XUnity.AutoTranslator/src/XUnity.AutoTranslator.Plugin.Core/MonoHttp/HttpUtility.cs

// 
// System.Web.HttpUtility
//
// Authors:
//   Patrik Torstensson ([email protected])
//   Wictor Wilén (decode/encode functions) ([email protected])
//   Tim Coleman ([email protected])
//   Gonzalo Paniagua Javier ([email protected])
//
// Copyright (C) 2005-2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Security.Permissions;
using System.Text;

namespace RestSharp.Contrib
{

//#if !MONOTOUCH
//    // CAS - no InheritanceDemand here as the class is sealed
//    [AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
//#endif
	public sealed class HttpUtility
	{
		sealed class HttpQSCollection : NameValueCollection
		{
			public override string ToString()
			{
				int count = Count;
				if (count == 0)
					return "";
				StringBuilder sb = new StringBuilder();
				string[] keys = AllKeys;
				for (int i = 0; i < count; i++)
				{
					sb.AppendFormat("{0}={1}&", keys[i], this[keys[i]]);
				}
				if (sb.Length > 0)
					sb.Length--;
				return sb.ToString();
			}
		}

		#region Constructors

		public HttpUtility()
		{
		}

		#endregion // Constructors

		#region Methods

		public static void HtmlAttributeEncode(string s, TextWriter output)
		{
			if (output == null)
			{
#if NET_4_0
				throw new ArgumentNullException ("output");
#else
				throw new NullReferenceException(".NET emulation");
#endif
			}
#if NET_4_0
			HttpEncoder.Current.HtmlAttributeEncode (s, output);
#else
			output.Write(HttpEncoder.HtmlAttributeEncode(s));
#endif
		}

		public static string HtmlAttributeEncode(string s)
		{
#if NET_4_0
			if (s == null)
				return null;
			
			using (var sw = new StringWriter ()) {
				HttpEncoder.Current.HtmlAttributeEncode (s, sw);
				return sw.ToString ();
			}
#else
			return HttpEncoder.HtmlAttributeEncode(s);
#endif
		}

		public static string UrlDecode(string str)
		{
			return UrlDecode(str, Encoding.UTF8);
		}

		static char[] GetChars(MemoryStream b, Encoding e)
		{
			return e.GetChars(b.GetBuffer(), 0, (int)b.Length);
		}

		static void WriteCharBytes(IList buf, char ch, Encoding e)
		{
			if (ch > 255)
			{
				foreach (byte b in e.GetBytes(new char[] { ch }))
					buf.Add(b);
			}
			else
				buf.Add((byte)ch);
		}

		public static string UrlDecode(string s, Encoding e)
		{
			if (null == s)
				return null;

			if (s.IndexOf('%') == -1 && s.IndexOf('+') == -1)
				return s;

			if (e == null)
				e = Encoding.UTF8;

			long len = s.Length;
			var bytes = new List<byte>();
			int xchar;
			char ch;

			for (int i = 0; i < len; i++)
			{
				ch = s[i];
				if (ch == '%' && i + 2 < len && s[i + 1] != '%')
				{
					if (s[i + 1] == 'u' && i + 5 < len)
					{
						// unicode hex sequence
						xchar = GetChar(s, i + 2, 4);
						if (xchar != -1)
						{
							WriteCharBytes(bytes, (char)xchar, e);
							i += 5;
						}
						else
							WriteCharBytes(bytes, '%', e);
					}
					else if ((xchar = GetChar(s, i + 1, 2)) != -1)
					{
						WriteCharBytes(bytes, (char)xchar, e);
						i += 2;
					}
					else
					{
						WriteCharBytes(bytes, '%', e);
					}
					continue;
				}

				if (ch == '+')
					WriteCharBytes(bytes, ' ', e);
				else
					WriteCharBytes(bytes, ch, e);
			}

			byte[] buf = bytes.ToArray();
			bytes = null;
			return e.GetString(buf);

		}

		public static string UrlDecode(byte[] bytes, Encoding e)
		{
			if (bytes == null)
				return null;

			return UrlDecode(bytes, 0, bytes.Length, e);
		}

		static int GetInt(byte b)
		{
			char c = (char)b;
			if (c >= '0' && c <= '9')
				return c - '0';

			if (c >= 'a' && c <= 'f')
				return c - 'a' + 10;

			if (c >= 'A' && c <= 'F')
				return c - 'A' + 10;

			return -1;
		}

