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, UploadHelpers.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 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, UploadHelpers.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 UploadText(string text, string fileName)
{
UploadResult result = new UploadResult();
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput(fileName, text);
CustomUploaderRequestFormat requestFormat = uploader.GetRequestFormat(CustomUploaderDestinationType.TextUploader);
if (requestFormat == CustomUploaderRequestFormat.MultipartFormData)
{
if (string.IsNullOrEmpty(uploader.FileFormName))
{
result.Response = SendRequestMultiPart(uploader.GetRequestURL(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType, uploader.RequestType);
}
else
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(bytes))
{
result = SendRequestFile(uploader.GetRequestURL(), stream, fileName, uploader.GetFileFormName(),
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType, uploader.RequestType);
}
}
}
else if (requestFormat == CustomUploaderRequestFormat.URLQueryString)
{
result.Response = SendRequest(uploader.RequestType, uploader.GetRequestURL(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (requestFormat == CustomUploaderRequestFormat.JSON)
{
result.Response = SendRequest(uploader.RequestType, uploader.GetRequestURL(), uploader.GetData(input), UploadHelpers.ContentTypeJSON,
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType);
}
else if (requestFormat == CustomUploaderRequestFormat.Binary)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
using (MemoryStream stream = new MemoryStream(bytes))
{
result.Response = SendRequest(uploader.RequestType, uploader.GetRequestURL(), stream, UploadHelpers.GetMimeType(fileName),
uploader.GetArguments(input), uploader.GetHeaders(input), null, uploader.ResponseType);
}
}
else if (requestFormat == CustomUploaderRequestFormat.FormURLEncoded)
{
result.Response = SendRequestURLEncoded(uploader.RequestType, uploader.GetRequestURL(), uploader.GetArguments(input),
uploader.GetHeaders(input), null, uploader.ResponseType);
}
else
{
throw new Exception("Unsupported request format.");
}
try
{
uploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
return(result);
}
public override UploadResult Upload(Stream stream, string fileName)
{
CustomUploaderArgumentInput input = new CustomUploaderArgumentInput(fileName, "");
if (customUploader.RequestType == CustomUploaderRequestType.POST)
{
UploadResult result = SendRequestFile(customUploader.GetRequestURL(), stream, fileName, customUploader.GetFileFormName(),
customUploader.GetArguments(input), customUploader.GetHeaders(input), responseType: customUploader.ResponseType);
if (result.IsSuccess)
{
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
}
return(result);
}
else if (customUploader.RequestType == CustomUploaderRequestType.PUT)
{
string response = SendRequest(HttpMethod.PUT, URLHelpers.CombineURL(customUploader.GetRequestURL(), fileName), stream, UploadHelpers.GetMimeType(fileName), null, customUploader.GetHeaders(input), null, customUploader.ResponseType);
UploadResult result = new UploadResult();
result.Response = response;
result.IsSuccess = true;
result.URL = URLHelpers.CombineURL(customUploader.URL, fileName);
if (result.IsSuccess)
{
try
{
customUploader.ParseResponse(result);
}
catch (Exception e)
{
Errors.Add(Resources.CustomFileUploader_Upload_Response_parse_failed_ + Environment.NewLine + e);
}
}
return(result);
}
else
{
throw new Exception("'Request type' must be 'POST' or 'PUT' when using custom file uploader.");
}
}
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 = UploadHelpers.GetMimeType(fileName);
string hashedPayload;
if (Settings.SignedPayload)
{
hashedPayload = Helpers.BytesToHex(Helpers.ComputeSHA256(stream));
}
else
{
hashedPayload = "UNSIGNED-PAYLOAD";
}
if ((Settings.RemoveExtensionImage && Helpers.IsImageFile(fileName)) ||
(Settings.RemoveExtensionText && Helpers.IsTextFile(fileName)) ||
(Settings.RemoveExtensionVideo && Helpers.IsVideoFile(fileName)))
{
fileName = Path.GetFileNameWithoutExtension(fileName);
}
string uploadPath = GetUploadPath(fileName);
NameValueCollection headers = new NameValueCollection
{
["Host"] = host,
["Content-Length"] = stream.Length.ToString(),
["Content-Type"] = contentType,
["x-amz-date"] = timeStamp,
["x-amz-content-sha256"] = hashedPayload,
["x-amz-storage-class"] = Settings.StorageClass.ToString()
};
if (Settings.SetPublicACL)
{
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://");
using (HttpWebResponse response = GetResponse(HttpMethod.PUT, url, stream, contentType, null, headers))
{
if (response != null)
{
NameValueCollection responseHeaders = response.Headers;
if (responseHeaders != null && responseHeaders["ETag"] != null)
{
return(new UploadResult
{
IsSuccess = true,
URL = GenerateURL(uploadPath)
});
}
}
}
Errors.Add("Upload to Amazon S3 failed.");
return(null);
}