niko
1424 lines
34 KiB
C#
1424 lines
34 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
namespace Mono.Security
|
|
{
|
|
// Token: 0x020000EB RID: 235
|
|
internal class Uri
|
|
{
|
|
// Token: 0x06000B9A RID: 2970 RVA: 0x000336F0 File Offset: 0x000318F0
|
|
public Uri(string uriString)
|
|
: this(uriString, false)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B9B RID: 2971 RVA: 0x000336FC File Offset: 0x000318FC
|
|
public Uri(string uriString, bool dontEscape)
|
|
{
|
|
this.scheme = string.Empty;
|
|
this.host = string.Empty;
|
|
this.port = -1;
|
|
this.path = string.Empty;
|
|
this.query = string.Empty;
|
|
this.fragment = string.Empty;
|
|
this.userinfo = string.Empty;
|
|
this.reduce = true;
|
|
base..ctor();
|
|
this.userEscaped = dontEscape;
|
|
this.source = uriString;
|
|
this.Parse();
|
|
}
|
|
|
|
// Token: 0x06000B9C RID: 2972 RVA: 0x00033774 File Offset: 0x00031974
|
|
public Uri(string uriString, bool dontEscape, bool reduce)
|
|
{
|
|
this.scheme = string.Empty;
|
|
this.host = string.Empty;
|
|
this.port = -1;
|
|
this.path = string.Empty;
|
|
this.query = string.Empty;
|
|
this.fragment = string.Empty;
|
|
this.userinfo = string.Empty;
|
|
this.reduce = true;
|
|
base..ctor();
|
|
this.userEscaped = dontEscape;
|
|
this.source = uriString;
|
|
this.reduce = reduce;
|
|
this.Parse();
|
|
}
|
|
|
|
// Token: 0x06000B9D RID: 2973 RVA: 0x000337F4 File Offset: 0x000319F4
|
|
public Uri(Uri baseUri, string relativeUri)
|
|
: this(baseUri, relativeUri, false)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000B9E RID: 2974 RVA: 0x00033800 File Offset: 0x00031A00
|
|
public Uri(Uri baseUri, string relativeUri, bool dontEscape)
|
|
{
|
|
this.scheme = string.Empty;
|
|
this.host = string.Empty;
|
|
this.port = -1;
|
|
this.path = string.Empty;
|
|
this.query = string.Empty;
|
|
this.fragment = string.Empty;
|
|
this.userinfo = string.Empty;
|
|
this.reduce = true;
|
|
base..ctor();
|
|
if (baseUri == null)
|
|
{
|
|
throw new NullReferenceException("baseUri");
|
|
}
|
|
this.userEscaped = dontEscape;
|
|
if (relativeUri == null)
|
|
{
|
|
throw new NullReferenceException("relativeUri");
|
|
}
|
|
if (relativeUri.StartsWith("\\\\"))
|
|
{
|
|
this.source = relativeUri;
|
|
this.Parse();
|
|
return;
|
|
}
|
|
int num = relativeUri.IndexOf(':');
|
|
if (num != -1)
|
|
{
|
|
int num2 = relativeUri.IndexOfAny(new char[] { '/', '\\', '?' });
|
|
if (num2 > num || num2 < 0)
|
|
{
|
|
this.source = relativeUri;
|
|
this.Parse();
|
|
return;
|
|
}
|
|
}
|
|
this.scheme = baseUri.scheme;
|
|
this.host = baseUri.host;
|
|
this.port = baseUri.port;
|
|
this.userinfo = baseUri.userinfo;
|
|
this.isUnc = baseUri.isUnc;
|
|
this.isUnixFilePath = baseUri.isUnixFilePath;
|
|
this.isOpaquePart = baseUri.isOpaquePart;
|
|
if (relativeUri == string.Empty)
|
|
{
|
|
this.path = baseUri.path;
|
|
this.query = baseUri.query;
|
|
this.fragment = baseUri.fragment;
|
|
return;
|
|
}
|
|
num = relativeUri.IndexOf('#');
|
|
if (num != -1)
|
|
{
|
|
this.fragment = relativeUri.Substring(num);
|
|
relativeUri = relativeUri.Substring(0, num);
|
|
}
|
|
num = relativeUri.IndexOf('?');
|
|
if (num != -1)
|
|
{
|
|
this.query = relativeUri.Substring(num);
|
|
if (!this.userEscaped)
|
|
{
|
|
this.query = Uri.EscapeString(this.query);
|
|
}
|
|
relativeUri = relativeUri.Substring(0, num);
|
|
}
|
|
if (relativeUri.Length > 0 && relativeUri[0] == '/')
|
|
{
|
|
if (relativeUri.Length > 1 && relativeUri[1] == '/')
|
|
{
|
|
this.source = this.scheme + ':' + relativeUri;
|
|
this.Parse();
|
|
return;
|
|
}
|
|
this.path = relativeUri;
|
|
if (!this.userEscaped)
|
|
{
|
|
this.path = Uri.EscapeString(this.path);
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
this.path = baseUri.path;
|
|
if (relativeUri.Length > 0 || this.query.Length > 0)
|
|
{
|
|
num = this.path.LastIndexOf('/');
|
|
if (num >= 0)
|
|
{
|
|
this.path = this.path.Substring(0, num + 1);
|
|
}
|
|
}
|
|
if (relativeUri.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
this.path += relativeUri;
|
|
int num3 = 0;
|
|
for (;;)
|
|
{
|
|
num = this.path.IndexOf("./", num3);
|
|
if (num == -1)
|
|
{
|
|
break;
|
|
}
|
|
if (num == 0)
|
|
{
|
|
this.path = this.path.Remove(0, 2);
|
|
}
|
|
else if (this.path[num - 1] != '.')
|
|
{
|
|
this.path = this.path.Remove(num, 2);
|
|
}
|
|
else
|
|
{
|
|
num3 = num + 1;
|
|
}
|
|
}
|
|
if (this.path.Length > 1 && this.path[this.path.Length - 1] == '.' && this.path[this.path.Length - 2] == '/')
|
|
{
|
|
this.path = this.path.Remove(this.path.Length - 1, 1);
|
|
}
|
|
num3 = 0;
|
|
for (;;)
|
|
{
|
|
num = this.path.IndexOf("/../", num3);
|
|
if (num == -1)
|
|
{
|
|
break;
|
|
}
|
|
if (num == 0)
|
|
{
|
|
num3 = 3;
|
|
}
|
|
else
|
|
{
|
|
int num4 = this.path.LastIndexOf('/', num - 1);
|
|
if (num4 == -1)
|
|
{
|
|
num3 = num + 1;
|
|
}
|
|
else if (this.path.Substring(num4 + 1, num - num4 - 1) != "..")
|
|
{
|
|
this.path = this.path.Remove(num4 + 1, num - num4 + 3);
|
|
}
|
|
else
|
|
{
|
|
num3 = num + 1;
|
|
}
|
|
}
|
|
}
|
|
if (this.path.Length > 3 && this.path.EndsWith("/.."))
|
|
{
|
|
num = this.path.LastIndexOf('/', this.path.Length - 4);
|
|
if (num != -1 && this.path.Substring(num + 1, this.path.Length - num - 4) != "..")
|
|
{
|
|
this.path = this.path.Remove(num + 1, this.path.Length - num - 1);
|
|
}
|
|
}
|
|
if (!this.userEscaped)
|
|
{
|
|
this.path = Uri.EscapeString(this.path);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001A7 RID: 423
|
|
// (get) Token: 0x06000BA0 RID: 2976 RVA: 0x00033E64 File Offset: 0x00032064
|
|
public string AbsolutePath
|
|
{
|
|
get
|
|
{
|
|
return this.path;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001A8 RID: 424
|
|
// (get) Token: 0x06000BA1 RID: 2977 RVA: 0x00033E6C File Offset: 0x0003206C
|
|
public string AbsoluteUri
|
|
{
|
|
get
|
|
{
|
|
if (this.cachedAbsoluteUri == null)
|
|
{
|
|
this.cachedAbsoluteUri = this.GetLeftPart(UriPartial.Path) + this.query + this.fragment;
|
|
}
|
|
return this.cachedAbsoluteUri;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001A9 RID: 425
|
|
// (get) Token: 0x06000BA2 RID: 2978 RVA: 0x00033EA0 File Offset: 0x000320A0
|
|
public string Authority
|
|
{
|
|
get
|
|
{
|
|
return (Uri.GetDefaultPort(this.scheme) != this.port) ? (this.host + ":" + this.port) : this.host;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001AA RID: 426
|
|
// (get) Token: 0x06000BA3 RID: 2979 RVA: 0x00033EEC File Offset: 0x000320EC
|
|
public string Fragment
|
|
{
|
|
get
|
|
{
|
|
return this.fragment;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001AB RID: 427
|
|
// (get) Token: 0x06000BA4 RID: 2980 RVA: 0x00033EF4 File Offset: 0x000320F4
|
|
public string Host
|
|
{
|
|
get
|
|
{
|
|
return this.host;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001AC RID: 428
|
|
// (get) Token: 0x06000BA5 RID: 2981 RVA: 0x00033EFC File Offset: 0x000320FC
|
|
public bool IsDefaultPort
|
|
{
|
|
get
|
|
{
|
|
return Uri.GetDefaultPort(this.scheme) == this.port;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001AD RID: 429
|
|
// (get) Token: 0x06000BA6 RID: 2982 RVA: 0x00033F14 File Offset: 0x00032114
|
|
public bool IsFile
|
|
{
|
|
get
|
|
{
|
|
return this.scheme == Uri.UriSchemeFile;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001AE RID: 430
|
|
// (get) Token: 0x06000BA7 RID: 2983 RVA: 0x00033F28 File Offset: 0x00032128
|
|
public bool IsLoopback
|
|
{
|
|
get
|
|
{
|
|
return !(this.host == string.Empty) && (this.host == "loopback" || this.host == "localhost");
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001AF RID: 431
|
|
// (get) Token: 0x06000BA8 RID: 2984 RVA: 0x00033F7C File Offset: 0x0003217C
|
|
public bool IsUnc
|
|
{
|
|
get
|
|
{
|
|
return this.isUnc;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B0 RID: 432
|
|
// (get) Token: 0x06000BA9 RID: 2985 RVA: 0x00033F84 File Offset: 0x00032184
|
|
public string LocalPath
|
|
{
|
|
get
|
|
{
|
|
if (this.cachedLocalPath != null)
|
|
{
|
|
return this.cachedLocalPath;
|
|
}
|
|
if (!this.IsFile)
|
|
{
|
|
return this.AbsolutePath;
|
|
}
|
|
bool flag = this.path.Length > 3 && this.path[1] == ':' && (this.path[2] == '\\' || this.path[2] == '/');
|
|
if (!this.IsUnc)
|
|
{
|
|
string text = this.Unescape(this.path);
|
|
if (Path.DirectorySeparatorChar == '\\' || flag)
|
|
{
|
|
this.cachedLocalPath = text.Replace('/', '\\');
|
|
}
|
|
else
|
|
{
|
|
this.cachedLocalPath = text;
|
|
}
|
|
}
|
|
else if (this.path.Length > 1 && this.path[1] == ':')
|
|
{
|
|
this.cachedLocalPath = this.Unescape(this.path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar));
|
|
}
|
|
else if (Path.DirectorySeparatorChar == '\\')
|
|
{
|
|
this.cachedLocalPath = "\\\\" + this.Unescape(this.host + this.path.Replace('/', '\\'));
|
|
}
|
|
else
|
|
{
|
|
this.cachedLocalPath = this.Unescape(this.path);
|
|
}
|
|
if (this.cachedLocalPath == string.Empty)
|
|
{
|
|
this.cachedLocalPath = Path.DirectorySeparatorChar.ToString();
|
|
}
|
|
return this.cachedLocalPath;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B1 RID: 433
|
|
// (get) Token: 0x06000BAA RID: 2986 RVA: 0x0003411C File Offset: 0x0003231C
|
|
public string PathAndQuery
|
|
{
|
|
get
|
|
{
|
|
return this.path + this.query;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B2 RID: 434
|
|
// (get) Token: 0x06000BAB RID: 2987 RVA: 0x00034130 File Offset: 0x00032330
|
|
public int Port
|
|
{
|
|
get
|
|
{
|
|
return this.port;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B3 RID: 435
|
|
// (get) Token: 0x06000BAC RID: 2988 RVA: 0x00034138 File Offset: 0x00032338
|
|
public string Query
|
|
{
|
|
get
|
|
{
|
|
return this.query;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B4 RID: 436
|
|
// (get) Token: 0x06000BAD RID: 2989 RVA: 0x00034140 File Offset: 0x00032340
|
|
public string Scheme
|
|
{
|
|
get
|
|
{
|
|
return this.scheme;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B5 RID: 437
|
|
// (get) Token: 0x06000BAE RID: 2990 RVA: 0x00034148 File Offset: 0x00032348
|
|
public string[] Segments
|
|
{
|
|
get
|
|
{
|
|
if (this.segments != null)
|
|
{
|
|
return this.segments;
|
|
}
|
|
if (this.path.Length == 0)
|
|
{
|
|
this.segments = new string[0];
|
|
return this.segments;
|
|
}
|
|
string[] array = this.path.Split(new char[] { '/' });
|
|
this.segments = array;
|
|
bool flag = this.path.EndsWith("/");
|
|
if (array.Length > 0 && flag)
|
|
{
|
|
string[] array2 = new string[array.Length - 1];
|
|
Array.Copy(array, 0, array2, 0, array.Length - 1);
|
|
array = array2;
|
|
}
|
|
int i = 0;
|
|
if (this.IsFile && this.path.Length > 1 && this.path[1] == ':')
|
|
{
|
|
string[] array3 = new string[array.Length + 1];
|
|
Array.Copy(array, 1, array3, 2, array.Length - 1);
|
|
array = array3;
|
|
array[0] = this.path.Substring(0, 2);
|
|
array[1] = string.Empty;
|
|
i++;
|
|
}
|
|
int num = array.Length;
|
|
while (i < num)
|
|
{
|
|
if (i != num - 1 || flag)
|
|
{
|
|
string[] array4 = array;
|
|
int num2 = i;
|
|
array4[num2] += '/';
|
|
}
|
|
i++;
|
|
}
|
|
this.segments = array;
|
|
return this.segments;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B6 RID: 438
|
|
// (get) Token: 0x06000BAF RID: 2991 RVA: 0x00034298 File Offset: 0x00032498
|
|
public bool UserEscaped
|
|
{
|
|
get
|
|
{
|
|
return this.userEscaped;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B7 RID: 439
|
|
// (get) Token: 0x06000BB0 RID: 2992 RVA: 0x000342A0 File Offset: 0x000324A0
|
|
public string UserInfo
|
|
{
|
|
get
|
|
{
|
|
return this.userinfo;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000BB1 RID: 2993 RVA: 0x000342A8 File Offset: 0x000324A8
|
|
internal static bool IsIPv4Address(string name)
|
|
{
|
|
string[] array = name.Split(new char[] { '.' });
|
|
if (array.Length != 4)
|
|
{
|
|
return false;
|
|
}
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
try
|
|
{
|
|
int num = int.Parse(array[i], CultureInfo.InvariantCulture);
|
|
if (num < 0 || num > 255)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000BB2 RID: 2994 RVA: 0x0003433C File Offset: 0x0003253C
|
|
internal static bool IsDomainAddress(string name)
|
|
{
|
|
int length = name.Length;
|
|
if (name[length - 1] == '.')
|
|
{
|
|
return false;
|
|
}
|
|
int num = 0;
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
char c = name[i];
|
|
if (num == 0)
|
|
{
|
|
if (!char.IsLetterOrDigit(c))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (c == '.')
|
|
{
|
|
num = 0;
|
|
}
|
|
else if (!char.IsLetterOrDigit(c) && c != '-' && c != '_')
|
|
{
|
|
return false;
|
|
}
|
|
if (++num == 64)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000BB3 RID: 2995 RVA: 0x000343D4 File Offset: 0x000325D4
|
|
public static bool CheckSchemeName(string schemeName)
|
|
{
|
|
if (schemeName == null || schemeName.Length == 0)
|
|
{
|
|
return false;
|
|
}
|
|
if (!char.IsLetter(schemeName[0]))
|
|
{
|
|
return false;
|
|
}
|
|
int length = schemeName.Length;
|
|
for (int i = 1; i < length; i++)
|
|
{
|
|
char c = schemeName[i];
|
|
if (!char.IsLetterOrDigit(c) && c != '.' && c != '+' && c != '-')
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000BB4 RID: 2996 RVA: 0x00034450 File Offset: 0x00032650
|
|
public override bool Equals(object comparant)
|
|
{
|
|
if (comparant == null)
|
|
{
|
|
return false;
|
|
}
|
|
Uri uri = comparant as Uri;
|
|
if (uri == null)
|
|
{
|
|
string text = comparant as string;
|
|
if (text == null)
|
|
{
|
|
return false;
|
|
}
|
|
uri = new Uri(text);
|
|
}
|
|
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
|
|
return this.scheme.ToLower(invariantCulture) == uri.scheme.ToLower(invariantCulture) && this.userinfo.ToLower(invariantCulture) == uri.userinfo.ToLower(invariantCulture) && this.host.ToLower(invariantCulture) == uri.host.ToLower(invariantCulture) && this.port == uri.port && this.path == uri.path && this.query.ToLower(invariantCulture) == uri.query.ToLower(invariantCulture);
|
|
}
|
|
|
|
// Token: 0x06000BB5 RID: 2997 RVA: 0x0003453C File Offset: 0x0003273C
|
|
public override int GetHashCode()
|
|
{
|
|
if (this.cachedHashCode == 0)
|
|
{
|
|
this.cachedHashCode = this.scheme.GetHashCode() + this.userinfo.GetHashCode() + this.host.GetHashCode() + this.port + this.path.GetHashCode() + this.query.GetHashCode();
|
|
}
|
|
return this.cachedHashCode;
|
|
}
|
|
|
|
// Token: 0x06000BB6 RID: 2998 RVA: 0x000345A4 File Offset: 0x000327A4
|
|
public string GetLeftPart(UriPartial part)
|
|
{
|
|
switch (part)
|
|
{
|
|
case UriPartial.Scheme:
|
|
return this.scheme + this.GetOpaqueWiseSchemeDelimiter();
|
|
case UriPartial.Authority:
|
|
{
|
|
if (this.host == string.Empty || this.scheme == Uri.UriSchemeMailto || this.scheme == Uri.UriSchemeNews)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
stringBuilder.Append(this.scheme);
|
|
stringBuilder.Append(this.GetOpaqueWiseSchemeDelimiter());
|
|
if (this.path.Length > 1 && this.path[1] == ':' && Uri.UriSchemeFile == this.scheme)
|
|
{
|
|
stringBuilder.Append('/');
|
|
}
|
|
if (this.userinfo.Length > 0)
|
|
{
|
|
stringBuilder.Append(this.userinfo).Append('@');
|
|
}
|
|
stringBuilder.Append(this.host);
|
|
int num = Uri.GetDefaultPort(this.scheme);
|
|
if (this.port != -1 && this.port != num)
|
|
{
|
|
stringBuilder.Append(':').Append(this.port);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
case UriPartial.Path:
|
|
{
|
|
StringBuilder stringBuilder2 = new StringBuilder();
|
|
stringBuilder2.Append(this.scheme);
|
|
stringBuilder2.Append(this.GetOpaqueWiseSchemeDelimiter());
|
|
if (this.path.Length > 1 && this.path[1] == ':' && Uri.UriSchemeFile == this.scheme)
|
|
{
|
|
stringBuilder2.Append('/');
|
|
}
|
|
if (this.userinfo.Length > 0)
|
|
{
|
|
stringBuilder2.Append(this.userinfo).Append('@');
|
|
}
|
|
stringBuilder2.Append(this.host);
|
|
int num = Uri.GetDefaultPort(this.scheme);
|
|
if (this.port != -1 && this.port != num)
|
|
{
|
|
stringBuilder2.Append(':').Append(this.port);
|
|
}
|
|
stringBuilder2.Append(this.path);
|
|
return stringBuilder2.ToString();
|
|
}
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000BB7 RID: 2999 RVA: 0x000347D8 File Offset: 0x000329D8
|
|
public static int FromHex(char digit)
|
|
{
|
|
if ('0' <= digit && digit <= '9')
|
|
{
|
|
return (int)(digit - '0');
|
|
}
|
|
if ('a' <= digit && digit <= 'f')
|
|
{
|
|
return (int)(digit - 'a' + '\n');
|
|
}
|
|
if ('A' <= digit && digit <= 'F')
|
|
{
|
|
return (int)(digit - 'A' + '\n');
|
|
}
|
|
throw new ArgumentException("digit");
|
|
}
|
|
|
|
// Token: 0x06000BB8 RID: 3000 RVA: 0x00034834 File Offset: 0x00032A34
|
|
public static string HexEscape(char character)
|
|
{
|
|
if (character > 'ÿ')
|
|
{
|
|
throw new ArgumentOutOfRangeException("character");
|
|
}
|
|
return "%" + Uri.hexUpperChars[(int)((character & 'ð') >> 4)] + Uri.hexUpperChars[(int)(character & '\u000f')];
|
|
}
|
|
|
|
// Token: 0x06000BB9 RID: 3001 RVA: 0x0003488C File Offset: 0x00032A8C
|
|
public static char HexUnescape(string pattern, ref int index)
|
|
{
|
|
if (pattern == null)
|
|
{
|
|
throw new ArgumentException("pattern");
|
|
}
|
|
if (index < 0 || index >= pattern.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("index");
|
|
}
|
|
int num = 0;
|
|
int num2 = 0;
|
|
while (index + 3 <= pattern.Length && pattern[index] == '%' && Uri.IsHexDigit(pattern[index + 1]) && Uri.IsHexDigit(pattern[index + 2]))
|
|
{
|
|
index++;
|
|
int num3 = Uri.FromHex(pattern[index++]);
|
|
int num4 = Uri.FromHex(pattern[index++]);
|
|
int num5 = (num3 << 4) + num4;
|
|
if (num == 0)
|
|
{
|
|
if (num5 < 192)
|
|
{
|
|
return (char)num5;
|
|
}
|
|
if (num5 < 224)
|
|
{
|
|
num2 = num5 - 192;
|
|
num = 2;
|
|
}
|
|
else if (num5 < 240)
|
|
{
|
|
num2 = num5 - 224;
|
|
num = 3;
|
|
}
|
|
else if (num5 < 248)
|
|
{
|
|
num2 = num5 - 240;
|
|
num = 4;
|
|
}
|
|
else if (num5 < 251)
|
|
{
|
|
num2 = num5 - 248;
|
|
num = 5;
|
|
}
|
|
else if (num5 < 254)
|
|
{
|
|
num2 = num5 - 252;
|
|
num = 6;
|
|
}
|
|
num2 <<= (num - 1) * 6;
|
|
}
|
|
else
|
|
{
|
|
num2 += num5 - 128 << (num - 1) * 6;
|
|
}
|
|
num--;
|
|
if (num <= 0)
|
|
{
|
|
IL_1A2:
|
|
return (char)num2;
|
|
}
|
|
}
|
|
if (num == 0)
|
|
{
|
|
return pattern[index++];
|
|
}
|
|
goto IL_1A2;
|
|
}
|
|
|
|
// Token: 0x06000BBA RID: 3002 RVA: 0x00034A40 File Offset: 0x00032C40
|
|
public static bool IsHexDigit(char digit)
|
|
{
|
|
return ('0' <= digit && digit <= '9') || ('a' <= digit && digit <= 'f') || ('A' <= digit && digit <= 'F');
|
|
}
|
|
|
|
// Token: 0x06000BBB RID: 3003 RVA: 0x00034A84 File Offset: 0x00032C84
|
|
public static bool IsHexEncoding(string pattern, int index)
|
|
{
|
|
return index + 3 <= pattern.Length && (pattern[index++] == '%' && Uri.IsHexDigit(pattern[index++])) && Uri.IsHexDigit(pattern[index]);
|
|
}
|
|
|
|
// Token: 0x06000BBC RID: 3004 RVA: 0x00034ADC File Offset: 0x00032CDC
|
|
public string MakeRelative(Uri toUri)
|
|
{
|
|
if (this.Scheme != toUri.Scheme || this.Authority != toUri.Authority)
|
|
{
|
|
return toUri.ToString();
|
|
}
|
|
if (this.path == toUri.path)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
string[] array = this.Segments;
|
|
string[] array2 = toUri.Segments;
|
|
int i = 0;
|
|
int num = Math.Min(array.Length, array2.Length);
|
|
while (i < num)
|
|
{
|
|
if (array[i] != array2[i])
|
|
{
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
string text = string.Empty;
|
|
for (int j = i + 1; j < array.Length; j++)
|
|
{
|
|
text += "../";
|
|
}
|
|
for (int k = i; k < array2.Length; k++)
|
|
{
|
|
text += array2[k];
|
|
}
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06000BBD RID: 3005 RVA: 0x00034BD0 File Offset: 0x00032DD0
|
|
public override string ToString()
|
|
{
|
|
if (this.cachedToString != null)
|
|
{
|
|
return this.cachedToString;
|
|
}
|
|
string text = ((!this.query.StartsWith("?")) ? this.Unescape(this.query) : ('?' + this.Unescape(this.query.Substring(1))));
|
|
this.cachedToString = this.Unescape(this.GetLeftPart(UriPartial.Path), true) + text + this.fragment;
|
|
return this.cachedToString;
|
|
}
|
|
|
|
// Token: 0x06000BBE RID: 3006 RVA: 0x00034C5C File Offset: 0x00032E5C
|
|
protected void Escape()
|
|
{
|
|
this.path = Uri.EscapeString(this.path);
|
|
}
|
|
|
|
// Token: 0x06000BBF RID: 3007 RVA: 0x00034C70 File Offset: 0x00032E70
|
|
protected static string EscapeString(string str)
|
|
{
|
|
return Uri.EscapeString(str, false, true, true);
|
|
}
|
|
|
|
// Token: 0x06000BC0 RID: 3008 RVA: 0x00034C7C File Offset: 0x00032E7C
|
|
internal static string EscapeString(string str, bool escapeReserved, bool escapeHex, bool escapeBrackets)
|
|
{
|
|
if (str == null)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
int length = str.Length;
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
if (Uri.IsHexEncoding(str, i))
|
|
{
|
|
stringBuilder.Append(str.Substring(i, 3));
|
|
i += 2;
|
|
}
|
|
else
|
|
{
|
|
byte[] bytes = Encoding.UTF8.GetBytes(new char[] { str[i] });
|
|
int num = bytes.Length;
|
|
for (int j = 0; j < num; j++)
|
|
{
|
|
char c = (char)bytes[j];
|
|
if (c <= ' ' || c >= '\u007f' || "<>%\"{}|\\^`".IndexOf(c) != -1 || (escapeHex && c == '#') || (escapeBrackets && (c == '[' || c == ']')) || (escapeReserved && ";/?:@&=+$,".IndexOf(c) != -1))
|
|
{
|
|
stringBuilder.Append(Uri.HexEscape(c));
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x06000BC1 RID: 3009 RVA: 0x00034D9C File Offset: 0x00032F9C
|
|
protected void Parse()
|
|
{
|
|
this.Parse(this.source);
|
|
if (this.userEscaped)
|
|
{
|
|
return;
|
|
}
|
|
this.host = Uri.EscapeString(this.host, false, true, false);
|
|
this.path = Uri.EscapeString(this.path);
|
|
}
|
|
|
|
// Token: 0x06000BC2 RID: 3010 RVA: 0x00034DE8 File Offset: 0x00032FE8
|
|
protected string Unescape(string str)
|
|
{
|
|
return this.Unescape(str, false);
|
|
}
|
|
|
|
// Token: 0x06000BC3 RID: 3011 RVA: 0x00034DF4 File Offset: 0x00032FF4
|
|
internal string Unescape(string str, bool excludeSharp)
|
|
{
|
|
if (str == null)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
int length = str.Length;
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
char c = str[i];
|
|
if (c == '%')
|
|
{
|
|
char c2 = Uri.HexUnescape(str, ref i);
|
|
if (excludeSharp && c2 == '#')
|
|
{
|
|
stringBuilder.Append("%23");
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(c2);
|
|
}
|
|
i--;
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(c);
|
|
}
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x06000BC4 RID: 3012 RVA: 0x00034E88 File Offset: 0x00033088
|
|
private void ParseAsWindowsUNC(string uriString)
|
|
{
|
|
this.scheme = Uri.UriSchemeFile;
|
|
this.port = -1;
|
|
this.fragment = string.Empty;
|
|
this.query = string.Empty;
|
|
this.isUnc = true;
|
|
uriString = uriString.TrimStart(new char[] { '\\' });
|
|
int num = uriString.IndexOf('\\');
|
|
if (num > 0)
|
|
{
|
|
this.path = uriString.Substring(num);
|
|
this.host = uriString.Substring(0, num);
|
|
}
|
|
else
|
|
{
|
|
this.host = uriString;
|
|
this.path = string.Empty;
|
|
}
|
|
this.path = this.path.Replace("\\", "/");
|
|
}
|
|
|
|
// Token: 0x06000BC5 RID: 3013 RVA: 0x00034F34 File Offset: 0x00033134
|
|
private void ParseAsWindowsAbsoluteFilePath(string uriString)
|
|
{
|
|
if (uriString.Length > 2 && uriString[2] != '\\' && uriString[2] != '/')
|
|
{
|
|
throw new FormatException("Relative file path is not allowed.");
|
|
}
|
|
this.scheme = Uri.UriSchemeFile;
|
|
this.host = string.Empty;
|
|
this.port = -1;
|
|
this.path = uriString.Replace("\\", "/");
|
|
this.fragment = string.Empty;
|
|
this.query = string.Empty;
|
|
}
|
|
|
|
// Token: 0x06000BC6 RID: 3014 RVA: 0x00034FC0 File Offset: 0x000331C0
|
|
private void ParseAsUnixAbsoluteFilePath(string uriString)
|
|
{
|
|
this.isUnixFilePath = true;
|
|
this.scheme = Uri.UriSchemeFile;
|
|
this.port = -1;
|
|
this.fragment = string.Empty;
|
|
this.query = string.Empty;
|
|
this.host = string.Empty;
|
|
this.path = null;
|
|
if (uriString.StartsWith("//"))
|
|
{
|
|
uriString = uriString.TrimStart(new char[] { '/' });
|
|
this.path = '/' + uriString;
|
|
}
|
|
if (this.path == null)
|
|
{
|
|
this.path = uriString;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000BC7 RID: 3015 RVA: 0x00035058 File Offset: 0x00033258
|
|
private void Parse(string uriString)
|
|
{
|
|
if (uriString == null)
|
|
{
|
|
throw new ArgumentNullException("uriString");
|
|
}
|
|
int length = uriString.Length;
|
|
if (length <= 1)
|
|
{
|
|
throw new FormatException();
|
|
}
|
|
int num = uriString.IndexOf(':');
|
|
if (num < 0)
|
|
{
|
|
if (uriString[0] == '/')
|
|
{
|
|
this.ParseAsUnixAbsoluteFilePath(uriString);
|
|
}
|
|
else
|
|
{
|
|
if (!uriString.StartsWith("\\\\"))
|
|
{
|
|
throw new FormatException("URI scheme was not recognized, nor input string is not recognized as an absolute file path.");
|
|
}
|
|
this.ParseAsWindowsUNC(uriString);
|
|
}
|
|
return;
|
|
}
|
|
if (num == 1)
|
|
{
|
|
if (!char.IsLetter(uriString[0]))
|
|
{
|
|
throw new FormatException("URI scheme must start with alphabet character.");
|
|
}
|
|
this.ParseAsWindowsAbsoluteFilePath(uriString);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
this.scheme = uriString.Substring(0, num).ToLower(CultureInfo.InvariantCulture);
|
|
if (!char.IsLetter(this.scheme[0]))
|
|
{
|
|
throw new FormatException("URI scheme must start with alphabet character.");
|
|
}
|
|
for (int i = 1; i < this.scheme.Length; i++)
|
|
{
|
|
if (!char.IsLetterOrDigit(this.scheme, i))
|
|
{
|
|
switch (this.scheme[i])
|
|
{
|
|
case '+':
|
|
case '-':
|
|
case '.':
|
|
goto IL_132;
|
|
}
|
|
throw new FormatException("URI scheme must consist of one of alphabet, digits, '+', '-' or '.' character.");
|
|
}
|
|
IL_132:;
|
|
}
|
|
uriString = uriString.Substring(num + 1);
|
|
num = uriString.IndexOf('#');
|
|
if (!this.IsUnc && num != -1)
|
|
{
|
|
this.fragment = uriString.Substring(num);
|
|
uriString = uriString.Substring(0, num);
|
|
}
|
|
num = uriString.IndexOf('?');
|
|
if (num != -1)
|
|
{
|
|
this.query = uriString.Substring(num);
|
|
uriString = uriString.Substring(0, num);
|
|
if (!this.userEscaped)
|
|
{
|
|
this.query = Uri.EscapeString(this.query);
|
|
}
|
|
}
|
|
bool flag = this.scheme == Uri.UriSchemeFile && uriString.StartsWith("///");
|
|
if (uriString.StartsWith("//"))
|
|
{
|
|
if (uriString.StartsWith("////"))
|
|
{
|
|
flag = false;
|
|
}
|
|
uriString = uriString.TrimStart(new char[] { '/' });
|
|
if (uriString.Length > 1 && uriString[1] == ':')
|
|
{
|
|
flag = false;
|
|
}
|
|
}
|
|
else if (!Uri.IsPredefinedScheme(this.scheme))
|
|
{
|
|
this.path = uriString;
|
|
this.isOpaquePart = true;
|
|
return;
|
|
}
|
|
num = uriString.IndexOfAny(new char[] { '/' });
|
|
if (flag)
|
|
{
|
|
num = -1;
|
|
}
|
|
if (num == -1)
|
|
{
|
|
if (this.scheme != Uri.UriSchemeMailto && this.scheme != Uri.UriSchemeNews && this.scheme != Uri.UriSchemeFile)
|
|
{
|
|
this.path = "/";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.path = uriString.Substring(num);
|
|
uriString = uriString.Substring(0, num);
|
|
}
|
|
num = uriString.IndexOf("@");
|
|
if (num != -1)
|
|
{
|
|
this.userinfo = uriString.Substring(0, num);
|
|
uriString = uriString.Remove(0, num + 1);
|
|
}
|
|
this.port = -1;
|
|
num = uriString.LastIndexOf(":");
|
|
if (flag)
|
|
{
|
|
num = -1;
|
|
}
|
|
if (num != -1 && num != uriString.Length - 1)
|
|
{
|
|
string text = uriString.Remove(0, num + 1);
|
|
if (text.Length > 1 && text[text.Length - 1] != ']')
|
|
{
|
|
try
|
|
{
|
|
this.port = (int)uint.Parse(text, CultureInfo.InvariantCulture);
|
|
uriString = uriString.Substring(0, num);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new FormatException("Invalid URI: invalid port number");
|
|
}
|
|
}
|
|
}
|
|
if (this.port == -1)
|
|
{
|
|
this.port = Uri.GetDefaultPort(this.scheme);
|
|
}
|
|
this.host = uriString;
|
|
if (flag)
|
|
{
|
|
this.path = '/' + uriString;
|
|
this.host = string.Empty;
|
|
}
|
|
else if (this.host.Length == 2 && this.host[1] == ':')
|
|
{
|
|
this.path = this.host + this.path;
|
|
this.host = string.Empty;
|
|
}
|
|
else if (this.isUnixFilePath)
|
|
{
|
|
uriString = "//" + uriString;
|
|
this.host = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
if (this.host.Length == 0)
|
|
{
|
|
throw new FormatException("Invalid URI: The hostname could not be parsed");
|
|
}
|
|
if (this.scheme == Uri.UriSchemeFile)
|
|
{
|
|
this.isUnc = true;
|
|
}
|
|
}
|
|
if (this.scheme != Uri.UriSchemeMailto && this.scheme != Uri.UriSchemeNews && this.scheme != Uri.UriSchemeFile && this.reduce)
|
|
{
|
|
this.path = Uri.Reduce(this.path);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000BC8 RID: 3016 RVA: 0x0003557C File Offset: 0x0003377C
|
|
private static string Reduce(string path)
|
|
{
|
|
path = path.Replace('\\', '/');
|
|
string[] array = path.Split(new char[] { '/' });
|
|
ArrayList arrayList = new ArrayList();
|
|
int num = array.Length;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
string text = array[i];
|
|
if (text.Length != 0 && !(text == "."))
|
|
{
|
|
if (text == "..")
|
|
{
|
|
if (arrayList.Count == 0)
|
|
{
|
|
if (i != 1)
|
|
{
|
|
throw new Exception("Invalid path.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arrayList.RemoveAt(arrayList.Count - 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arrayList.Add(text);
|
|
}
|
|
}
|
|
}
|
|
if (arrayList.Count == 0)
|
|
{
|
|
return "/";
|
|
}
|
|
arrayList.Insert(0, string.Empty);
|
|
string text2 = string.Join("/", (string[])arrayList.ToArray(typeof(string)));
|
|
if (path.EndsWith("/"))
|
|
{
|
|
text2 += '/';
|
|
}
|
|
return text2;
|
|
}
|
|
|
|
// Token: 0x06000BC9 RID: 3017 RVA: 0x0003569C File Offset: 0x0003389C
|
|
internal static string GetSchemeDelimiter(string scheme)
|
|
{
|
|
for (int i = 0; i < Uri.schemes.Length; i++)
|
|
{
|
|
if (Uri.schemes[i].scheme == scheme)
|
|
{
|
|
return Uri.schemes[i].delimiter;
|
|
}
|
|
}
|
|
return Uri.SchemeDelimiter;
|
|
}
|
|
|
|
// Token: 0x06000BCA RID: 3018 RVA: 0x000356F4 File Offset: 0x000338F4
|
|
internal static int GetDefaultPort(string scheme)
|
|
{
|
|
for (int i = 0; i < Uri.schemes.Length; i++)
|
|
{
|
|
if (Uri.schemes[i].scheme == scheme)
|
|
{
|
|
return Uri.schemes[i].defaultPort;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Token: 0x06000BCB RID: 3019 RVA: 0x00035748 File Offset: 0x00033948
|
|
private string GetOpaqueWiseSchemeDelimiter()
|
|
{
|
|
if (this.isOpaquePart)
|
|
{
|
|
return ":";
|
|
}
|
|
return Uri.GetSchemeDelimiter(this.scheme);
|
|
}
|
|
|
|
// Token: 0x06000BCC RID: 3020 RVA: 0x00035768 File Offset: 0x00033968
|
|
protected bool IsBadFileSystemCharacter(char ch)
|
|
{
|
|
if (ch < ' ' || (ch < '@' && ch > '9'))
|
|
{
|
|
return true;
|
|
}
|
|
switch (ch)
|
|
{
|
|
case '*':
|
|
case ',':
|
|
case '/':
|
|
break;
|
|
default:
|
|
switch (ch)
|
|
{
|
|
case '\\':
|
|
case '^':
|
|
break;
|
|
default:
|
|
if (ch != '\0' && ch != '"' && ch != '&' && ch != '|')
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000BCD RID: 3021 RVA: 0x000357F0 File Offset: 0x000339F0
|
|
protected static bool IsExcludedCharacter(char ch)
|
|
{
|
|
return ch <= ' ' || ch >= '\u007f' || (ch == '"' || ch == '#' || ch == '%' || ch == '<' || ch == '>' || ch == '[' || ch == '\\' || ch == ']' || ch == '^' || ch == '`' || ch == '{' || ch == '|' || ch == '}');
|
|
}
|
|
|
|
// Token: 0x06000BCE RID: 3022 RVA: 0x0003587C File Offset: 0x00033A7C
|
|
private static bool IsPredefinedScheme(string scheme)
|
|
{
|
|
if (scheme != null)
|
|
{
|
|
if (Uri.<>f__switch$map17 == null)
|
|
{
|
|
Uri.<>f__switch$map17 = new Dictionary<string, int>(8)
|
|
{
|
|
{ "http", 0 },
|
|
{ "https", 0 },
|
|
{ "file", 0 },
|
|
{ "ftp", 0 },
|
|
{ "nntp", 0 },
|
|
{ "gopher", 0 },
|
|
{ "mailto", 0 },
|
|
{ "news", 0 }
|
|
};
|
|
}
|
|
int num;
|
|
if (Uri.<>f__switch$map17.TryGetValue(scheme, out num))
|
|
{
|
|
if (num == 0)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x06000BCF RID: 3023 RVA: 0x00035928 File Offset: 0x00033B28
|
|
protected bool IsReservedCharacter(char ch)
|
|
{
|
|
return ch == '$' || ch == '&' || ch == '+' || ch == ',' || ch == '/' || ch == ':' || ch == ';' || ch == '=' || ch == '@';
|
|
}
|
|
|
|
// Token: 0x0400031E RID: 798
|
|
private bool isUnixFilePath;
|
|
|
|
// Token: 0x0400031F RID: 799
|
|
private string source;
|
|
|
|
// Token: 0x04000320 RID: 800
|
|
private string scheme;
|
|
|
|
// Token: 0x04000321 RID: 801
|
|
private string host;
|
|
|
|
// Token: 0x04000322 RID: 802
|
|
private int port;
|
|
|
|
// Token: 0x04000323 RID: 803
|
|
private string path;
|
|
|
|
// Token: 0x04000324 RID: 804
|
|
private string query;
|
|
|
|
// Token: 0x04000325 RID: 805
|
|
private string fragment;
|
|
|
|
// Token: 0x04000326 RID: 806
|
|
private string userinfo;
|
|
|
|
// Token: 0x04000327 RID: 807
|
|
private bool isUnc;
|
|
|
|
// Token: 0x04000328 RID: 808
|
|
private bool isOpaquePart;
|
|
|
|
// Token: 0x04000329 RID: 809
|
|
private string[] segments;
|
|
|
|
// Token: 0x0400032A RID: 810
|
|
private bool userEscaped;
|
|
|
|
// Token: 0x0400032B RID: 811
|
|
private string cachedAbsoluteUri;
|
|
|
|
// Token: 0x0400032C RID: 812
|
|
private string cachedToString;
|
|
|
|
// Token: 0x0400032D RID: 813
|
|
private string cachedLocalPath;
|
|
|
|
// Token: 0x0400032E RID: 814
|
|
private int cachedHashCode;
|
|
|
|
// Token: 0x0400032F RID: 815
|
|
private bool reduce;
|
|
|
|
// Token: 0x04000330 RID: 816
|
|
private static readonly string hexUpperChars = "0123456789ABCDEF";
|
|
|
|
// Token: 0x04000331 RID: 817
|
|
public static readonly string SchemeDelimiter = "://";
|
|
|
|
// Token: 0x04000332 RID: 818
|
|
public static readonly string UriSchemeFile = "file";
|
|
|
|
// Token: 0x04000333 RID: 819
|
|
public static readonly string UriSchemeFtp = "ftp";
|
|
|
|
// Token: 0x04000334 RID: 820
|
|
public static readonly string UriSchemeGopher = "gopher";
|
|
|
|
// Token: 0x04000335 RID: 821
|
|
public static readonly string UriSchemeHttp = "http";
|
|
|
|
// Token: 0x04000336 RID: 822
|
|
public static readonly string UriSchemeHttps = "https";
|
|
|
|
// Token: 0x04000337 RID: 823
|
|
public static readonly string UriSchemeMailto = "mailto";
|
|
|
|
// Token: 0x04000338 RID: 824
|
|
public static readonly string UriSchemeNews = "news";
|
|
|
|
// Token: 0x04000339 RID: 825
|
|
public static readonly string UriSchemeNntp = "nntp";
|
|
|
|
// Token: 0x0400033A RID: 826
|
|
private static Uri.UriScheme[] schemes = new Uri.UriScheme[]
|
|
{
|
|
new Uri.UriScheme(Uri.UriSchemeHttp, Uri.SchemeDelimiter, 80),
|
|
new Uri.UriScheme(Uri.UriSchemeHttps, Uri.SchemeDelimiter, 443),
|
|
new Uri.UriScheme(Uri.UriSchemeFtp, Uri.SchemeDelimiter, 21),
|
|
new Uri.UriScheme(Uri.UriSchemeFile, Uri.SchemeDelimiter, -1),
|
|
new Uri.UriScheme(Uri.UriSchemeMailto, ":", 25),
|
|
new Uri.UriScheme(Uri.UriSchemeNews, ":", -1),
|
|
new Uri.UriScheme(Uri.UriSchemeNntp, Uri.SchemeDelimiter, 119),
|
|
new Uri.UriScheme(Uri.UriSchemeGopher, Uri.SchemeDelimiter, 70)
|
|
};
|
|
|
|
// Token: 0x020000EC RID: 236
|
|
private struct UriScheme
|
|
{
|
|
// Token: 0x06000BD0 RID: 3024 RVA: 0x00035980 File Offset: 0x00033B80
|
|
public UriScheme(string s, string d, int p)
|
|
{
|
|
this.scheme = s;
|
|
this.delimiter = d;
|
|
this.defaultPort = p;
|
|
}
|
|
|
|
// Token: 0x0400033C RID: 828
|
|
public string scheme;
|
|
|
|
// Token: 0x0400033D RID: 829
|
|
public string delimiter;
|
|
|
|
// Token: 0x0400033E RID: 830
|
|
public int defaultPort;
|
|
}
|
|
}
|
|
}
|