Kenneth Skovhede
1716d09b51
Made the SMBShareConnection slightly more robust. Introduced v2 List API to S3 backend, currently it retains v1 as the default. Changed S3 backends to not recurse, potentially making smaller listings. This option can be disabled if it breaks things. Added support for relative paths in the SSH backend.
458 lines
20 KiB
C#
458 lines
20 KiB
C#
// Copyright (C) 2025, 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.
|
|
|
|
#nullable enable
|
|
|
|
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, NormalizeSlashes(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 linuxNormalizedPath = path.Replace('/', '\\').TrimEnd('\\');
|
|
string currentPath = "";
|
|
|
|
foreach (string part in linuxNormalizedPath.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="path">Path to list</param>
|
|
/// <param name="cancellationToken">Cancellation Token</param>
|
|
/// <exception cref="UserInformationException">Exception to be displayed to user</exception>
|
|
public async Task<List<IFileEntry>> ListAsync(string path, CancellationToken cancellationToken)
|
|
{
|
|
await _semaphore.WaitAsync(cancellationToken);
|
|
|
|
object? directoryHandle = null;
|
|
FileStatus fileStatus;
|
|
try
|
|
{
|
|
try
|
|
{
|
|
var status = _smbFileStore.CreateFile(
|
|
out directoryHandle,
|
|
out fileStatus,
|
|
NormalizeSlashes(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")} {NormalizeSlashes(path)} with status {status}", "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}", "DirectoryQueryError");
|
|
|
|
return
|
|
[
|
|
..fileList
|
|
.OfType<FileDirectoryInformation>()
|
|
.Select(info => new FileEntry(
|
|
info.FileName,
|
|
info.EndOfFile,
|
|
info.LastAccessTime,
|
|
info.LastWriteTime)
|
|
{
|
|
IsFolder = info.FileAttributes == FileAttributes.Directory,
|
|
Created = info.CreationTime
|
|
})
|
|
.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,
|
|
NormalizeSlashes(Path.Combine(_connectionParameters.Path, filename)),
|
|
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)
|
|
{
|
|
// Use the provided read buffer size if set, otherwise use the protocol negotiated maximum. Never exceed the negotiated maximum.
|
|
int readBufferSize = Math.Min(_connectionParameters.ReadBufferSize ?? (int)_smb2Client.MaxReadSize, (int)_smb2Client.MaxReadSize);
|
|
status = _smbFileStore.ReadFile(out data, fileHandle, bytesRead, readBufferSize);
|
|
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,
|
|
NormalizeSlashes(Path.Combine(_connectionParameters.Path, filename)),
|
|
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)
|
|
{
|
|
// Use the provided write buffer size if set, otherwise use the protocol negotiated maximum. Never exceed the negotiated maximum.
|
|
byte[] buffer = new byte[Math.Min(_connectionParameters.WriteBufferSize ?? (int)_smb2Client.MaxWriteSize, _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>
|
|
/// Normalizes paths to use backslashes (for Windows shares compatibility) and removes trailing slashes.
|
|
///
|
|
/// Samba deals with \ and / in paths, but Windows shares require backslashes.
|
|
/// </summary>
|
|
/// <param name="path">Path to be normalized</param>
|
|
/// <returns></returns>
|
|
private string NormalizeSlashes(string path)
|
|
{
|
|
return path.Replace('/', '\\').TrimEnd('\\');
|
|
}
|
|
|
|
/// <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;
|
|
}
|
|
}
|
|
}
|