// Token: 0x06000947 RID: 2375 RVA: 0x0004BB88 File Offset: 0x00049D88
public Stream Download(INode node, CancellationToken?cancellationToken = null)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (node.Type != NodeType.File)
{
throw new ArgumentException("Invalid node");
}
INodeCrypto nodeCrypto = node as INodeCrypto;
if (nodeCrypto == null)
{
throw new ArgumentException("node must implement INodeCrypto");
}
this.EnsureLoggedIn();
DownloadUrlRequest request = new DownloadUrlRequest(node);
DownloadUrlResponse downloadUrlResponse = this.Request <DownloadUrlResponse>(request, null);
Stream stream = new MegaAesCtrStreamDecrypter(new BufferedStream(this.webClient.GetRequestRaw(new Uri(downloadUrlResponse.Url))), downloadUrlResponse.Size, nodeCrypto.Key, nodeCrypto.Iv, nodeCrypto.MetaMac);
if (cancellationToken != null)
{
stream = new CancellableStream(stream, cancellationToken.Value);
}
return(stream);
}
public Stream Download(Uri uri, CancellationToken?cancellationToken = null)
#endif
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
this.EnsureLoggedIn();
string id;
byte[] iv, metaMac, key;
this.GetPartsFromUri(uri, out id, out iv, out metaMac, out key);
// Retrieve download URL
DownloadUrlRequestFromId downloadRequest = new DownloadUrlRequestFromId(id);
DownloadUrlResponse downloadResponse = this.Request <DownloadUrlResponse>(downloadRequest);
Stream dataStream = this.webClient.GetRequestRaw(new Uri(downloadResponse.Url));
Stream resultStream = new MegaAesCtrStreamDecrypter(dataStream, downloadResponse.Size, key, iv, metaMac);
#if !NET35
if (cancellationToken.HasValue)
{
resultStream = new CancellableStream(resultStream, cancellationToken.Value);
}
#endif
return(resultStream);
}
/// <summary>
/// Retrieve a Stream to download and decrypt the specified Uri
/// </summary>
/// <param name="uri">Uri to download</param>
/// <exception cref="NotSupportedException">Not logged in</exception>
/// <exception cref="ApiException">Mega.co.nz service reports an error</exception>
/// <exception cref="ArgumentNullException">uri is null</exception>
/// <exception cref="ArgumentException">Uri is not valid (id and key are required)</exception>
/// <exception cref="DownloadException">Checksum is invalid. Downloaded data are corrupted</exception>
public Stream Download(Uri uri, CancellationToken?cancellationToken = null)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
this.EnsureLoggedIn();
string id;
byte[] iv, metaMac, key;
this.GetPartsFromUri(uri, out id, out iv, out metaMac, out key);
// Retrieve download URL
DownloadUrlRequestFromId downloadRequest = new DownloadUrlRequestFromId(id);
DownloadUrlResponse downloadResponse = this.Request <DownloadUrlResponse>(downloadRequest);
Uri downloadUrl = new Uri(downloadResponse.Url);
Stream dataStream = new SeekableReadStream(this.webClient.GetLength(downloadUrl), (buffer, bufferOffset, offset, count)
=> this.webClient.GetRequestRawWithRange(
downloadUrl, offset, offset + count).Read(buffer, bufferOffset, count));
Stream resultStream = new MegaAesCtrStreamDecrypter(dataStream, downloadResponse.Size, key, iv, metaMac);
if (cancellationToken.HasValue)
{
resultStream = new CancellableStream(resultStream, cancellationToken.Value);
}
return(resultStream);
}
/// <summary>
/// Retrieve a Stream to download and decrypt the specified node
/// </summary>
/// <param name="node">Node to download (only <see cref="NodeType.File" /> can be downloaded)</param>
/// <exception cref="NotSupportedException">Not logged in</exception>
/// <exception cref="ApiException">Mega.co.nz service reports an error</exception>
/// <exception cref="ArgumentNullException">node or outputFile is null</exception>
/// <exception cref="ArgumentException">node is not valid (only <see cref="NodeType.File" /> can be downloaded)</exception>
/// <exception cref="DownloadException">Checksum is invalid. Downloaded data are corrupted</exception>
public Stream Download(INode node, CancellationToken?cancellationToken = null)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (node.Type != NodeType.File)
{
throw new ArgumentException("Invalid node");
}
INodeCrypto nodeCrypto = node as INodeCrypto;
if (nodeCrypto == null)
{
throw new ArgumentException("node must implement INodeCrypto");
}
this.EnsureLoggedIn();
// Retrieve download URL
DownloadUrlRequest downloadRequest = new DownloadUrlRequest(node);
DownloadUrlResponse downloadResponse = this.Request <DownloadUrlResponse>(downloadRequest);
Uri downloadUrl = new Uri(downloadResponse.Url);
Stream dataStream = new SeekableReadStream(this.webClient.GetLength(downloadUrl), (buffer, bufferOffset, offset, count)
=> this.webClient.GetRequestRawWithRange(
downloadUrl, offset, offset + count).Read(buffer, bufferOffset, count));
Stream resultStream = new MegaAesCtrStreamDecrypter(dataStream, downloadResponse.Size, nodeCrypto.Key, nodeCrypto.Iv, nodeCrypto.MetaMac);
if (cancellationToken.HasValue)
{
resultStream = new CancellableStream(resultStream, cancellationToken.Value);
}
return(resultStream);
}
public Stream Download(INode node, CancellationToken?cancellationToken = null)
#endif
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (node.Type != NodeType.File)
{
throw new ArgumentException("Invalid node");
}
INodeCrypto nodeCrypto = node as INodeCrypto;
if (nodeCrypto == null)
{
throw new ArgumentException("node must implement INodeCrypto");
}
this.EnsureLoggedIn();
// Retrieve download URL
DownloadUrlRequest downloadRequest = new DownloadUrlRequest(node);
DownloadUrlResponse downloadResponse = this.Request <DownloadUrlResponse>(downloadRequest);
Stream dataStream = this.webClient.GetRequestRaw(new Uri(downloadResponse.Url));
Stream resultStream = new MegaAesCtrStreamDecrypter(dataStream, downloadResponse.Size, nodeCrypto.Key, nodeCrypto.Iv, nodeCrypto.MetaMac);
#if !NET35
if (cancellationToken.HasValue)
{
resultStream = new CancellableStream(resultStream, cancellationToken.Value);
}
#endif
return(resultStream);
}
// Token: 0x06000948 RID: 2376 RVA: 0x0004BC34 File Offset: 0x00049E34
public Stream Download(Uri uri, CancellationToken?cancellationToken = null)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
this.EnsureLoggedIn();
string id;
byte[] iv;
byte[] expectedMetaMac;
byte[] fileKey;
this.GetPartsFromUri(uri, out id, out iv, out expectedMetaMac, out fileKey);
DownloadUrlRequestFromId request = new DownloadUrlRequestFromId(id);
DownloadUrlResponse downloadUrlResponse = this.Request <DownloadUrlResponse>(request, null);
Stream stream = new MegaAesCtrStreamDecrypter(new BufferedStream(this.webClient.GetRequestRaw(new Uri(downloadUrlResponse.Url))), downloadUrlResponse.Size, fileKey, iv, expectedMetaMac);
if (cancellationToken != null)
{
stream = new CancellableStream(stream, cancellationToken.Value);
}
return(stream);
}
// Token: 0x0600094C RID: 2380 RVA: 0x0004BE18 File Offset: 0x0004A018
public INode Upload(Stream stream, string name, INode parent, DateTime?modificationDate = null, CancellationToken?cancellationToken = null)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
if (parent == null)
{
throw new ArgumentNullException("parent");
}
if (parent.Type == NodeType.File)
{
throw new ArgumentException("Invalid parent node");
}
this.EnsureLoggedIn();
if (cancellationToken != null)
{
stream = new CancellableStream(stream, cancellationToken.Value);
}
string text = string.Empty;
int num = 0;
TimeSpan retryDelay;
while (this.options.ComputeApiRequestRetryWaitDelay(++num, out retryDelay))
{
UploadUrlRequest request = new UploadUrlRequest(stream.Length);
UploadUrlResponse uploadUrlResponse = this.Request <UploadUrlResponse>(request, null);
ApiResultCode apiResultCode = ApiResultCode.Ok;
using (MegaAesCtrStreamCrypter megaAesCtrStreamCrypter = new MegaAesCtrStreamCrypter(stream))
{
long num2 = 0L;
int[] array = this.ComputeChunksSizesToUpload(megaAesCtrStreamCrypter.ChunksPositions, megaAesCtrStreamCrypter.Length).ToArray <int>();
Uri url = null;
for (int i = 0; i < array.Length; i++)
{
text = string.Empty;
int num3 = array[i];
byte[] buffer = new byte[num3];
megaAesCtrStreamCrypter.Read(buffer, 0, num3);
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
url = new Uri(uploadUrlResponse.Url + "/" + num2);
num2 += (long)num3;
try
{
text = this.webClient.PostRequestRaw(url, memoryStream);
long num4;
if (string.IsNullOrEmpty(text))
{
apiResultCode = ApiResultCode.Ok;
}
else if (text.FromBase64().Length != 27 && long.TryParse(text, out num4))
{
apiResultCode = (ApiResultCode)num4;
break;
}
}
catch (Exception exception)
{
apiResultCode = ApiResultCode.RequestFailedRetry;
EventHandler <ApiRequestFailedEventArgs> apiRequestFailed = this.ApiRequestFailed;
if (apiRequestFailed != null)
{
apiRequestFailed(this, new ApiRequestFailedEventArgs(url, num, retryDelay, apiResultCode, exception));
}
break;
}
}
}
if (apiResultCode == ApiResultCode.Ok)
{
byte[] data = Crypto.EncryptAttributes(new Attributes(name, stream, modificationDate), megaAesCtrStreamCrypter.FileKey);
byte[] array2 = new byte[32];
for (int j = 0; j < 8; j++)
{
array2[j] = (megaAesCtrStreamCrypter.FileKey[j] ^ megaAesCtrStreamCrypter.Iv[j]);
array2[j + 16] = megaAesCtrStreamCrypter.Iv[j];
}
for (int k = 8; k < 16; k++)
{
array2[k] = (megaAesCtrStreamCrypter.FileKey[k] ^ megaAesCtrStreamCrypter.MetaMac[k - 8]);
array2[k + 16] = megaAesCtrStreamCrypter.MetaMac[k - 8];
}
byte[] data2 = Crypto.EncryptKey(array2, this.masterKey);
CreateNodeRequest request2 = CreateNodeRequest.CreateFileNodeRequest(parent, data.ToBase64(), data2.ToBase64(), array2, text);
return(this.Request <GetNodesResponse>(request2, this.masterKey).Nodes[0]);
}
EventHandler <ApiRequestFailedEventArgs> apiRequestFailed2 = this.ApiRequestFailed;
if (apiRequestFailed2 != null)
{
apiRequestFailed2(this, new ApiRequestFailedEventArgs(url, num, retryDelay, apiResultCode, text));
}
if (apiResultCode != ApiResultCode.RequestFailedRetry && apiResultCode != ApiResultCode.RequestFailedPermanetly)
{
if (apiResultCode != ApiResultCode.TooManyRequests)
{
throw new ApiException(apiResultCode);
}
}
this.Wait(retryDelay);
stream.Seek(0L, SeekOrigin.Begin);
}
}
throw new UploadException(text);
}
public INode Upload(Stream stream, string name, INode parent, DateTime?modificationDate = null, CancellationToken?cancellationToken = null)
#endif
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
if (parent == null)
{
throw new ArgumentNullException("parent");
}
if (parent.Type == NodeType.File)
{
throw new ArgumentException("Invalid parent node");
}
this.EnsureLoggedIn();
#if !NET35
if (cancellationToken.HasValue)
{
stream = new CancellableStream(stream, cancellationToken.Value);
}
#endif
string completionHandle = string.Empty;
int requestDelay = this.options.ApiRequestDelay;
int remainingRetry = this.options.ApiRequestAttempts;
while (remainingRetry-- > 0)
{
// Retrieve upload URL
UploadUrlRequest uploadRequest = new UploadUrlRequest(stream.Length);
UploadUrlResponse uploadResponse = this.Request <UploadUrlResponse>(uploadRequest);
ApiResultCode apiResult = ApiResultCode.Ok;
using (MegaAesCtrStreamCrypter encryptedStream = new MegaAesCtrStreamCrypter(stream))
{
var chunkStartPosition = 0;
var chunksSizesToUpload = this.ComputeChunksSizesToUpload(encryptedStream.ChunksPositions, encryptedStream.Length).ToArray();
Uri uri = null;
for (int i = 0; i < chunksSizesToUpload.Length; i++)
{
completionHandle = string.Empty;
int chunkSize = chunksSizesToUpload[i];
byte[] chunkBuffer = new byte[chunkSize];
encryptedStream.Read(chunkBuffer, 0, chunkSize);
using (MemoryStream chunkStream = new MemoryStream(chunkBuffer))
{
uri = new Uri(uploadResponse.Url + "/" + chunkStartPosition);
chunkStartPosition += chunkSize;
try
{
completionHandle = this.webClient.PostRequestRaw(uri, chunkStream);
if (string.IsNullOrEmpty(completionHandle))
{
apiResult = ApiResultCode.Ok;
continue;
}
long retCode;
if (completionHandle.FromBase64().Length != 27 && long.TryParse(completionHandle, out retCode))
{
apiResult = (ApiResultCode)retCode;
break;
}
}
catch (Exception ex)
{
apiResult = ApiResultCode.RequestFailedRetry;
this.ApiRequestFailed?.Invoke(this, new ApiRequestFailedEventArgs(uri, remainingRetry, requestDelay, apiResult, ex));
break;
}
}
}
if (apiResult != ApiResultCode.Ok)
{
this.ApiRequestFailed?.Invoke(this, new ApiRequestFailedEventArgs(uri, remainingRetry, requestDelay, apiResult, completionHandle));
if (apiResult == ApiResultCode.RequestFailedRetry || apiResult == ApiResultCode.RequestFailedPermanetly || apiResult == ApiResultCode.TooManyRequests)
{
// Restart upload from the beginning
requestDelay = this.Wait(requestDelay);
// Reset steam position
stream.Seek(0, SeekOrigin.Begin);
continue;
}
throw new ApiException(apiResult);
}
// Encrypt attributes
byte[] cryptedAttributes = Crypto.EncryptAttributes(new Attributes(name, stream, modificationDate), encryptedStream.FileKey);
// Compute the file key
byte[] fileKey = new byte[32];
for (int i = 0; i < 8; i++)
{
fileKey[i] = (byte)(encryptedStream.FileKey[i] ^ encryptedStream.Iv[i]);
fileKey[i + 16] = encryptedStream.Iv[i];
}
for (int i = 8; i < 16; i++)
{
fileKey[i] = (byte)(encryptedStream.FileKey[i] ^ encryptedStream.MetaMac[i - 8]);
fileKey[i + 16] = encryptedStream.MetaMac[i - 8];
}
byte[] encryptedKey = Crypto.EncryptKey(fileKey, this.masterKey);
CreateNodeRequest createNodeRequest = CreateNodeRequest.CreateFileNodeRequest(parent, cryptedAttributes.ToBase64(), encryptedKey.ToBase64(), fileKey, completionHandle);
GetNodesResponse createNodeResponse = this.Request <GetNodesResponse>(createNodeRequest, this.masterKey);
return(createNodeResponse.Nodes[0]);
}
}
throw new UploadException(completionHandle);
}
