internal static string?UrlEncodeUnicode(string?value)
{
if (value == null)
{
return(null);
}
int l = value.Length;
StringBuilder sb = new StringBuilder(l);
for (int i = 0; i < l; i++)
{
char ch = value[i];
if ((ch & 0xff80) == 0)
{ // 7 bit?
if (HttpEncoderUtility.IsUrlSafeChar(ch))
{
sb.Append(ch);
}
else if (ch == ' ')
{
sb.Append('+');
}
else
{
sb.Append('%');
sb.Append(HexConverter.ToCharLower(ch >> 4));
sb.Append(HexConverter.ToCharLower(ch));
}
}
else
{ // arbitrary Unicode?
sb.Append("%u");
sb.Append(HexConverter.ToCharLower(ch >> 12));
sb.Append(HexConverter.ToCharLower(ch >> 8));
sb.Append(HexConverter.ToCharLower(ch >> 4));
sb.Append(HexConverter.ToCharLower(ch));
}
}
return(sb.ToString());
}
internal byte[] UrlDecode(byte[] bytes, int offset, int count)
{
if (!ValidateUrlEncodingParameters(bytes, offset, count))
{
return(null);
}
int decodedBytesCount = 0;
byte[] decodedBytes = new byte[count];
for (int i = 0; i < count; i++)
{
int pos = offset + i;
byte b = bytes[pos];
if (b == '+')
{
b = (byte)' ';
}
else if (b == '%' && i < count - 2)
{
int h1 = HttpEncoderUtility.HexToInt((char)bytes[pos + 1]);
int h2 = HttpEncoderUtility.HexToInt((char)bytes[pos + 2]);
if (h1 >= 0 && h2 >= 0) // valid 2 hex chars
{
b = (byte)((h1 << 4) | h2);
i += 2;
}
}
decodedBytes[decodedBytesCount++] = b;
}
if (decodedBytesCount < decodedBytes.Length)
{
byte[] newDecodedBytes = new byte[decodedBytesCount];
Array.Copy(decodedBytes, newDecodedBytes, decodedBytesCount);
decodedBytes = newDecodedBytes;
}
return(decodedBytes);
}
internal static string UrlEncodeUnicode(string value, bool ignoreAscii)
{
if (value == null)
{
return(null);
}
int l = value.Length;
StringBuilder sb = new StringBuilder(l);
for (int i = 0; i < l; i++)
{
char ch = value[i];
if ((ch & 0xff80) == 0)
{ // 7 bit?
if (ignoreAscii || HttpEncoderUtility.IsUrlSafeChar(ch))
{
sb.Append(ch);
}
else if (ch == ' ')
{
sb.Append('+');
}
else
{
sb.Append('%');
sb.Append(HttpEncoderUtility.IntToHex((ch >> 4) & 0xf));
sb.Append(HttpEncoderUtility.IntToHex((ch) & 0xf));
}
}
else
{ // arbitrary Unicode?
sb.Append("%u");
sb.Append(HttpEncoderUtility.IntToHex((ch >> 12) & 0xf));
sb.Append(HttpEncoderUtility.IntToHex((ch >> 8) & 0xf));
sb.Append(HttpEncoderUtility.IntToHex((ch >> 4) & 0xf));
sb.Append(HttpEncoderUtility.IntToHex((ch) & 0xf));
}
}
return(sb.ToString());
}
private static byte[] UrlEncodeNonAscii(byte[] bytes, int offset, int count)
{
int cNonAscii = 0;
// count them first
for (int i = 0; i < count; i++)
{
if (IsNonAsciiByte(bytes[offset + i]))
{
cNonAscii++;
}
}
// nothing to expand?
if (cNonAscii == 0)
{
return(bytes);
}
// expand not 'safe' characters into %XX, spaces to +s
byte[] expandedBytes = new byte[count + cNonAscii * 2];
int pos = 0;
for (int i = 0; i < count; i++)
{
byte b = bytes[offset + i];
if (IsNonAsciiByte(b))
{
expandedBytes[pos++] = (byte)'%';
expandedBytes[pos++] = (byte)HttpEncoderUtility.IntToHex((b >> 4) & 0xf);
expandedBytes[pos++] = (byte)HttpEncoderUtility.IntToHex(b & 0x0f);
}
else
{
expandedBytes[pos++] = b;
}
}
return(expandedBytes);
}
internal string UrlEncodeUnicode(string value, bool ignoreAscii)
{
if (value == null)
{
return(null);
}
int length = value.Length;
StringBuilder builder = new StringBuilder(length);
for (int i = 0; i < length; i++)
{
char ch = value[i];
if ((ch & 0xff80) == 0)
{
if (ignoreAscii || HttpEncoderUtility.IsUrlSafeChar(ch))
{
builder.Append(ch);
}
else if (ch == ' ')
{
builder.Append('+');
}
else
{
builder.Append('%');
builder.Append(HttpEncoderUtility.IntToHex((ch >> 4) & '\x000f'));
builder.Append(HttpEncoderUtility.IntToHex(ch & '\x000f'));
}
}
else
{
builder.Append("%u");
builder.Append(HttpEncoderUtility.IntToHex((ch >> 12) & '\x000f'));
builder.Append(HttpEncoderUtility.IntToHex((ch >> 8) & '\x000f'));
builder.Append(HttpEncoderUtility.IntToHex((ch >> 4) & '\x000f'));
builder.Append(HttpEncoderUtility.IntToHex(ch & '\x000f'));
}
}
return(builder.ToString());
}
internal byte[] UrlEncodeNonAscii(byte[] bytes, int offset, int count, bool alwaysCreateNewReturnValue)
{
if (!ValidateUrlEncodingParameters(bytes, offset, count))
{
return(null);
}
int num = 0;
for (int i = 0; i < count; i++)
{
if (IsNonAsciiByte(bytes[offset + i]))
{
num++;
}
}
if (!alwaysCreateNewReturnValue && (num == 0))
{
return(bytes);
}
byte[] buffer = new byte[count + (num * 2)];
int num3 = 0;
for (int j = 0; j < count; j++)
{
byte b = bytes[offset + j];
if (IsNonAsciiByte(b))
{
buffer[num3++] = 0x25;
buffer[num3++] = (byte)HttpEncoderUtility.IntToHex((b >> 4) & 15);
buffer[num3++] = (byte)HttpEncoderUtility.IntToHex(b & 15);
}
else
{
buffer[num3++] = b;
}
}
return(buffer);
}
internal byte[] UrlDecode(byte[] bytes, int offset, int count)
{
if (!ValidateUrlEncodingParameters(bytes, offset, count))
{
return(null);
}
int length = 0;
byte[] sourceArray = new byte[count];
for (int i = 0; i < count; i++)
{
int index = offset + i;
byte num4 = bytes[index];
if (num4 == 0x2b)
{
num4 = 0x20;
}
else if ((num4 == 0x25) && (i < (count - 2)))
{
int num5 = HttpEncoderUtility.HexToInt((char)bytes[index + 1]);
int num6 = HttpEncoderUtility.HexToInt((char)bytes[index + 2]);
if ((num5 >= 0) && (num6 >= 0))
{
num4 = (byte)((num5 << 4) | num6);
i += 2;
}
}
sourceArray[length++] = num4;
}
if (length < sourceArray.Length)
{
byte[] destinationArray = new byte[length];
Array.Copy(sourceArray, destinationArray, length);
sourceArray = destinationArray;
}
return(sourceArray);
}
internal static string CollapsePercentUFromStringInternal(string s, Encoding e)
{
int length = s.Length;
UrlDecoder decoder = new UrlDecoder(length, e);
if (s.IndexOf("%u", StringComparison.Ordinal) == -1)
{
return(s);
}
for (int i = 0; i < length; i++)
{
char ch = s[i];
if (((ch == '%') && (i < (length - 5))) && (s[i + 1] == 'u'))
{
int num4 = HttpEncoderUtility.HexToInt(s[i + 2]);
int num5 = HttpEncoderUtility.HexToInt(s[i + 3]);
int num6 = HttpEncoderUtility.HexToInt(s[i + 4]);
int num7 = HttpEncoderUtility.HexToInt(s[i + 5]);
if (((num4 >= 0) && (num5 >= 0)) && ((num6 >= 0) && (num7 >= 0)))
{
ch = (char)((((num4 << 12) | (num5 << 8)) | (num6 << 4)) | num7);
i += 5;
decoder.AddChar(ch);
continue;
}
}
if ((ch & 0xff80) == 0)
{
decoder.AddByte((byte)ch);
}
else
{
decoder.AddChar(ch);
}
}
return(decoder.GetString());
}
private static byte[] UrlEncode(byte[] bytes, int offset, int count)
{
if (!ValidateUrlEncodingParameters(bytes, offset, count))
{
return(null);
}
int cSpaces = 0;
int cUnsafe = 0;
// count them first
for (int i = 0; i < count; i++)
{
char ch = (char)bytes[offset + i];
if (ch == ' ')
{
cSpaces++;
}
else if (!HttpEncoderUtility.IsUrlSafeChar(ch))
{
cUnsafe++;
}
}
// nothing to expand?
if (cSpaces == 0 && cUnsafe == 0)
{
// DevDiv 912606: respect "offset" and "count"
if (0 == offset && bytes.Length == count)
{
return(bytes);
}
else
{
var subarray = new byte[count];
Buffer.BlockCopy(bytes, offset, subarray, 0, count);
return(subarray);
}
}
// expand not 'safe' characters into %XX, spaces to +s
byte[] expandedBytes = new byte[count + cUnsafe * 2];
int pos = 0;
for (int i = 0; i < count; i++)
{
byte b = bytes[offset + i];
char ch = (char)b;
if (HttpEncoderUtility.IsUrlSafeChar(ch))
{
expandedBytes[pos++] = b;
}
else if (ch == ' ')
{
expandedBytes[pos++] = (byte)'+';
}
else
{
expandedBytes[pos++] = (byte)'%';
expandedBytes[pos++] = (byte)HttpEncoderUtility.IntToHex((b >> 4) & 0xf);
expandedBytes[pos++] = (byte)HttpEncoderUtility.IntToHex(b & 0x0f);
}
}
return(expandedBytes);
}
internal static string UrlDecode(string value, Encoding encoding)
{
if (value == null)
{
return(null);
}
int count = value.Length;
UrlDecoder helper = new UrlDecoder(count, encoding);
// go through the string's chars collapsing %XX and %uXXXX and
// appending each char as char, with exception of %XX constructs
// that are appended as bytes
for (int pos = 0; pos < count; pos++)
{
char ch = value[pos];
if (ch == '+')
{
ch = ' ';
}
else if (ch == '%' && pos < count - 2)
{
if (value[pos + 1] == 'u' && pos < count - 5)
{
int h1 = HttpEncoderUtility.HexToInt(value[pos + 2]);
int h2 = HttpEncoderUtility.HexToInt(value[pos + 3]);
int h3 = HttpEncoderUtility.HexToInt(value[pos + 4]);
int h4 = HttpEncoderUtility.HexToInt(value[pos + 5]);
if (h1 >= 0 && h2 >= 0 && h3 >= 0 && h4 >= 0)
{ // valid 4 hex chars
ch = (char)((h1 << 12) | (h2 << 8) | (h3 << 4) | h4);
pos += 5;
// only add as char
helper.AddChar(ch);
continue;
}
}
else
{
int h1 = HttpEncoderUtility.HexToInt(value[pos + 1]);
int h2 = HttpEncoderUtility.HexToInt(value[pos + 2]);
if (h1 >= 0 && h2 >= 0)
{ // valid 2 hex chars
byte b = (byte)((h1 << 4) | h2);
pos += 2;
// don't add as char
helper.AddByte(b);
continue;
}
}
}
if ((ch & 0xFF80) == 0)
{
helper.AddByte((byte)ch); // 7 bit have to go as bytes because of Unicode
}
else
{
helper.AddChar(ch);
}
}
return(Utf16StringValidator.ValidateString(helper.GetString()));
}
internal static string UrlDecode(byte[] bytes, int offset, int count, Encoding encoding)
{
if (!ValidateUrlEncodingParameters(bytes, offset, count))
{
return(null);
}
UrlDecoder helper = new UrlDecoder(count, encoding);
// go through the bytes collapsing %XX and %uXXXX and appending
// each byte as byte, with exception of %uXXXX constructs that
// are appended as chars
for (int i = 0; i < count; i++)
{
int pos = offset + i;
byte b = bytes[pos];
// The code assumes that + and % cannot be in multibyte sequence
if (b == '+')
{
b = (byte)' ';
}
else if (b == '%' && i < count - 2)
{
if (bytes[pos + 1] == 'u' && i < count - 5)
{
int h1 = HttpEncoderUtility.HexToInt((char)bytes[pos + 2]);
int h2 = HttpEncoderUtility.HexToInt((char)bytes[pos + 3]);
int h3 = HttpEncoderUtility.HexToInt((char)bytes[pos + 4]);
int h4 = HttpEncoderUtility.HexToInt((char)bytes[pos + 5]);
if (h1 >= 0 && h2 >= 0 && h3 >= 0 && h4 >= 0)
{ // valid 4 hex chars
char ch = (char)((h1 << 12) | (h2 << 8) | (h3 << 4) | h4);
i += 5;
// don't add as byte
helper.AddChar(ch);
continue;
}
}
else
{
int h1 = HttpEncoderUtility.HexToInt((char)bytes[pos + 1]);
int h2 = HttpEncoderUtility.HexToInt((char)bytes[pos + 2]);
if (h1 >= 0 && h2 >= 0)
{ // valid 2 hex chars
b = (byte)((h1 << 4) | h2);
i += 2;
}
}
}
helper.AddByte(b);
}
return(Utf16StringValidator.ValidateString(helper.GetString()));
}
internal static byte[] UrlDecode(byte[] bytes, int offset, int count)
{
if (!ValidateUrlEncodingParameters(bytes, offset, count))
{
return(null);
}
int decodedBytesCount = 0;
byte[] decodedBytes = new byte[count];
for (int i = 0; i < count; i++)
{
int pos = offset + i;
byte b = bytes[pos];
if (b == '+')
{
b = (byte)' ';
}
else if (b == '%' && i < count - 2)
{
if (bytes[pos + 1] == 'u' && i < count - 5)
{
int h1 = HttpEncoderUtility.HexToInt((char)bytes[pos + 2]);
int h2 = HttpEncoderUtility.HexToInt((char)bytes[pos + 3]);
int h3 = HttpEncoderUtility.HexToInt((char)bytes[pos + 4]);
int h4 = HttpEncoderUtility.HexToInt((char)bytes[pos + 5]);
if (h1 >= 0 && h2 >= 0 && h3 >= 0 && h4 >= 0)
{
// valid 4 hex chars
char ch = (char)((h1 << 12) | (h2 << 8) | (h3 << 4) | h4);
i += 5;
byte[] chBytes = Encoding.UTF8.GetBytes(new[] { ch });
if (chBytes.Length == 1)
{
b = chBytes[0];
}
else
{
for (int j = 0; j < chBytes.Length - 1; j++)
{
decodedBytes[decodedBytesCount++] = chBytes[j];
}
b = chBytes[chBytes.Length - 1];
}
}
}
else
{
int h1 = HttpEncoderUtility.HexToInt((char)bytes[pos + 1]);
int h2 = HttpEncoderUtility.HexToInt((char)bytes[pos + 2]);
if (h1 >= 0 && h2 >= 0)
{
// valid 2 hex chars
b = (byte)((h1 << 4) | h2);
i += 2;
}
}
}
decodedBytes[decodedBytesCount++] = b;
}
if (decodedBytesCount < decodedBytes.Length)
{
byte[] newDecodedBytes = new byte[decodedBytesCount];
Array.Copy(decodedBytes, newDecodedBytes, decodedBytesCount);
decodedBytes = newDecodedBytes;
}
return(decodedBytes);
}
