internal async Task <WsItem> CopyItem(WsItem sourceItem, WsFolder targetFolder, CancellationToken cancellationToken, IProgress <int> progress)
{
if (sourceItem == null)
{
throw new ArgumentNullException(nameof(sourceItem));
}
if (targetFolder == null)
{
throw new ArgumentNullException(nameof(targetFolder));
}
if (cancellationToken == null)
{
throw new ArgumentNullException(nameof(cancellationToken));
}
progress?.Report(0);
if (sourceItem is WsFile sourceFile)
{
using (HttpResponseMessage response = await DownloadFile(sourceFile, cancellationToken))
{
long fileSize = response.Content.Headers.ContentLength ?? sourceFile.Size;
int bufferSize = CalculateBuffer(fileSize);
WsFilePath targetFilePath = new WsFilePath(targetFolder.PathInfo, sourceItem.PathInfoGeneric.Name);
using (TransportStream sourceTrasportStream = new TransportStream(await response.Content.ReadAsStreamAsync(), fileSize, null))
{
return(await UploadFile(sourceTrasportStream, fileSize, targetFilePath, cancellationToken, progress));
}
}
}
else
{
throw new NotSupportedException("Copy folder not supported.");
}
}
internal async Task DownloadFile(WsFile sourceFile, Stream targetStream, CancellationToken cancellationToken, IProgress <int> progress)
{
if (sourceFile == null)
{
throw new ArgumentNullException(nameof(sourceFile));
}
if (targetStream == null)
{
throw new ArgumentNullException(nameof(targetStream));
}
if (targetStream.CanWrite == false)
{
throw new NotSupportedException("The target stream does not support writing.");
}
if (cancellationToken == null)
{
throw new ArgumentNullException(nameof(cancellationToken));
}
progress?.Report(0);
using (HttpResponseMessage response = await DownloadFile(sourceFile, cancellationToken))
{
long fileSize = response.Content.Headers.ContentLength ?? sourceFile.Size;
using (TransportStream sourceTrasportStream = new TransportStream(await response.Content.ReadAsStreamAsync(), fileSize, progress))
{
await sourceTrasportStream.CopyToAsync(targetStream, CalculateBuffer(fileSize), cancellationToken);
progress?.Report(100);
}
}
}
static SecurityContext AuthenticateClient(TransportClient client)
{
TransportStream stream = client.GetStream();
byte[] clientToken;
byte[] serverToken;
// create client context
SecurityContext clientContext = authModule.CreateSecurityContext(clientCredentials, SecurityContextAttributes.Identify, null, out clientToken);
while (true)
{
if (clientToken != null)
{
// send client token to server
SendBuffer(stream, clientToken);
}
if (clientContext.State == SecurityContextState.Completed)
{
// authentication completed
break;
}
// receive server token
serverToken = ReceiveBuffer(stream);
// update security context
authModule.UpdateSecurityContext(clientContext, SecurityContextAttributes.Identify, serverToken, out clientToken);
}
return(clientContext);
}
internal async Task <WsFile> UploadFile(Stream sourceStream, long sourceSize, WsFilePath targetFilePath, bool ensureDeleteIfNeed, CancellationToken cancellationToken, IProgress <int> progress)
{
if (sourceStream == null)
{
throw new ArgumentNullException(nameof(sourceStream));
}
if (sourceStream.CanRead == false)
{
throw new NotSupportedException("The source stream does not support reading.");
}
if (cancellationToken == null)
{
throw new ArgumentNullException(nameof(cancellationToken));
}
CheckConnected();
progress?.Report(0);
if (ensureDeleteIfNeed)
{
WsFile file = await FindFile(targetFilePath);
if (file != null)
{
await file.Delete();
}
}
MultipartFormDataContent form = new MultipartFormDataContent();
form.Add(new StringContent(WebUtility.UrlEncode(targetFilePath.Name)), "name");
form.Add(new StringContent(_loginInfo.LoginToken), "wst");
form.Add(new StringContent(WebUtility.UrlEncode(targetFilePath.Folder.FullPath)), "folder");
form.Add(new StringContent(targetFilePath.IsPrivate ? "1" : "0"), "private");
form.Add(new StringContent("0"), "adult");
form.Add(new StringContent(sourceSize.ToString()), "total");
//form.Add(new StringContent(""), "offset");
TransportStream sourceTransportStream = new TransportStream(sourceStream, sourceSize, progress);
TransportStreamContent fileContent = new TransportStreamContent(sourceTransportStream, targetFilePath.Name, CalculateBuffer(sourceSize));
form.Add(fileContent);
UploadResult uploadResult = await _httpClient.PostFormData <UploadResult>(await GetUploadFileUrl(), form, cancellationToken, false, TimeSpan.FromHours(24));
if (string.IsNullOrWhiteSpace(uploadResult?.Ident))
{
throw new IOException($"Server upload error: result={uploadResult.Result}");
}
return(_createdFileResolver.Add(targetFilePath.Folder, targetFilePath.Name, uploadResult.Ident, sourceSize));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool CloseConnection()
{
bool close;
try
{
TransportStream.Close();
TcpClient.Close();
close = true;
}
catch (Exception)
{
throw;
}
return(close);
}
static void SendBuffer(TransportStream stream, byte[] buffer)
{
BinaryWriter writer = new BinaryWriter(stream);
if ((buffer != null) && (buffer.Length > 0))
{
// send buffer size
writer.Write((Int32)buffer.Length);
// send buffer data
writer.Write(buffer);
}
else
{
// send NULL size
writer.Write((Int32)0);
}
}
static byte[] ReceiveBuffer(TransportStream stream)
{
BinaryReader reader = new BinaryReader(stream);
// receive buffer size
int size = reader.ReadInt32();
if (size > 0)
{
// receive buffer data
byte[] buffer = new byte[size];
reader.Read(buffer, 0, size);
return(buffer);
}
else
{
return(null);
}
}
public async Task CompleteAsync()
{
Output.Writer.Complete();
Input.Reader.Complete();
if (_outputTask == null)
{
return;
}
// Wait for the output task to complete, this ensures that we've copied
// the application data to the underlying stream
await _outputTask;
// Cancel the underlying stream so that the input task yields
TransportStream.CancelPendingRead();
// The input task should yield now that we've cancelled it
await _inputTask;
}
/// <summary>
/// Ermittelt einen Kürzel zu dieser Kennung.
/// </summary>
/// <returns>Ein Kürzel, zusammengesesetzt aus den einzelnen Fragmenten
/// der Kennung.</returns>
public override int GetHashCode()
{
// Create
return(Network.GetHashCode() ^ TransportStream.GetHashCode() ^ Service.GetHashCode());
}