		static int GetChar(byte[] bytes, int offset, int length)
		{
			int value = 0;
			int end = length + offset;
			for (int i = offset; i < end; i++)
			{
				int current = GetInt(bytes[i]);
				if (current == -1)
					return -1;
				value = (value << 4) + current;
			}

			return value;
		}

		static int GetChar(string str, int offset, int length)
		{
			int val = 0;
			int end = length + offset;
			for (int i = offset; i < end; i++)
			{
				char c = str[i];
				if (c > 127)
					return -1;

				int current = GetInt((byte)c);
				if (current == -1)
					return -1;
				val = (val << 4) + current;
			}

			return val;
		}

		public static string UrlDecode(byte[] bytes, int offset, int count, Encoding e)
		{
			if (bytes == null)
				return null;
			if (count == 0)
				return String.Empty;

			if (bytes == null)
				throw new ArgumentNullException("bytes");

			if (offset < 0 || offset > bytes.Length)
				throw new ArgumentOutOfRangeException("offset");

			if (count < 0 || offset + count > bytes.Length)
				throw new ArgumentOutOfRangeException("count");

			StringBuilder output = new StringBuilder();
			MemoryStream acc = new MemoryStream();

			int end = count + offset;
			int xchar;
			for (int i = offset; i < end; i++)
			{
				if (bytes[i] == '%' && i + 2 < count && bytes[i + 1] != '%')
				{
					if (bytes[i + 1] == (byte)'u' && i + 5 < end)
					{
						if (acc.Length > 0)
						{
							output.Append(GetChars(acc, e));
							acc.SetLength(0);
						}
						xchar = GetChar(bytes, i + 2, 4);
						if (xchar != -1)
						{
							output.Append((char)xchar);
							i += 5;
							continue;
						}
					}
					else if ((xchar = GetChar(bytes, i + 1, 2)) != -1)
					{
						acc.WriteByte((byte)xchar);
						i += 2;
						continue;
					}
				}

				if (acc.Length > 0)
				{
					output.Append(GetChars(acc, e));
					acc.SetLength(0);
				}

				if (bytes[i] == '+')
				{
					output.Append(' ');
				}
				else
				{
					output.Append((char)bytes[i]);
				}
			}

			if (acc.Length > 0)
			{
				output.Append(GetChars(acc, e));
			}

			acc = null;
			return output.ToString();
		}

		public static byte[] UrlDecodeToBytes(byte[] bytes)
		{
			if (bytes == null)
				return null;

			return UrlDecodeToBytes(bytes, 0, bytes.Length);
		}

		public static byte[] UrlDecodeToBytes(string str)
		{
			return UrlDecodeToBytes(str, Encoding.UTF8);
		}

		public static byte[] UrlDecodeToBytes(string str, Encoding e)
		{
			if (str == null)
				return null;

			if (e == null)
				throw new ArgumentNullException("e");

			return UrlDecodeToBytes(e.GetBytes(str));
		}

		public static byte[] UrlDecodeToBytes(byte[] bytes, int offset, int count)
		{
			if (bytes == null)
				return null;
			if (count == 0)
				return new byte[0];

			int len = bytes.Length;
			if (offset < 0 || offset >= len)
				throw new ArgumentOutOfRangeException("offset");

			if (count < 0 || offset > len - count)
				throw new ArgumentOutOfRangeException("count");

			MemoryStream result = new MemoryStream();
			int end = offset + count;
			for (int i = offset; i < end; i++)
			{
				char c = (char)bytes[i];
				if (c == '+')
				{
					c = ' ';
				}
				else if (c == '%' && i < end - 2)
				{
					int xchar = GetChar(bytes, i + 1, 2);
					if (xchar != -1)
					{
						c = (char)xchar;
						i += 2;
					}
				}
				result.WriteByte((byte)c);
			}

			return result.ToArray();
		}

		public static string UrlEncode(string str)
		{
			return UrlEncode(str, Encoding.UTF8);
		}

