marceloduplicatiandGitHub
99ee234640
* Primary functionality implemented for CIFS This will add CIFS support to Duplicati. One of the advantages is that the resource does not need to be mounted as the backend connects and authenticates directly to the resource via TCP/or Netbios over TCP. The authentication supported is domain/username/password. At present integrated Windows authentication is not supported. This implementation relies on SMBLibrary library (https://github.com/TalAloni/SMBLibrary). * Fixes to XML documentation * Implementing single CIFS connection + Fix on PutAsync Single CIFS connection to avoid re-authentication on every operation. Fix to PutAsync which only because apparent after file sizes were larger than _smb2Client.MaxWriteSize * Adding CI tests for CIFS The CI test for CIFS is self contained, requiring no environment variables. Also updated README.
441 lines
19 KiB
C#
441 lines
19 KiB
C#
// Copyright (C) 2024, The Duplicati Team
|
|
// https://duplicati.com, hello@duplicati.com
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the "Software"),
|
|
// to deal in the Software without restriction, including without limitation
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
// and/or sell copies of the Software, and to permit persons to whom the
|
|
// Software is furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
// DEALINGS IN THE SOFTWARE.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Duplicati.Library.Backend.CIFS.Model;
|
|
using Duplicati.Library.Common.IO;
|
|
using Duplicati.Library.Interface;
|
|
using Duplicati.Library.Localization.Short;
|
|
using SMBLibrary;
|
|
using SMBLibrary.Client;
|
|
using FileAttributes = SMBLibrary.FileAttributes;
|
|
|
|
namespace Duplicati.Library.Backend.CIFS;
|
|
|
|
/// <summary>
|
|
/// Class the wraps the SMB connection and file store objects, handling the connection,
|
|
/// logon and logoff operations as well as safely disposing resources.
|
|
/// </summary>
|
|
public class SMBShareConnection : IDisposable, IAsyncDisposable
|
|
{
|
|
/// <summary>
|
|
/// SMBConnection client
|
|
/// </summary>
|
|
private readonly SMB2Client _smb2Client = new();
|
|
|
|
/// <summary>
|
|
/// Shared fileStore object.
|
|
/// </summary>
|
|
private readonly ISMBFileStore _smbFileStore;
|
|
|
|
/// <summary>
|
|
/// Connection parameters
|
|
/// </summary>
|
|
private readonly SMBConnectionParameters _connectionParameters;
|
|
|
|
/// <summary>
|
|
/// The semaphore to ensure that only one operation is performed at a time.
|
|
/// </summary>
|
|
private readonly SemaphoreSlim _semaphore = new(1, 1);
|
|
|
|
private bool _disposed;
|
|
|
|
/// <summary>
|
|
/// This constructor will connect to the server and share as specified in the connection parameters.
|
|
///
|
|
/// It throws specific exceptions for connection and authentication failures.
|
|
/// </summary>
|
|
/// <param name="connectionParameters">Connection Parameters</param>
|
|
/// <exception cref="UserInformationException">Exception to be displayed to user</exception>
|
|
public SMBShareConnection(SMBConnectionParameters connectionParameters)
|
|
{
|
|
_connectionParameters = connectionParameters;
|
|
|
|
if (!_smb2Client.Connect(connectionParameters.ServerName, connectionParameters.TransportType))
|
|
throw new UserInformationException($"{LC.L("Failed to connect to server")} {connectionParameters.ServerName}", "ConnectionError");
|
|
|
|
var status = _smb2Client.Login(connectionParameters.AuthDomain, connectionParameters.AuthUser, connectionParameters.AuthPassword);
|
|
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to authenticate to server")} {connectionParameters.ServerName} with status {status}", "ConnectionError");
|
|
|
|
_smbFileStore = _smb2Client.TreeConnect(connectionParameters.ShareName, out status);
|
|
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to connect to share")} {connectionParameters.ShareName} with status {status}", "ConnectionError");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes the file specified in the path specified in the connection parameters.
|
|
/// </summary>
|
|
/// <param name="fileName">Filename to be deleted</param>
|
|
/// <param name="cancellationToken">The cancellation token</param>
|
|
/// <exception cref="UserInformationException">Exception to be displayed to user</exception>
|
|
public async Task DeleteAsync(string fileName, CancellationToken cancellationToken)
|
|
{
|
|
await _semaphore.WaitAsync(cancellationToken);
|
|
try
|
|
{
|
|
NTStatus status;
|
|
object fileHandle;
|
|
FileStatus fileStatus;
|
|
status = _smbFileStore.CreateFile(out fileHandle, out fileStatus, Path.Combine(_connectionParameters.Path, fileName),
|
|
AccessMask.GENERIC_WRITE | AccessMask.DELETE | AccessMask.SYNCHRONIZE,
|
|
FileAttributes.Normal,
|
|
ShareAccess.None,
|
|
CreateDisposition.FILE_OPEN,
|
|
CreateOptions.FILE_NON_DIRECTORY_FILE | CreateOptions.FILE_SYNCHRONOUS_IO_ALERT,
|
|
null);
|
|
|
|
if (status == NTStatus.STATUS_OBJECT_NAME_NOT_FOUND)
|
|
throw new FileMissingException();
|
|
|
|
if (status == NTStatus.STATUS_SUCCESS)
|
|
{
|
|
var fileDispositionInformation = new FileDispositionInformation
|
|
{
|
|
DeletePending = true
|
|
};
|
|
status = _smbFileStore.SetFileInformation(fileHandle, fileDispositionInformation);
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to delete file on DeleteAsync")} with status {status}", "DeleteFileError");
|
|
status = _smbFileStore.CloseFile(fileHandle);
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to close file on DeleteAsync")} with status {status}", "CloseFileError");
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_semaphore.Release();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create the folder structure specified in the path.
|
|
/// </summary>
|
|
/// <param name="path">Path to create</param>
|
|
/// <param name="cancellationToken">Cancellation Token</param>
|
|
/// <exception cref="UserInformationException">Exception to be displayed to user</exception>
|
|
public async Task CreateFolderAsync(string path, CancellationToken cancellationToken)
|
|
{
|
|
await _semaphore.WaitAsync(cancellationToken);
|
|
try
|
|
{
|
|
// Normalize path separators to forward slashes and trim any trailing separators
|
|
string normalizedPath = path.Replace('\\', '/').TrimEnd('/');
|
|
string currentPath = "";
|
|
|
|
foreach (string part in normalizedPath.Split('/', StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
if (string.IsNullOrWhiteSpace(part) || part == ".")
|
|
continue;
|
|
|
|
currentPath = currentPath.Length == 0 ? part : $"{currentPath}/{part}";
|
|
object? fileHandle = null;
|
|
try
|
|
{
|
|
NTStatus status = _smbFileStore.CreateFile(
|
|
out fileHandle,
|
|
out FileStatus fileStatus,
|
|
currentPath,
|
|
AccessMask.GENERIC_WRITE | AccessMask.SYNCHRONIZE,
|
|
FileAttributes.Normal,
|
|
ShareAccess.None,
|
|
CreateDisposition.FILE_CREATE,
|
|
CreateOptions.FILE_DIRECTORY_FILE | CreateOptions.FILE_SYNCHRONOUS_IO_ALERT,
|
|
null
|
|
);
|
|
if (status != NTStatus.STATUS_SUCCESS &&
|
|
status != NTStatus.STATUS_OBJECT_NAME_COLLISION) // Ignore if directory already exists
|
|
throw new UserInformationException($"{LC.L("Failed to create directory")} {currentPath} with status{status}", "CreateDirectoryError");
|
|
}
|
|
finally
|
|
{
|
|
if (fileHandle != null)
|
|
{
|
|
var status = _smbFileStore.CloseFile(fileHandle);
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to close file handle on CreateFolderAsync")} with status {status.ToString()}", "HandleCloseError");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_semaphore.Release();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lists the folder contents of the share and path specified in the connection parameters.
|
|
/// </summary>
|
|
/// <param name="cancellationToken">Cancellation Token</param>
|
|
/// <exception cref="UserInformationException">Exception to be displayed to user</exception>
|
|
public async Task<List<IFileEntry>> ListAsync(CancellationToken cancellationToken)
|
|
{
|
|
await _semaphore.WaitAsync(cancellationToken);
|
|
|
|
object? directoryHandle = null;
|
|
FileStatus fileStatus;
|
|
try
|
|
{
|
|
try
|
|
{
|
|
|
|
var status = _smbFileStore.CreateFile(
|
|
out directoryHandle,
|
|
out fileStatus,
|
|
_connectionParameters.Path,
|
|
AccessMask.GENERIC_READ,
|
|
FileAttributes.Directory,
|
|
ShareAccess.Read | ShareAccess.Write,
|
|
CreateDisposition.FILE_OPEN,
|
|
CreateOptions.FILE_DIRECTORY_FILE,
|
|
null);
|
|
|
|
if (status != NTStatus.STATUS_SUCCESS && fileStatus != FileStatus.FILE_OPENED)
|
|
if (status == NTStatus.STATUS_OBJECT_PATH_NOT_FOUND || status == NTStatus.STATUS_OBJECT_NAME_NOT_FOUND)
|
|
throw new FolderMissingException();
|
|
else
|
|
throw new UserInformationException($"{LC.L("Failed to open directory")} {_connectionParameters.Path} with status {status.ToString()}","DirectoryOpenError");
|
|
|
|
List<QueryDirectoryFileInformation> fileList;
|
|
status = _smbFileStore.QueryDirectory(
|
|
out fileList,
|
|
directoryHandle,
|
|
"*",
|
|
FileInformationClass.FileDirectoryInformation);
|
|
|
|
if (status != NTStatus.STATUS_NO_MORE_FILES)
|
|
throw new UserInformationException($"{LC.L("Failed to query directory contents")} with status {status.ToString()}","DirectoryQueryError");
|
|
|
|
return
|
|
[
|
|
..fileList
|
|
.OfType<FileDirectoryInformation>()
|
|
.Select(info => new FileEntry(
|
|
info.FileName,
|
|
info.EndOfFile,
|
|
info.LastAccessTime,
|
|
info.LastWriteTime)
|
|
{
|
|
IsFolder = info.FileAttributes == FileAttributes.Directory
|
|
})
|
|
.ToList()
|
|
];
|
|
}
|
|
finally
|
|
{
|
|
if (directoryHandle != null)
|
|
{
|
|
var status = _smbFileStore.CloseFile(directoryHandle);
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to close directory handle on ListAsync")} with status {status.ToString()}", "HandleCloseError");
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_semaphore.Release();
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a file from source and write it to the destination stream.
|
|
/// </summary>
|
|
/// <param name="filename">Filename to be read</param>
|
|
/// <param name="destinationStream">Destination stream to write contents read from source</param>
|
|
/// <param name="cancellationToken">Cancellation Token</param>
|
|
public async Task GetAsync(string filename, Stream destinationStream, CancellationToken cancellationToken)
|
|
{
|
|
await _semaphore.WaitAsync(cancellationToken);
|
|
|
|
try
|
|
{
|
|
object? fileHandle;
|
|
FileStatus fileStatus;
|
|
NTStatus status = _smbFileStore.CreateFile(out fileHandle, out fileStatus,
|
|
Path.Combine(_connectionParameters.Path, filename), // This is where the file name is concatenated with the path
|
|
AccessMask.GENERIC_READ | AccessMask.SYNCHRONIZE, FileAttributes.Normal, ShareAccess.Read,
|
|
CreateDisposition.FILE_OPEN,
|
|
CreateOptions.FILE_NON_DIRECTORY_FILE | CreateOptions.FILE_SYNCHRONOUS_IO_ALERT, null);
|
|
|
|
if (status == NTStatus.STATUS_SUCCESS || fileStatus != FileStatus.FILE_DOES_NOT_EXIST)
|
|
{
|
|
byte[] data;
|
|
long bytesRead = 0;
|
|
while (!cancellationToken.IsCancellationRequested)
|
|
{
|
|
status = _smbFileStore.ReadFile(out data, fileHandle, bytesRead, (int)_smb2Client.MaxReadSize);
|
|
if (status != NTStatus.STATUS_SUCCESS && status != NTStatus.STATUS_END_OF_FILE)
|
|
throw new UserInformationException($"{LC.L("Failed to read file on GetAsync")} {filename} with status {status.ToString()}","FileReadError");
|
|
|
|
if (status == NTStatus.STATUS_END_OF_FILE || data.Length == 0)
|
|
break;
|
|
|
|
bytesRead += data.Length;
|
|
await destinationStream.WriteAsync(data, 0, data.Length, cancellationToken);
|
|
}
|
|
|
|
await destinationStream.FlushAsync(cancellationToken);
|
|
|
|
if (fileHandle != null)
|
|
{
|
|
status = _smbFileStore.CloseFile(fileHandle);
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to close file handle on GetAsync")} {filename} with status {status.ToString()}", "HandleCloseError");
|
|
}
|
|
}
|
|
else if (status == NTStatus.STATUS_OBJECT_NAME_NOT_FOUND)
|
|
throw new FileMissingException($"{LC.L("The requested file does not exist")} {filename}");
|
|
else if (status == NTStatus.STATUS_OBJECT_PATH_NOT_FOUND)
|
|
throw new FolderMissingException();
|
|
else
|
|
throw new UserInformationException(
|
|
$"{LC.L("Failed to open file with error")} {filename} with status {status.ToString()}",
|
|
"FileOpenError");
|
|
}
|
|
finally
|
|
{
|
|
_semaphore.Release();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes file in the remote share and path specified in the connection parameters reading
|
|
/// from the sourceStream provided.
|
|
/// </summary>
|
|
/// <param name="filename"></param>
|
|
/// <param name="sourceStream"></param>
|
|
/// <param name="cancellationToken"></param>
|
|
/// <exception cref="Exception"></exception>
|
|
public async Task PutAsync(string filename, Stream sourceStream, CancellationToken cancellationToken)
|
|
{
|
|
await _semaphore.WaitAsync(cancellationToken);
|
|
try
|
|
{
|
|
object fileHandle;
|
|
FileStatus fileStatus;
|
|
NTStatus status = _smbFileStore.CreateFile(out fileHandle, out fileStatus,
|
|
Path.Combine(_connectionParameters.Path, filename), // This is where the file name is concatenated with the path
|
|
AccessMask.GENERIC_WRITE | AccessMask.SYNCHRONIZE,
|
|
FileAttributes.Normal, ShareAccess.None,
|
|
CreateDisposition.FILE_SUPERSEDE,
|
|
CreateOptions.FILE_NON_DIRECTORY_FILE | CreateOptions.FILE_SYNCHRONOUS_IO_ALERT,
|
|
null);
|
|
if (status == NTStatus.STATUS_SUCCESS)
|
|
{
|
|
|
|
byte[] buffer = new byte[_smb2Client.MaxWriteSize];
|
|
int bytesRead;
|
|
int numberOfBytesWritten;
|
|
int offset = 0;
|
|
while (!cancellationToken.IsCancellationRequested && sourceStream.Position < sourceStream.Length)
|
|
{
|
|
bytesRead = await sourceStream.ReadAsync(buffer, cancellationToken);
|
|
if (bytesRead == 0)
|
|
break;
|
|
status = _smbFileStore.WriteFile(out numberOfBytesWritten, fileHandle, offset, buffer.Take(bytesRead).ToArray());
|
|
offset += numberOfBytesWritten;
|
|
if (numberOfBytesWritten != bytesRead)
|
|
throw new UserInformationException(LC.L("Failed to write to file, difference between bytes read and bytes written"), "HandleWriteError");
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to write file on Putasync")} {filename} with status {status.ToString()}", "HandleWriteError");
|
|
}
|
|
if (fileHandle != null)
|
|
{
|
|
status = _smbFileStore.CloseFile(fileHandle);
|
|
if (status != NTStatus.STATUS_SUCCESS)
|
|
throw new UserInformationException($"{LC.L("Failed to close file handle on PutAsync")} {filename} with status {status.ToString()}", "HandleCloseError");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new UserInformationException($"{LC.L("Failed to create file for writing")} {filename} with status {status.ToString()}", "FileCreateError");
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_semaphore.Release();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Synchronously dispose the resources.
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
DisposeResourcesAsync().AsTask().GetAwaiter().GetResult();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Async dispose implementation
|
|
/// </summary>
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
await DisposeResourcesAsync();
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inner dispose implementation
|
|
/// </summary>
|
|
private async ValueTask DisposeResourcesAsync()
|
|
{
|
|
if (_disposed) return;
|
|
|
|
await _semaphore.WaitAsync(); // Ensure no operations are in progress
|
|
try
|
|
{
|
|
if (_smbFileStore != null)
|
|
{
|
|
try
|
|
{
|
|
await Task.Run(() => _smbFileStore.Disconnect());
|
|
}
|
|
catch { /* Can be safely ignored */ }
|
|
}
|
|
|
|
if (_smb2Client != null)
|
|
{
|
|
try
|
|
{
|
|
await Task.Run(() => _smb2Client.Logoff());
|
|
await Task.Run(() => _smb2Client.Disconnect());
|
|
}
|
|
catch { /* Can be safely ignored */ }
|
|
}
|
|
|
|
_semaphore.Dispose();
|
|
}
|
|
finally
|
|
{
|
|
_disposed = true;
|
|
}
|
|
}
|
|
}
|