/// <summary>
/// Given a <see cref="B2UploadUrl"/> returned from the API, attempts to upload a file.
/// </summary>
/// <param name="b2UploadUrl">Information returned by the <c>b2_get_upload_url</c> API.</param>
/// <param name="destinationPath">The remote path to upload to.</param>
/// <param name="file">The file to upload.</param>
/// <returns>
/// A B2UploadResult(HTTP status, B2Error, B2Upload) that can be decomposed as follows:
///
/// <ul>
/// <li><b>If successful:</b> <c>(200, null, B2Upload)</c></li>
/// <li><b>If unsuccessful:</b> <c>(HTTP status, B2Error, null)</c></li>
/// <li><b>If the connection failed:</b> <c>(-1, null, null)</c></li>
/// </ul>
/// </returns>
private B2UploadResult B2ApiUploadFile(B2UploadUrl b2UploadUrl, string destinationPath, Stream file)
{
// we want to send 'Content-Disposition: inline; filename="screenshot.png"'
// this should display the uploaded data inline if possible, but if that fails, present a sensible filename
// conveniently, this class will handle this for us
ContentDisposition contentDisposition = new ContentDisposition("inline")
{
FileName = URLHelpers.GetFileName(destinationPath)
};
DebugHelper.WriteLine($"B2 uploader: Content disposition is '{contentDisposition}'.");
// compute SHA1 hash without loading the file fully into memory
string sha1Hash;
using (SHA1CryptoServiceProvider cryptoProvider = new SHA1CryptoServiceProvider())
{
file.Seek(0, SeekOrigin.Begin);
byte[] bytes = cryptoProvider.ComputeHash(file);
sha1Hash = BitConverter.ToString(bytes).Replace("-", "").ToLower();
file.Seek(0, SeekOrigin.Begin);
}
DebugHelper.WriteLine($"B2 uploader: SHA1 hash is '{sha1Hash}'.");
// it's showtime
// https://www.backblaze.com/b2/docs/b2_upload_file.html
NameValueCollection headers = new NameValueCollection()
{
["Authorization"] = b2UploadUrl.authorizationToken,
["X-Bz-File-Name"] = URLHelpers.URLEncode(destinationPath),
["Content-Length"] = file.Length.ToString(),
["X-Bz-Content-Sha1"] = sha1Hash,
["X-Bz-Info-src_last_modified_millis"] = DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString(),
["X-Bz-Info-b2-content-disposition"] = URLHelpers.URLEncode(contentDisposition.ToString()),
};
string contentType = RequestHelpers.GetMimeType(destinationPath);
using (HttpWebResponse res = GetResponse(HttpMethod.POST, b2UploadUrl.uploadUrl,
contentType: contentType, headers: headers, data: file, allowNon2xxResponses: true))
{
// if connection failed, res will be null, and here we -do- want to check explicitly for this
// since the server might be down
if (res == null)
{
return(new B2UploadResult(-1, null, null));
}
if (res.StatusCode != HttpStatusCode.OK)
{
return(new B2UploadResult((int)res.StatusCode, ParseB2Error(res), null));
}
string body = RequestHelpers.ResponseToString(res);
DebugHelper.WriteLine($"B2 uploader: B2ApiUploadFile() reports success! '{body}'");
return(new B2UploadResult((int)res.StatusCode, null, JsonConvert.DeserializeObject <B2Upload>(body)));
}
}
public override UploadResult Upload(Stream stream, string fileName)
{
if (string.IsNullOrEmpty(AzureStorageAccountName))
{
Errors.Add("'Account Name' must not be empty");
}
if (string.IsNullOrEmpty(AzureStorageAccountAccessKey))
{
Errors.Add("'Access key' must not be empty");
}
if (string.IsNullOrEmpty(AzureStorageContainer))
{
Errors.Add("'Container' must not be empty");
}
if (IsError)
{
return(null);
}
string date = DateTime.UtcNow.ToString("R", CultureInfo.InvariantCulture);
string uploadPath = GetUploadPath(fileName);
string requestURL = GenerateURL(uploadPath, true);
string resultURL = GenerateURL(uploadPath);
OnEarlyURLCopyRequested(resultURL);
string contentType = RequestHelpers.GetMimeType(fileName);
NameValueCollection requestHeaders = new NameValueCollection();
requestHeaders["x-ms-date"] = date;
requestHeaders["x-ms-version"] = APIVersion;
requestHeaders["x-ms-blob-type"] = "BlockBlob";
string canonicalizedHeaders = $"x-ms-blob-type:BlockBlob\nx-ms-date:{date}\nx-ms-version:{APIVersion}\n";
string canonicalizedResource = $"/{AzureStorageAccountName}/{AzureStorageContainer}/{uploadPath}";
string stringToSign = GenerateStringToSign(canonicalizedHeaders, canonicalizedResource, stream.Length.ToString(), contentType);
requestHeaders["Authorization"] = $"SharedKey {AzureStorageAccountName}:{stringToSign}";
SendRequest(HttpMethod.PUT, requestURL, stream, contentType, null, requestHeaders);
if (LastResponseInfo != null && LastResponseInfo.IsSuccess)
{
return(new UploadResult
{
IsSuccess = true,
URL = resultURL
});
}
Errors.Add("Upload failed.");
return(null);
}
public override UploadResult Upload(Stream stream, string fileName)
{
if (string.IsNullOrEmpty(Host))
{
throw new Exception("ownCloud Host is empty.");
}
if (string.IsNullOrEmpty(Username) || string.IsNullOrEmpty(Password))
{
throw new Exception("ownCloud Username or Password is empty.");
}
if (string.IsNullOrEmpty(Path))
{
Path = "/";
}
// Original, unencoded path. Necessary for shared files
string path = URLHelpers.CombineURL(Path, fileName);
// Encoded path, necessary when sent in the URL
string encodedPath = URLHelpers.CombineURL(Path, URLHelpers.URLEncode(fileName));
string url = URLHelpers.CombineURL(Host, "remote.php/webdav", encodedPath);
url = URLHelpers.FixPrefix(url);
NameValueCollection headers = RequestHelpers.CreateAuthenticationHeader(Username, Password);
headers["OCS-APIREQUEST"] = "true";
string response = SendRequest(HttpMethod.PUT, url, stream, RequestHelpers.GetMimeType(fileName), null, headers);
UploadResult result = new UploadResult(response);
if (!IsError)
{
if (CreateShare)
{
AllowReportProgress = false;
result.URL = ShareFile(path);
}
else
{
result.IsURLExpected = false;
}
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
if (string.IsNullOrEmpty(Settings.URL))
{
throw new Exception("Plik Host is empty.");
}
NameValueCollection requestHeaders = new NameValueCollection();
requestHeaders["X-PlikToken"] = Settings.APIKey;
UploadMetadataRequest metaDataReq = new UploadMetadataRequest();
metaDataReq.Files = new UploadMetadataRequestFile0();
metaDataReq.Files.File0 = new UploadMetadataRequestFile();
metaDataReq.Files.File0.FileName = fileName;
metaDataReq.Files.File0.FileType = RequestHelpers.GetMimeType(fileName);
metaDataReq.Files.File0.FileSize = Convert.ToInt32(stream.Length);
metaDataReq.Removable = Settings.Removable;
metaDataReq.OneShot = Settings.OneShot;
if (Settings.TTLUnit != 3) // everything except the expire time -1
{
metaDataReq.Ttl = Convert.ToInt32(GetMultiplyIndex(2, Settings.TTLUnit) * Settings.TTL * 60);
}
else
{
metaDataReq.Ttl = -1;
}
if (Settings.HasComment)
{
metaDataReq.Comment = Settings.Comment;
}
if (Settings.IsSecured)
{
metaDataReq.Login = Settings.Login;
metaDataReq.Password = Settings.Password;
}
string metaDataResp = SendRequest(HttpMethod.POST, Settings.URL + "/upload", JsonConvert.SerializeObject(metaDataReq), headers: requestHeaders);
UploadMetadataResponse metaData = JsonConvert.DeserializeObject <UploadMetadataResponse>(metaDataResp);
requestHeaders["x-uploadtoken"] = metaData.uploadToken;
string url = $"{Settings.URL}/file/{metaData.id}/{metaData.files.First().Value.id.ToString()}/{fileName}";
UploadResult FileDatReq = SendRequestFile(url, stream, fileName, "file", headers: requestHeaders);
return(ConvertResult(metaData, FileDatReq));
}
public override UploadResult UploadText(string text, string fileName)
{
UploadResult result = new UploadResult();
CustomUploaderInput input = new CustomUploaderInput(fileName, text);
if (uploader.Body == CustomUploaderBody.None)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), null, uploader.GetHeaders(input));
}
else if (uploader.Body == CustomUploaderBody.MultipartFormData)
{
if (string.IsNullOrEmpty(uploader.FileFormName))
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(input), uploader.GetArguments(input), uploader.GetHeaders(input),
null, uploader.RequestMethod);
}
else
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(bytes))
{
result = SendRequestFile(uploader.GetRequestURL(input), stream, fileName, uploader.GetFileFormName(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.RequestMethod);
}
}
}
else if (uploader.Body == CustomUploaderBody.FormURLEncoded)
{
result.Response = SendRequestURLEncoded(uploader.RequestMethod, uploader.GetRequestURL(input), uploader.GetArguments(input), uploader.GetHeaders(input));
}
else if (uploader.Body == CustomUploaderBody.JSON || uploader.Body == CustomUploaderBody.XML)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), uploader.GetData(input), uploader.GetContentType(),
null, uploader.GetHeaders(input));
}
else if (uploader.Body == CustomUploaderBody.Binary)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(bytes))
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), stream, RequestHelpers.GetMimeType(fileName),
null, uploader.GetHeaders(input));
}
}
else
{
throw new Exception("Unsupported request format: " + uploader.Body);
}
try
{
uploader.ParseResponse(result, LastResponseInfo, input);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
bool isPathStyleRequest = Settings.UsePathStyle;
if (!isPathStyleRequest && Settings.Bucket.Contains("."))
{
isPathStyleRequest = true;
}
string endpoint = URLHelpers.RemovePrefixes(Settings.Endpoint);
string host = isPathStyleRequest ? endpoint : $"{Settings.Bucket}.{endpoint}";
string algorithm = "AWS4-HMAC-SHA256";
string credentialDate = DateTime.UtcNow.ToString("yyyyMMdd", CultureInfo.InvariantCulture);
string region = GetRegion();
string scope = URLHelpers.CombineURL(credentialDate, region, "s3", "aws4_request");
string credential = URLHelpers.CombineURL(Settings.AccessKeyID, scope);
string timeStamp = DateTime.UtcNow.ToString("yyyyMMddTHHmmssZ", CultureInfo.InvariantCulture);
string contentType = RequestHelpers.GetMimeType(fileName);
string hashedPayload;
if (Settings.SignedPayload)
{
hashedPayload = Helpers.BytesToHex(Helpers.ComputeSHA256(stream));
}
else
{
hashedPayload = "UNSIGNED-PAYLOAD";
}
string uploadPath = GetUploadPath(fileName);
string resultURL = GenerateURL(uploadPath);
OnEarlyURLCopyRequested(resultURL);
NameValueCollection headers = new NameValueCollection
{
["Host"] = host,
["Content-Length"] = stream.Length.ToString(),
["Content-Type"] = contentType,
["x-amz-date"] = timeStamp,
["x-amz-content-sha256"] = hashedPayload,
// If you don't specify, S3 Standard is the default storage class. Amazon S3 supports other storage classes.
// Valid Values: STANDARD | REDUCED_REDUNDANCY | STANDARD_IA | ONEZONE_IA | INTELLIGENT_TIERING | GLACIER | DEEP_ARCHIVE
// https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html
["x-amz-storage-class"] = Settings.StorageClass.ToString()
};
if (Settings.SetPublicACL)
{
// The canned ACL to apply to the object. For more information, see Canned ACL.
// https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
headers["x-amz-acl"] = "public-read";
}
string canonicalURI = uploadPath;
if (isPathStyleRequest)
{
canonicalURI = URLHelpers.CombineURL(Settings.Bucket, canonicalURI);
}
canonicalURI = URLHelpers.AddSlash(canonicalURI, SlashType.Prefix);
canonicalURI = URLHelpers.URLEncode(canonicalURI, true);
string canonicalQueryString = "";
string canonicalHeaders = CreateCanonicalHeaders(headers);
string signedHeaders = GetSignedHeaders(headers);
string canonicalRequest = "PUT" + "\n" +
canonicalURI + "\n" +
canonicalQueryString + "\n" +
canonicalHeaders + "\n" +
signedHeaders + "\n" +
hashedPayload;
string stringToSign = algorithm + "\n" +
timeStamp + "\n" +
scope + "\n" +
Helpers.BytesToHex(Helpers.ComputeSHA256(canonicalRequest));
byte[] dateKey = Helpers.ComputeHMACSHA256(credentialDate, "AWS4" + Settings.SecretAccessKey);
byte[] dateRegionKey = Helpers.ComputeHMACSHA256(region, dateKey);
byte[] dateRegionServiceKey = Helpers.ComputeHMACSHA256("s3", dateRegionKey);
byte[] signingKey = Helpers.ComputeHMACSHA256("aws4_request", dateRegionServiceKey);
string signature = Helpers.BytesToHex(Helpers.ComputeHMACSHA256(stringToSign, signingKey));
headers["Authorization"] = algorithm + " " +
"Credential=" + credential + "," +
"SignedHeaders=" + signedHeaders + "," +
"Signature=" + signature;
headers.Remove("Host");
headers.Remove("Content-Type");
string url = URLHelpers.CombineURL(host, canonicalURI);
url = URLHelpers.ForcePrefix(url, "https://");
SendRequest(HttpMethod.PUT, url, stream, contentType, null, headers);
if (LastResponseInfo != null && LastResponseInfo.IsSuccess)
{
return(new UploadResult
{
IsSuccess = true,
URL = resultURL
});
}
Errors.Add("Upload to Amazon S3 failed.");
return(null);
}
public override UploadResult Upload(Stream stream, string fileName)
{
UploadResult result = new UploadResult();
CustomUploaderInput input = new CustomUploaderInput(fileName, "");
if (uploader.Body == CustomUploaderBody.MultipartFormData)
{
result = SendRequestFile(uploader.GetRequestURL(input), stream, fileName, uploader.GetFileFormName(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.RequestMethod);
}
else if (uploader.Body == CustomUploaderBody.Binary)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), stream, RequestHelpers.GetMimeType(fileName), null,
uploader.GetHeaders(input));
}
else
{
throw new Exception("Unsupported request format: " + uploader.Body);
}
try
{
uploader.ParseResponse(result, LastResponseInfo, input);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
UploadResult result = new UploadResult();
CustomUploaderInput input = new CustomUploaderInput(fileName, "");
if (uploader.Body == CustomUploaderBody.MultipartFormData)
{
result = SendRequestFile(uploader.GetRequestURL(input), stream, fileName, uploader.GetFileFormName(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.RequestMethod);
}
else if (uploader.Body == CustomUploaderBody.Binary)
{
result.Response = SendRequest(uploader.RequestMethod, uploader.GetRequestURL(input), stream, RequestHelpers.GetMimeType(fileName), null,
uploader.GetHeaders(input));
}
else
{
throw new Exception("Unsupported request format: " + uploader.Body);
}
uploader.TryParseResponse(result, LastResponseInfo, input);
return(result);
}