		public static string UrlEncode(string s, Encoding Enc)
		{
			if (s == null)
				return null;

			if (s == String.Empty)
				return String.Empty;

			bool needEncode = false;
			int len = s.Length;
			for (int i = 0; i < len; i++)
			{
				char c = s[i];
				if ((c < '0') || (c < 'A' && c > '9') || (c > 'Z' && c < 'a') || (c > 'z'))
				{
					if (HttpEncoder.NotEncoded(c))
						continue;

					needEncode = true;
					break;
				}
			}

			if (!needEncode)
				return s;

			// avoided GetByteCount call
			byte[] bytes = new byte[Enc.GetMaxByteCount(s.Length)];
			int realLen = Enc.GetBytes(s, 0, s.Length, bytes, 0);
			return Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, 0, realLen));
		}

		public static string UrlEncode(byte[] bytes)
		{
			if (bytes == null)
				return null;

			if (bytes.Length == 0)
				return String.Empty;

			return Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, 0, bytes.Length));
		}

		public static string UrlEncode(byte[] bytes, int offset, int count)
		{
			if (bytes == null)
				return null;

			if (bytes.Length == 0)
				return String.Empty;

			return Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, offset, count));
		}

		public static byte[] UrlEncodeToBytes(string str)
		{
			return UrlEncodeToBytes(str, Encoding.UTF8);
		}

		public static byte[] UrlEncodeToBytes(string str, Encoding e)
		{
			if (str == null)
				return null;

			if (str.Length == 0)
				return new byte[0];

			byte[] bytes = e.GetBytes(str);
			return UrlEncodeToBytes(bytes, 0, bytes.Length);
		}

		public static byte[] UrlEncodeToBytes(byte[] bytes)
		{
			if (bytes == null)
				return null;

			if (bytes.Length == 0)
				return new byte[0];

			return UrlEncodeToBytes(bytes, 0, bytes.Length);
		}

		public static byte[] UrlEncodeToBytes(byte[] bytes, int offset, int count)
		{
			if (bytes == null)
				return null;
#if NET_4_0
			return HttpEncoder.Current.UrlEncode (bytes, offset, count);
#else
			return HttpEncoder.UrlEncodeToBytes(bytes, offset, count);
#endif
		}

		public static string UrlEncodeUnicode(string str)
		{
			if (str == null)
				return null;

			return Encoding.ASCII.GetString(UrlEncodeUnicodeToBytes(str));
		}

		public static byte[] UrlEncodeUnicodeToBytes(string str)
		{
			if (str == null)
				return null;

			if (str.Length == 0)
				return new byte[0];

			MemoryStream result = new MemoryStream(str.Length);
			foreach (char c in str)
			{
				HttpEncoder.UrlEncodeChar(c, result, true);
			}
			return result.ToArray();
		}

		/// <summary>
		/// Decodes an HTML-encoded string and returns the decoded string.
		/// </summary>
		/// <param name="s">The HTML string to decode. </param>
		/// <returns>The decoded text.</returns>
		public static string HtmlDecode(string s)
		{
#if NET_4_0
			if (s == null)
				return null;
			
			using (var sw = new StringWriter ()) {
				HttpEncoder.Current.HtmlDecode (s, sw);
				return sw.ToString ();
			}
#else
			return HttpEncoder.HtmlDecode(s);
#endif
		}

		/// <summary>
		/// Decodes an HTML-encoded string and sends the resulting output to a TextWriter output stream.
		/// </summary>
		/// <param name="s">The HTML string to decode</param>
		/// <param name="output">The TextWriter output stream containing the decoded string. </param>
		public static void HtmlDecode(string s, TextWriter output)
		{
			if (output == null)
			{
#if NET_4_0
				throw new ArgumentNullException ("output");
#else
				throw new NullReferenceException(".NET emulation");
#endif
			}

			if (!String.IsNullOrEmpty(s))
			{
#if NET_4_0
				HttpEncoder.Current.HtmlDecode (s, output);
#else
				output.Write(HttpEncoder.HtmlDecode(s));
#endif
			}
		}

		public static string HtmlEncode(string s)
		{
#if NET_4_0
			if (s == null)
				return null;
			
			using (var sw = new StringWriter ()) {
				HttpEncoder.Current.HtmlEncode (s, sw);
				return sw.ToString ();
			}
#else
			return HttpEncoder.HtmlEncode(s);
#endif
		}

		/// <summary>
		/// HTML-encodes a string and sends the resulting output to a TextWriter output stream.
		/// </summary>
		/// <param name="s">The string to encode. </param>
		/// <param name="output">The TextWriter output stream containing the encoded string. </param>
		public static void HtmlEncode(string s, TextWriter output)
		{
			if (output == null)
			{
#if NET_4_0
				throw new ArgumentNullException ("output");
#else
				throw new NullReferenceException(".NET emulation");
#endif
			}

			if (!String.IsNullOrEmpty(s))
			{
#if NET_4_0
				HttpEncoder.Current.HtmlEncode (s, output);
#else
				output.Write(HttpEncoder.HtmlEncode(s));
#endif
			}
		}
