mirror of
https://github.com/ShareX/ShareX.git
synced 2024-07-04 22:21:23 +12:00
907 lines
35 KiB
C#
907 lines
35 KiB
C#
/*
|
|
* Greenshot - a free and open source screenshot tool
|
|
* Copyright (C) 2007-2015 Thomas Braun, Jens Klingen, Robin Krom
|
|
*
|
|
* For more information see: http://getgreenshot.org/
|
|
* The Greenshot project is hosted on Sourceforge: http://sourceforge.net/projects/greenshot/
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 1 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
using Greenshot.IniFile;
|
|
using Greenshot.Plugin;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace GreenshotPlugin.Core
|
|
{
|
|
/// <summary>
|
|
/// HTTP Method to make sure we have the correct method
|
|
/// </summary>
|
|
public enum HTTPMethod
|
|
{
|
|
GET,
|
|
POST,
|
|
PUT,
|
|
DELETE,
|
|
HEAD
|
|
};
|
|
|
|
/// <summary>
|
|
/// Description of NetworkHelper.
|
|
/// </summary>
|
|
public static class NetworkHelper
|
|
{
|
|
private static readonly CoreConfiguration Config = IniConfig.GetIniSection<CoreConfiguration>();
|
|
|
|
static NetworkHelper()
|
|
{
|
|
try
|
|
{
|
|
// Disable certificate checking
|
|
ServicePointManager.ServerCertificateValidationCallback += delegate
|
|
{
|
|
return true;
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LOG.Warn("An error has occured while allowing self-signed certificates:", ex);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Download a uri response as string
|
|
/// </summary>
|
|
/// <param name="uri">An Uri to specify the download location</param>
|
|
/// <returns>string with the file content</returns>
|
|
public static string GetAsString(Uri uri)
|
|
{
|
|
return GetResponseAsString(CreateWebRequest(uri));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Download the FavIcon as a Bitmap
|
|
/// </summary>
|
|
/// <param name="baseUri"></param>
|
|
/// <returns>Bitmap with the FavIcon</returns>
|
|
public static Bitmap DownloadFavIcon(Uri baseUri)
|
|
{
|
|
Uri url = new Uri(baseUri, new Uri("favicon.ico"));
|
|
try
|
|
{
|
|
HttpWebRequest request = CreateWebRequest(url);
|
|
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
|
|
{
|
|
if (request.HaveResponse)
|
|
{
|
|
using (Stream responseStream = response.GetResponseStream())
|
|
{
|
|
if (responseStream != null)
|
|
{
|
|
using (Image image = Image.FromStream(responseStream))
|
|
{
|
|
return (image.Height > 16 && image.Width > 16) ? new Bitmap(image, 16, 16) : new Bitmap(image);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
LOG.Error("Problem downloading the FavIcon from: " + baseUri, e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Download the uri into a memorystream, without catching exceptions
|
|
/// </summary>
|
|
/// <param name="url">Of an image</param>
|
|
/// <returns>MemoryStream which is already seeked to 0</returns>
|
|
public static MemoryStream GetAsMemoryStream(string url)
|
|
{
|
|
HttpWebRequest request = CreateWebRequest(url);
|
|
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
|
|
{
|
|
MemoryStream memoryStream = new MemoryStream();
|
|
using (Stream responseStream = response.GetResponseStream())
|
|
{
|
|
if (responseStream != null)
|
|
{
|
|
responseStream.CopyTo(memoryStream);
|
|
}
|
|
// Make sure it can be used directly
|
|
memoryStream.Seek(0, SeekOrigin.Begin);
|
|
}
|
|
return memoryStream;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Download the uri to Bitmap
|
|
/// </summary>
|
|
/// <param name="url">Of an image</param>
|
|
/// <returns>Bitmap</returns>
|
|
public static Image DownloadImage(string url)
|
|
{
|
|
try
|
|
{
|
|
string content;
|
|
using (MemoryStream memoryStream = GetAsMemoryStream(url))
|
|
{
|
|
try
|
|
{
|
|
using (Image image = Image.FromStream(memoryStream))
|
|
{
|
|
return ImageHelper.Clone(image, PixelFormat.Format32bppArgb);
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// If we arrive here, the image loading didn't work, try to see if the response has a http(s) URL to an image and just take this instead.
|
|
using (StreamReader streamReader = new StreamReader(memoryStream, Encoding.UTF8, true))
|
|
{
|
|
content = streamReader.ReadLine();
|
|
}
|
|
if (!string.IsNullOrEmpty(content))
|
|
{
|
|
Regex imageUrlRegex = new Regex(@"(http|https)://.*(\.png|\.gif|\.jpg|\.tiff|\.jpeg|\.bmp)");
|
|
Match match = imageUrlRegex.Match(content);
|
|
if (match.Success)
|
|
{
|
|
using (MemoryStream memoryStream2 = GetAsMemoryStream(match.Value))
|
|
{
|
|
using (Image image = Image.FromStream(memoryStream2))
|
|
{
|
|
return ImageHelper.Clone(image, PixelFormat.Format32bppArgb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
LOG.Error("Problem downloading the image from: " + url, e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper method to create a web request with a lot of default settings
|
|
/// </summary>
|
|
/// <param name="uri">string with uri to connect to</param>
|
|
/// <returns>WebRequest</returns>
|
|
public static HttpWebRequest CreateWebRequest(string uri)
|
|
{
|
|
return CreateWebRequest(new Uri(uri));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper method to create a web request with a lot of default settings
|
|
/// </summary>
|
|
/// <param name="uri">string with uri to connect to</param>
|
|
/// /// <param name="method">Method to use</param>
|
|
/// <returns>WebRequest</returns>
|
|
public static HttpWebRequest CreateWebRequest(string uri, HTTPMethod method)
|
|
{
|
|
return CreateWebRequest(new Uri(uri), method);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper method to create a web request with a lot of default settings
|
|
/// </summary>
|
|
/// <param name="uri">Uri with uri to connect to</param>
|
|
/// <param name="method">Method to use</param>
|
|
/// <returns>WebRequest</returns>
|
|
public static HttpWebRequest CreateWebRequest(Uri uri, HTTPMethod method)
|
|
{
|
|
HttpWebRequest webRequest = CreateWebRequest(uri);
|
|
webRequest.Method = method.ToString();
|
|
return webRequest;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper method to create a web request, eventually with proxy
|
|
/// </summary>
|
|
/// <param name="uri">Uri with uri to connect to</param>
|
|
/// <returns>WebRequest</returns>
|
|
public static HttpWebRequest CreateWebRequest(Uri uri)
|
|
{
|
|
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
|
|
webRequest.Proxy = Config.UseProxy ? CreateProxy(uri) : null;
|
|
// Make sure the default credentials are available
|
|
webRequest.Credentials = CredentialCache.DefaultCredentials;
|
|
|
|
// Allow redirect, this is usually needed so that we don't get a problem when a service moves
|
|
webRequest.AllowAutoRedirect = true;
|
|
// Set default timeouts
|
|
webRequest.Timeout = Config.WebRequestTimeout * 1000;
|
|
webRequest.ReadWriteTimeout = Config.WebRequestReadWriteTimeout * 1000;
|
|
return webRequest;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a IWebProxy Object which can be used to access the Internet
|
|
/// This method will check the configuration if the proxy is allowed to be used.
|
|
/// Usages can be found in the DownloadFavIcon or Jira and Confluence plugins
|
|
/// </summary>
|
|
/// <param name="uri"></param>
|
|
/// <returns>IWebProxy filled with all the proxy details or null if none is set/wanted</returns>
|
|
public static IWebProxy CreateProxy(Uri uri)
|
|
{
|
|
IWebProxy proxyToUse = null;
|
|
if (Config.UseProxy)
|
|
{
|
|
proxyToUse = WebRequest.DefaultWebProxy;
|
|
if (proxyToUse != null)
|
|
{
|
|
proxyToUse.Credentials = CredentialCache.DefaultCredentials;
|
|
if (LOG.IsDebugEnabled)
|
|
{
|
|
// check the proxy for the Uri
|
|
if (!proxyToUse.IsBypassed(uri))
|
|
{
|
|
Uri proxyUri = proxyToUse.GetProxy(uri);
|
|
if (proxyUri != null)
|
|
{
|
|
LOG.Debug("Using proxy: " + proxyUri + " for " + uri);
|
|
}
|
|
else
|
|
{
|
|
LOG.Debug("No proxy found!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG.Debug("Proxy bypass for: " + uri);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG.Debug("No proxy found!");
|
|
}
|
|
}
|
|
return proxyToUse;
|
|
}
|
|
|
|
/// <summary>
|
|
/// UrlEncodes a string without the requirement for System.Web
|
|
/// </summary>
|
|
/// <param name="text"></param>
|
|
/// <returns></returns>
|
|
// [Obsolete("Use System.Uri.EscapeDataString instead")]
|
|
public static string UrlEncode(string text)
|
|
{
|
|
if (!string.IsNullOrEmpty(text))
|
|
{
|
|
// Sytem.Uri provides reliable parsing, but doesn't encode spaces.
|
|
return Uri.EscapeDataString(text).Replace("%20", "+");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// A wrapper around the EscapeDataString, as the limit is 32766 characters
|
|
/// See: http://msdn.microsoft.com/en-us/library/system.uri.escapedatastring%28v=vs.110%29.aspx
|
|
/// </summary>
|
|
/// <param name="text"></param>
|
|
/// <returns>escaped data string</returns>
|
|
public static string EscapeDataString(string text)
|
|
{
|
|
if (!string.IsNullOrEmpty(text))
|
|
{
|
|
StringBuilder result = new StringBuilder();
|
|
int currentLocation = 0;
|
|
while (currentLocation < text.Length)
|
|
{
|
|
string process = text.Substring(currentLocation, Math.Min(16384, text.Length - currentLocation));
|
|
result.Append(Uri.EscapeDataString(process));
|
|
currentLocation = currentLocation + 16384;
|
|
}
|
|
return result.ToString();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// UrlDecodes a string without requiring System.Web
|
|
/// </summary>
|
|
/// <param name="text">String to decode.</param>
|
|
/// <returns>decoded string</returns>
|
|
public static string UrlDecode(string text)
|
|
{
|
|
// pre-process for + sign space formatting since System.Uri doesn't handle it
|
|
// plus literals are encoded as %2b normally so this should be safe
|
|
text = text.Replace("+", " ");
|
|
return Uri.UnescapeDataString(text);
|
|
}
|
|
|
|
/// <summary>
|
|
/// ParseQueryString without the requirement for System.Web
|
|
/// </summary>
|
|
/// <param name="queryString"></param>
|
|
/// <returns>IDictionary string, string</returns>
|
|
public static IDictionary<string, string> ParseQueryString(string queryString)
|
|
{
|
|
IDictionary<string, string> parameters = new SortedDictionary<string, string>();
|
|
// remove anything other than query string from uri
|
|
if (queryString.Contains("?"))
|
|
{
|
|
queryString = queryString.Substring(queryString.IndexOf('?') + 1);
|
|
}
|
|
foreach (string vp in Regex.Split(queryString, "&"))
|
|
{
|
|
if (string.IsNullOrEmpty(vp))
|
|
{
|
|
continue;
|
|
}
|
|
string[] singlePair = Regex.Split(vp, "=");
|
|
if (parameters.ContainsKey(singlePair[0]))
|
|
{
|
|
parameters.Remove(singlePair[0]);
|
|
}
|
|
parameters.Add(singlePair[0], singlePair.Length == 2 ? singlePair[1] : string.Empty);
|
|
}
|
|
return parameters;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate the query paramters
|
|
/// </summary>
|
|
/// <param name="queryParameters">the list of query parameters</param>
|
|
/// <returns>a string with the query parameters</returns>
|
|
public static string GenerateQueryParameters(IDictionary<string, object> queryParameters)
|
|
{
|
|
if (queryParameters == null || queryParameters.Count == 0)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
queryParameters = new SortedDictionary<string, object>(queryParameters);
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
foreach (string key in queryParameters.Keys)
|
|
{
|
|
sb.AppendFormat(CultureInfo.InvariantCulture, "{0}={1}&", key, UrlEncode(string.Format("{0}", queryParameters[key])));
|
|
}
|
|
sb.Remove(sb.Length - 1, 1);
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write Multipart Form Data directly to the HttpWebRequest
|
|
/// </summary>
|
|
/// <param name="webRequest">HttpWebRequest to write the multipart form data to</param>
|
|
/// <param name="postParameters">Parameters to include in the multipart form data</param>
|
|
public static void WriteMultipartFormData(HttpWebRequest webRequest, IDictionary<string, object> postParameters)
|
|
{
|
|
string boundary = String.Format("----------{0:N}", Guid.NewGuid());
|
|
webRequest.ContentType = "multipart/form-data; boundary=" + boundary;
|
|
using (Stream formDataStream = webRequest.GetRequestStream())
|
|
{
|
|
WriteMultipartFormData(formDataStream, boundary, postParameters);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write Multipart Form Data to the HttpListenerResponse
|
|
/// </summary>
|
|
/// <param name="response">HttpListenerResponse</param>
|
|
/// <param name="postParameters">Parameters to include in the multipart form data</param>
|
|
public static void WriteMultipartFormData(HttpListenerResponse response, IDictionary<string, object> postParameters)
|
|
{
|
|
string boundary = String.Format("----------{0:N}", Guid.NewGuid());
|
|
response.ContentType = "multipart/form-data; boundary=" + boundary;
|
|
WriteMultipartFormData(response.OutputStream, boundary, postParameters);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write Multipart Form Data to a Stream, content-type should be set before this!
|
|
/// </summary>
|
|
/// <param name="formDataStream">Stream to write the multipart form data to</param>
|
|
/// <param name="boundary">String boundary for the multipart/form-data</param>
|
|
/// <param name="postParameters">Parameters to include in the multipart form data</param>
|
|
public static void WriteMultipartFormData(Stream formDataStream, string boundary, IDictionary<string, object> postParameters)
|
|
{
|
|
bool needsClrf = false;
|
|
foreach (var param in postParameters)
|
|
{
|
|
// Add a CRLF to allow multiple parameters to be added.
|
|
// Skip it on the first parameter, add it to subsequent parameters.
|
|
if (needsClrf)
|
|
{
|
|
formDataStream.Write(Encoding.UTF8.GetBytes("\r\n"), 0, Encoding.UTF8.GetByteCount("\r\n"));
|
|
}
|
|
|
|
needsClrf = true;
|
|
|
|
if (param.Value is IBinaryContainer)
|
|
{
|
|
IBinaryContainer binaryParameter = (IBinaryContainer)param.Value;
|
|
binaryParameter.WriteFormDataToStream(boundary, param.Key, formDataStream);
|
|
}
|
|
else
|
|
{
|
|
string postData = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"\r\n\r\n{2}",
|
|
boundary,
|
|
param.Key,
|
|
param.Value);
|
|
formDataStream.Write(Encoding.UTF8.GetBytes(postData), 0, Encoding.UTF8.GetByteCount(postData));
|
|
}
|
|
}
|
|
|
|
// Add the end of the request. Start with a newline
|
|
string footer = "\r\n--" + boundary + "--\r\n";
|
|
formDataStream.Write(Encoding.UTF8.GetBytes(footer), 0, Encoding.UTF8.GetByteCount(footer));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Post the parameters "x-www-form-urlencoded"
|
|
/// </summary>
|
|
/// <param name="webRequest"></param>
|
|
/// <param name="parameters"></param>
|
|
public static void UploadFormUrlEncoded(HttpWebRequest webRequest, IDictionary<string, object> parameters)
|
|
{
|
|
webRequest.ContentType = "application/x-www-form-urlencoded";
|
|
string urlEncoded = GenerateQueryParameters(parameters);
|
|
|
|
byte[] data = Encoding.UTF8.GetBytes(urlEncoded);
|
|
using (var requestStream = webRequest.GetRequestStream())
|
|
{
|
|
requestStream.Write(data, 0, data.Length);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Log the headers of the WebResponse, if IsDebugEnabled
|
|
/// </summary>
|
|
/// <param name="response">WebResponse</param>
|
|
private static void DebugHeaders(WebResponse response)
|
|
{
|
|
if (!LOG.IsDebugEnabled)
|
|
{
|
|
return;
|
|
}
|
|
LOG.DebugFormat("Debug information on the response from {0} :", response.ResponseUri);
|
|
foreach (string key in response.Headers.AllKeys)
|
|
{
|
|
LOG.DebugFormat("Reponse-header: {0}={1}", key, response.Headers[key]);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Process the web response.
|
|
/// </summary>
|
|
/// <param name="webRequest">The request object.</param>
|
|
/// <returns>The response data.</returns>
|
|
/// This method should handle the StatusCode better!
|
|
public static string GetResponseAsString(HttpWebRequest webRequest)
|
|
{
|
|
return GetResponseAsString(webRequest, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read the response as string
|
|
/// </summary>
|
|
/// <param name="response"></param>
|
|
/// <returns>string or null</returns>
|
|
private static string GetResponseAsString(HttpWebResponse response)
|
|
{
|
|
string responseData = null;
|
|
if (response == null)
|
|
{
|
|
return null;
|
|
}
|
|
using (response)
|
|
{
|
|
Stream responseStream = response.GetResponseStream();
|
|
if (responseStream != null)
|
|
{
|
|
using (StreamReader reader = new StreamReader(responseStream, true))
|
|
{
|
|
responseData = reader.ReadToEnd();
|
|
}
|
|
}
|
|
}
|
|
return responseData;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="webRequest"></param>
|
|
/// <param name="alsoReturnContentOnError"></param>
|
|
/// <returns></returns>
|
|
public static string GetResponseAsString(HttpWebRequest webRequest, bool alsoReturnContentOnError)
|
|
{
|
|
string responseData = null;
|
|
HttpWebResponse response = null;
|
|
bool isHttpError = false;
|
|
try
|
|
{
|
|
response = (HttpWebResponse)webRequest.GetResponse();
|
|
LOG.InfoFormat("Response status: {0}", response.StatusCode);
|
|
isHttpError = (int)response.StatusCode >= 300;
|
|
if (isHttpError)
|
|
{
|
|
LOG.ErrorFormat("HTTP error {0}", response.StatusCode);
|
|
}
|
|
DebugHeaders(response);
|
|
responseData = GetResponseAsString(response);
|
|
if (isHttpError)
|
|
{
|
|
LOG.ErrorFormat("HTTP response {0}", responseData);
|
|
}
|
|
}
|
|
catch (WebException e)
|
|
{
|
|
response = (HttpWebResponse)e.Response;
|
|
HttpStatusCode statusCode = HttpStatusCode.Unused;
|
|
if (response != null)
|
|
{
|
|
statusCode = response.StatusCode;
|
|
LOG.ErrorFormat("HTTP error {0}", statusCode);
|
|
string errorContent = GetResponseAsString(response);
|
|
if (alsoReturnContentOnError)
|
|
{
|
|
return errorContent;
|
|
}
|
|
LOG.ErrorFormat("Content: {0}", errorContent);
|
|
}
|
|
LOG.Error("WebException: ", e);
|
|
if (statusCode == HttpStatusCode.Unauthorized)
|
|
{
|
|
throw new UnauthorizedAccessException(e.Message);
|
|
}
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
if (response != null)
|
|
{
|
|
if (isHttpError)
|
|
{
|
|
LOG.ErrorFormat("HTTP error {0} with content: {1}", response.StatusCode, responseData);
|
|
}
|
|
response.Close();
|
|
}
|
|
}
|
|
return responseData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get LastModified for a URI
|
|
/// </summary>
|
|
/// <param name="uri">Uri</param>
|
|
/// <returns>DateTime</returns>
|
|
public static DateTime GetLastModified(Uri uri)
|
|
{
|
|
try
|
|
{
|
|
HttpWebRequest webRequest = CreateWebRequest(uri);
|
|
webRequest.Method = HTTPMethod.HEAD.ToString();
|
|
using (HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse())
|
|
{
|
|
LOG.DebugFormat("RSS feed was updated at {0}", webResponse.LastModified);
|
|
return webResponse.LastModified;
|
|
}
|
|
}
|
|
catch (Exception wE)
|
|
{
|
|
LOG.WarnFormat("Problem requesting HTTP - HEAD on uri {0}", uri);
|
|
LOG.Warn(wE.Message);
|
|
// Pretend it is old
|
|
return DateTime.MinValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This interface can be used to pass binary information around, like byte[] or Image
|
|
/// </summary>
|
|
public interface IBinaryContainer
|
|
{
|
|
void WriteFormDataToStream(string boundary, string name, Stream formDataStream);
|
|
|
|
void WriteToStream(Stream formDataStream);
|
|
|
|
string ToBase64String(Base64FormattingOptions formattingOptions);
|
|
|
|
byte[] ToByteArray();
|
|
|
|
void Upload(HttpWebRequest webRequest);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A container to supply files to a Multi-part form data upload
|
|
/// </summary>
|
|
public class ByteContainer : IBinaryContainer
|
|
{
|
|
private readonly byte[] _file;
|
|
private readonly string _fileName;
|
|
private readonly string _contentType;
|
|
private readonly int _fileSize;
|
|
|
|
public ByteContainer(byte[] file) : this(file, null)
|
|
{
|
|
}
|
|
|
|
public ByteContainer(byte[] file, string filename) : this(file, filename, null)
|
|
{
|
|
}
|
|
|
|
public ByteContainer(byte[] file, string filename, string contenttype) : this(file, filename, contenttype, 0)
|
|
{
|
|
}
|
|
|
|
public ByteContainer(byte[] file, string filename, string contenttype, int filesize)
|
|
{
|
|
_file = file;
|
|
_fileName = filename;
|
|
_contentType = contenttype;
|
|
_fileSize = filesize == 0 ? file.Length : filesize;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a Base64String from the byte[]
|
|
/// </summary>
|
|
/// <returns>string</returns>
|
|
public string ToBase64String(Base64FormattingOptions formattingOptions)
|
|
{
|
|
return Convert.ToBase64String(_file, 0, _fileSize, formattingOptions);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the initial byte-array which was supplied when creating the FileParameter
|
|
/// </summary>
|
|
/// <returns>byte[]</returns>
|
|
public byte[] ToByteArray()
|
|
{
|
|
return _file;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write Multipart Form Data directly to the HttpWebRequest response stream
|
|
/// </summary>
|
|
/// <param name="boundary">Separator</param>
|
|
/// <param name="name">name</param>
|
|
/// <param name="formDataStream">Stream to write to</param>
|
|
public void WriteFormDataToStream(string boundary, string name, Stream formDataStream)
|
|
{
|
|
// Add just the first part of this param, since we will write the file data directly to the Stream
|
|
string header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n",
|
|
boundary,
|
|
name,
|
|
_fileName ?? name,
|
|
_contentType ?? "application/octet-stream");
|
|
|
|
formDataStream.Write(Encoding.UTF8.GetBytes(header), 0, Encoding.UTF8.GetByteCount(header));
|
|
|
|
// Write the file data directly to the Stream, rather than serializing it to a string.
|
|
formDataStream.Write(_file, 0, _fileSize);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A plain "write data to stream"
|
|
/// </summary>
|
|
/// <param name="dataStream">Stream to write to</param>
|
|
public void WriteToStream(Stream dataStream)
|
|
{
|
|
// Write the file data directly to the Stream, rather than serializing it to a string.
|
|
dataStream.Write(_file, 0, _fileSize);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Upload the file to the webrequest
|
|
/// </summary>
|
|
/// <param name="webRequest"></param>
|
|
public void Upload(HttpWebRequest webRequest)
|
|
{
|
|
webRequest.ContentType = _contentType;
|
|
webRequest.ContentLength = _fileSize;
|
|
using (var requestStream = webRequest.GetRequestStream())
|
|
{
|
|
WriteToStream(requestStream);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A container to supply images to a Multi-part form data upload
|
|
/// </summary>
|
|
public class BitmapContainer : IBinaryContainer
|
|
{
|
|
private readonly Bitmap _bitmap;
|
|
private readonly SurfaceOutputSettings _outputSettings;
|
|
private readonly string _fileName;
|
|
|
|
public BitmapContainer(Bitmap bitmap, SurfaceOutputSettings outputSettings, string filename)
|
|
{
|
|
_bitmap = bitmap;
|
|
_outputSettings = outputSettings;
|
|
_fileName = filename;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a Base64String from the image by saving it to a memory stream and converting it.
|
|
/// Should be avoided if possible, as this uses a lot of memory.
|
|
/// </summary>
|
|
/// <returns>string</returns>
|
|
public string ToBase64String(Base64FormattingOptions formattingOptions)
|
|
{
|
|
using (MemoryStream stream = new MemoryStream())
|
|
{
|
|
ImageOutput.SaveToStream(_bitmap, null, stream, _outputSettings);
|
|
return Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length, formattingOptions);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a byte[] from the image by saving it to a memory stream.
|
|
/// Should be avoided if possible, as this uses a lot of memory.
|
|
/// </summary>
|
|
/// <returns>byte[]</returns>
|
|
public byte[] ToByteArray()
|
|
{
|
|
using (MemoryStream stream = new MemoryStream())
|
|
{
|
|
ImageOutput.SaveToStream(_bitmap, null, stream, _outputSettings);
|
|
return stream.ToArray();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write Multipart Form Data directly to the HttpWebRequest response stream
|
|
/// </summary>
|
|
/// <param name="boundary">Separator</param>
|
|
/// <param name="name">Name of the thing/file</param>
|
|
/// <param name="formDataStream">Stream to write to</param>
|
|
public void WriteFormDataToStream(string boundary, string name, Stream formDataStream)
|
|
{
|
|
// Add just the first part of this param, since we will write the file data directly to the Stream
|
|
string header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n",
|
|
boundary,
|
|
name,
|
|
_fileName ?? name,
|
|
"image/" + _outputSettings.Format);
|
|
|
|
formDataStream.Write(Encoding.UTF8.GetBytes(header), 0, Encoding.UTF8.GetByteCount(header));
|
|
ImageOutput.SaveToStream(_bitmap, null, formDataStream, _outputSettings);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A plain "write data to stream"
|
|
/// </summary>
|
|
/// <param name="dataStream"></param>
|
|
public void WriteToStream(Stream dataStream)
|
|
{
|
|
// Write the file data directly to the Stream, rather than serializing it to a string.
|
|
ImageOutput.SaveToStream(_bitmap, null, dataStream, _outputSettings);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Upload the image to the webrequest
|
|
/// </summary>
|
|
/// <param name="webRequest"></param>
|
|
public void Upload(HttpWebRequest webRequest)
|
|
{
|
|
webRequest.ContentType = "image/" + _outputSettings.Format;
|
|
using (var requestStream = webRequest.GetRequestStream())
|
|
{
|
|
WriteToStream(requestStream);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A container to supply surfaces to a Multi-part form data upload
|
|
/// </summary>
|
|
public class SurfaceContainer : IBinaryContainer
|
|
{
|
|
private readonly ISurface _surface;
|
|
private readonly SurfaceOutputSettings _outputSettings;
|
|
private readonly string _fileName;
|
|
|
|
public SurfaceContainer(ISurface surface, SurfaceOutputSettings outputSettings, string filename)
|
|
{
|
|
_surface = surface;
|
|
_outputSettings = outputSettings;
|
|
_fileName = filename;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a Base64String from the Surface by saving it to a memory stream and converting it.
|
|
/// Should be avoided if possible, as this uses a lot of memory.
|
|
/// </summary>
|
|
/// <returns>string</returns>
|
|
public string ToBase64String(Base64FormattingOptions formattingOptions)
|
|
{
|
|
using (MemoryStream stream = new MemoryStream())
|
|
{
|
|
ImageOutput.SaveToStream(_surface, stream, _outputSettings);
|
|
return Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length, formattingOptions);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a byte[] from the image by saving it to a memory stream.
|
|
/// Should be avoided if possible, as this uses a lot of memory.
|
|
/// </summary>
|
|
/// <returns>byte[]</returns>
|
|
public byte[] ToByteArray()
|
|
{
|
|
using (MemoryStream stream = new MemoryStream())
|
|
{
|
|
ImageOutput.SaveToStream(_surface, stream, _outputSettings);
|
|
return stream.ToArray();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write Multipart Form Data directly to the HttpWebRequest response stream
|
|
/// </summary>
|
|
/// <param name="boundary">Multipart separator</param>
|
|
/// <param name="name">Name of the thing</param>
|
|
/// <param name="formDataStream">Stream to write to</param>
|
|
public void WriteFormDataToStream(string boundary, string name, Stream formDataStream)
|
|
{
|
|
// Add just the first part of this param, since we will write the file data directly to the Stream
|
|
string header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n",
|
|
boundary,
|
|
name,
|
|
_fileName ?? name,
|
|
"image/" + _outputSettings.Format);
|
|
|
|
formDataStream.Write(Encoding.UTF8.GetBytes(header), 0, Encoding.UTF8.GetByteCount(header));
|
|
ImageOutput.SaveToStream(_surface, formDataStream, _outputSettings);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A plain "write data to stream"
|
|
/// </summary>
|
|
/// <param name="dataStream"></param>
|
|
public void WriteToStream(Stream dataStream)
|
|
{
|
|
// Write the file data directly to the Stream, rather than serializing it to a string.
|
|
ImageOutput.SaveToStream(_surface, dataStream, _outputSettings);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Upload the Surface as image to the webrequest
|
|
/// </summary>
|
|
/// <param name="webRequest"></param>
|
|
public void Upload(HttpWebRequest webRequest)
|
|
{
|
|
webRequest.ContentType = "image/" + _outputSettings.Format.ToString();
|
|
using (var requestStream = webRequest.GetRequestStream())
|
|
{
|
|
WriteToStream(requestStream);
|
|
}
|
|
}
|
|
}
|
|
} |