#if NET_4_0
		public static string HtmlEncode (object value)
		{
			if (value == null)
				return null;

			IHtmlString htmlString = value as IHtmlString;
			if (htmlString != null)
				return htmlString.ToHtmlString ();
			
			return HtmlEncode (value.ToString ());
		}

		public static string JavaScriptStringEncode (string value)
		{
			return JavaScriptStringEncode (value, false);
		}

		public static string JavaScriptStringEncode (string value, bool addDoubleQuotes)
		{
			if (String.IsNullOrEmpty (value))
				return addDoubleQuotes ? "\"\"" : String.Empty;

			int len = value.Length;
			bool needEncode = false;
			char c;
			for (int i = 0; i < len; i++) {
				c = value [i];

				if (c >= 0 && c <= 31 || c == 34 || c == 39 || c == 60 || c == 62 || c == 92) {
					needEncode = true;
					break;
				}
			}

			if (!needEncode)
				return addDoubleQuotes ? "\"" + value + "\"" : value;

			var sb = new StringBuilder ();
			if (addDoubleQuotes)
				sb.Append ('"');

			for (int i = 0; i < len; i++) {
				c = value [i];
				if (c >= 0 && c <= 7 || c == 11 || c >= 14 && c <= 31 || c == 39 || c == 60 || c == 62)
					sb.AppendFormat ("\\u{0:x4}", (int)c);
				else switch ((int)c) {
						case 8:
							sb.Append ("\\b");
							break;

						case 9:
							sb.Append ("\\t");
							break;

						case 10:
							sb.Append ("\\n");
							break;

						case 12:
							sb.Append ("\\f");
							break;

						case 13:
							sb.Append ("\\r");
							break;

						case 34:
							sb.Append ("\\\"");
							break;

						case 92:
							sb.Append ("\\\\");
							break;

						default:
							sb.Append (c);
							break;
					}
			}

			if (addDoubleQuotes)
				sb.Append ('"');

			return sb.ToString ();
		}
#endif
		public static string UrlPathEncode(string s)
		{
#if NET_4_0
			return HttpEncoder.Current.UrlPathEncode (s);
#else
			return HttpEncoder.UrlPathEncode(s);
#endif
		}

		public static NameValueCollection ParseQueryString(string query)
		{
			return ParseQueryString(query, Encoding.UTF8);
		}

		public static NameValueCollection ParseQueryString(string query, Encoding encoding)
		{
			if (query == null)
				throw new ArgumentNullException("query");
			if (encoding == null)
				throw new ArgumentNullException("encoding");
			if (query.Length == 0 || (query.Length == 1 && query[0] == '?'))
				return new NameValueCollection();
			if (query[0] == '?')
				query = query.Substring(1);

			NameValueCollection result = new HttpQSCollection();
			ParseQueryString(query, encoding, result);
			return result;
		}

		internal static void ParseQueryString(string query, Encoding encoding, NameValueCollection result)
		{
			if (query.Length == 0)
				return;

			string decoded = HtmlDecode(query);
			int decodedLength = decoded.Length;
			int namePos = 0;
			bool first = true;
			while (namePos <= decodedLength)
			{
				int valuePos = -1, valueEnd = -1;
				for (int q = namePos; q < decodedLength; q++)
				{
					if (valuePos == -1 && decoded[q] == '=')
					{
						valuePos = q + 1;
					}
					else if (decoded[q] == '&')
					{
						valueEnd = q;
						break;
					}
				}

				if (first)
				{
					first = false;
					if (decoded[namePos] == '?')
						namePos++;
				}

				string name, value;
				if (valuePos == -1)
				{
					name = null;
					valuePos = namePos;
				}
				else
				{
					name = UrlDecode(decoded.Substring(namePos, valuePos - namePos - 1), encoding);
				}
				if (valueEnd < 0)
				{
					namePos = -1;
					valueEnd = decoded.Length;
				}
				else
				{
					namePos = valueEnd + 1;
				}
				value = UrlDecode(decoded.Substring(valuePos, valueEnd - valuePos), encoding);

				result.Add(name, value);
				if (namePos == -1)
					break;
			}
		}
		#endregion // Methods
	}
}