Initial commit of Microsoft .NET Framework reference source files
This commit adds the 4 files we need from the Microsoft .NET Framework reference source along with the license (MIT) and metadata. The source files have not been modified.
Change-Id: Ideeb869cd9ea62f10aab3785eb212544d17de9ae
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..ccdf041
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation
+
+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.
diff --git a/METADATA b/METADATA
new file mode 100644
index 0000000..c2157c4
--- /dev/null
+++ b/METADATA
@@ -0,0 +1,19 @@
+name: ".NET Framework Reference Source"
+description:
+ "Source from the Microsoft .NET Reference "
+ "Source that represent a subset of the "
+ ".NET Framework"
+
+third_party {
+ url {
+ type: HOMEPAGE
+ value: "https://referencesource.microsoft.com/"
+ }
+ url {
+ type: GIT
+ value: "https://github.com/microsoft/referencesource.git"
+ }
+ version: "4.6.2"
+ last_upgrade_date { year: 2023 month: 03 day: 29 }
+ license_type: NOTICE
+}
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..60df063
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1,12 @@
+set noparent
+
+adamws@google.com
+bcairns@google.com
+gregdenton@google.com
+hugheshilton@google.com
+ianfisk@google.com
+igorveli@google.com
+joshuta@google.com
+kellerc@google.com
+lhumphries@google.com
+tryland@google.com
\ No newline at end of file
diff --git a/System/net/System/URI.cs b/System/net/System/URI.cs
new file mode 100644
index 0000000..e264a1f
--- /dev/null
+++ b/System/net/System/URI.cs
@@ -0,0 +1,5518 @@
+//------------------------------------------------------------------------------
+// <copyright file="URI.cs" company="Microsoft">
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System {
+ using System.Runtime.InteropServices;
+ using System.Text;
+ using System.Globalization;
+ using System.Security;
+ using System.ComponentModel;
+ // Not in SL:
+ using System.Configuration;
+ using System.Security.Permissions;
+ using System.Runtime.Serialization;
+ using Microsoft.Win32;
+ using System.Threading;
+ using System.Diagnostics.CodeAnalysis;
+ using System.Net;
+ [Serializable]
+ [TypeConverter(typeof(UriTypeConverter))]
+ public partial class Uri : ISerializable {
+
+ public static readonly string UriSchemeFile = UriParser.FileUri.SchemeName;
+ public static readonly string UriSchemeFtp = UriParser.FtpUri.SchemeName;
+ public static readonly string UriSchemeGopher = UriParser.GopherUri.SchemeName;
+ public static readonly string UriSchemeHttp = UriParser.HttpUri.SchemeName;
+ public static readonly string UriSchemeHttps = UriParser.HttpsUri.SchemeName;
+ internal static readonly string UriSchemeWs = UriParser.WsUri.SchemeName;
+ internal static readonly string UriSchemeWss = UriParser.WssUri.SchemeName;
+ public static readonly string UriSchemeMailto = UriParser.MailToUri.SchemeName;
+ public static readonly string UriSchemeNews = UriParser.NewsUri.SchemeName;
+ public static readonly string UriSchemeNntp = UriParser.NntpUri.SchemeName;
+ public static readonly string UriSchemeNetTcp = UriParser.NetTcpUri.SchemeName;
+ public static readonly string UriSchemeNetPipe = UriParser.NetPipeUri.SchemeName;
+ public static readonly string SchemeDelimiter = "://";
+
+
+ private const int c_Max16BitUtf8SequenceLength = 3+3+3+3; //each unicode byte takes 3 escaped chars
+ internal const int c_MaxUriBufferSize = 0xFFF0;
+ private const int c_MaxUriSchemeName = 1024;
+
+ // untouched user string unless string has unicode chars and iriparsing is enabled
+ // or idn is on and we have unicode host or idn host
+ // In that case, this string is normalized, stripped of bidi chars, and validated
+ // with char limits
+ private string m_String;
+
+ // untouched user string if string has unicode with iri on or unicode/idn host with idn on
+ private string m_originalUnicodeString;
+
+ private UriParser m_Syntax; // This is a whole Uri syntax, not only the scheme name
+ // temporarily stores dnssafe host when we have unicode/idn host and idn is on
+ private string m_DnsSafeHost = null;
+
+ [Flags]
+ private enum Flags : ulong {
+ Zero = 0x00000000,
+
+ SchemeNotCanonical = 0x1,
+ UserNotCanonical = 0x2,
+ HostNotCanonical = 0x4,
+ PortNotCanonical = 0x8,
+ PathNotCanonical = 0x10,
+ QueryNotCanonical = 0x20,
+ FragmentNotCanonical = 0x40,
+ CannotDisplayCanonical = 0x7F,
+
+ E_UserNotCanonical = 0x80,
+ E_HostNotCanonical = 0x100,
+ E_PortNotCanonical = 0x200,
+ E_PathNotCanonical = 0x400,
+ E_QueryNotCanonical = 0x800,
+ E_FragmentNotCanonical = 0x1000,
+ E_CannotDisplayCanonical = 0x1F80,
+
+
+ ShouldBeCompressed = 0x2000,
+ FirstSlashAbsent = 0x4000,
+ BackslashInPath = 0x8000,
+
+ IndexMask = 0x0000FFFF,
+ HostTypeMask = 0x00070000,
+ HostNotParsed = 0x00000000,
+ IPv6HostType = 0x00010000,
+ IPv4HostType = 0x00020000,
+ DnsHostType = 0x00030000,
+#if !PLATFORM_UNIX
+ UncHostType = 0x00040000,
+#endif // !PLATFORM_UNIX
+ BasicHostType = 0x00050000,
+ UnusedHostType = 0x00060000,
+ UnknownHostType = 0x00070000,
+
+ UserEscaped = 0x00080000,
+ AuthorityFound = 0x00100000,
+ HasUserInfo = 0x00200000,
+ LoopbackHost = 0x00400000,
+ NotDefaultPort = 0x00800000,
+
+ UserDrivenParsing = 0x01000000,
+ CanonicalDnsHost = 0x02000000,
+ ErrorOrParsingRecursion = 0x04000000, // Used to signal a default parser error and alsoe to confirm Port
+ // and Host values in case of a custom user Parser
+#if !PLATFORM_UNIX
+ DosPath = 0x08000000,
+ UncPath = 0x10000000,
+#endif // !PLATFORM_UNIX
+ ImplicitFile = 0x20000000,
+ MinimalUriInfoSet = 0x40000000,
+ AllUriInfoSet = unchecked(0x80000000),
+ IdnHost = 0x100000000,
+ HasUnicode = 0x200000000,
+ HostUnicodeNormalized = 0x400000000,
+ RestUnicodeNormalized = 0x800000000,
+ UnicodeHost = 0x1000000000,
+ IntranetUri = 0x2000000000,
+ UseOrigUncdStrOffset= 0x4000000000,
+ // Is this component Iri canonical
+ UserIriCanonical = 0x8000000000,
+ PathIriCanonical = 0x10000000000,
+ QueryIriCanonical = 0x20000000000,
+ FragmentIriCanonical = 0x40000000000,
+ IriCanonical = 0x78000000000,
+ }
+
+ private Flags m_Flags;
+ private UriInfo m_Info;
+
+ private class UriInfo {
+ public string Host;
+ public string ScopeId; //only IP v6 may need this
+ public string String;
+ public Offset Offset;
+ public string DnsSafeHost; // stores dns safe host when idn is on and we have unicode or idn host
+ public MoreInfo MoreInfo; // Multi-threading: This field must be always accessed through a _local_
+ // stack copy of m_Info.
+ };
+
+ [StructLayout(LayoutKind.Sequential, Pack=1)]
+ private struct Offset {
+ public ushort Scheme;
+ public ushort User;
+ public ushort Host;
+ public ushort PortValue;
+ public ushort Path;
+ public ushort Query;
+ public ushort Fragment;
+ public ushort End;
+ };
+
+ private class MoreInfo {
+ public string Path;
+ public string Query;
+ public string Fragment;
+ public string AbsoluteUri;
+ public int Hash;
+ public string RemoteUrl;
+ };
+
+ private bool IsImplicitFile {
+ get {return (m_Flags & Flags.ImplicitFile) != 0;}
+ }
+
+ private bool IsUncOrDosPath {
+#if !PLATFORM_UNIX
+ get {return (m_Flags & (Flags.UncPath|Flags.DosPath)) != 0;}
+#else
+ get {return false;}
+#endif // !PLATFORM_UNIX
+ }
+
+ private bool IsDosPath {
+#if !PLATFORM_UNIX
+ get {return (m_Flags & Flags.DosPath) != 0;}
+#else
+ get {return false;}
+#endif // !PLATFORM_UNIX
+ }
+
+ private bool IsUncPath {
+#if !PLATFORM_UNIX
+ get {return (m_Flags & Flags.UncPath) != 0;}
+#else
+ get {return false;}
+#endif // !PLATFORM_UNIX
+ }
+
+ private Flags HostType {
+ get {return m_Flags & Flags.HostTypeMask;}
+ }
+
+ private UriParser Syntax {
+ get {
+ return m_Syntax;
+ }
+ }
+
+ private bool IsNotAbsoluteUri {
+ get {return (object) m_Syntax == null;}
+ }
+
+ //
+ // Checks if Iri parsing is allowed by the syntax & by config
+ //
+ private bool m_iriParsing;
+
+ //
+ // Statically checks if Iri parsing is allowed by the syntax & by config
+ //
+ internal static bool IriParsingStatic( UriParser syntax )
+ {
+ return (s_IriParsing && (((syntax != null) && syntax.InFact(UriSyntaxFlags.AllowIriParsing)) ||
+ (syntax == null)));
+ }
+
+ //
+ // Checks if Idn is allowed by the syntax & by config
+ //
+ private bool AllowIdn
+ {
+ get { return ((m_Syntax != null) && ((m_Syntax.Flags & UriSyntaxFlags.AllowIdn) != 0) &&
+ ((s_IdnScope == UriIdnScope.All) || ((s_IdnScope == UriIdnScope.AllExceptIntranet)
+ && NotAny(Flags.IntranetUri)))); }
+ }
+
+ //
+ // Checks statically if Idn is allowed by the syntax & by config
+ //
+ private bool AllowIdnStatic(UriParser syntax, Flags flags)
+ {
+ return ((syntax != null) && ((syntax.Flags & UriSyntaxFlags.AllowIdn) != 0) &&
+ ((s_IdnScope == UriIdnScope.All) || ((s_IdnScope == UriIdnScope.AllExceptIntranet)
+ && StaticNotAny(flags, Flags.IntranetUri))));
+ }
+
+ //
+ // check if the scheme + host are in intranet or not
+ // Used to determine of we apply idn or not
+ //
+ private static volatile IInternetSecurityManager s_ManagerRef = null;
+ private static object s_IntranetLock = new object();
+
+ private bool IsIntranet(string schemeHost)
+ {
+ bool error = false;
+ int zone = -1;
+ int E_FAIL = unchecked((int)0x80004005);
+
+ // MapUrlToZone call below fails on scheme length > 32 so we consider this
+ // not be be intranet
+ //
+ if (m_Syntax.SchemeName.Length > 32)
+ return false;
+
+ if (s_ManagerRef == null){
+ lock (s_IntranetLock){
+ if(s_ManagerRef == null)
+ {
+#if !FEATURE_PAL
+ // Go through CoCreateInstance as creating arbitary COM object is no longer supported in AppX scenario
+ Guid clsid = typeof(InternetSecurityManager).GUID;
+ Guid iid = typeof(IInternetSecurityManager).GUID;
+
+ object managerRef;
+ UnsafeNclNativeMethods.CoCreateInstance(
+ ref clsid ,
+ IntPtr.Zero,
+ UnsafeNclNativeMethods.CLSCTX_SERVER,
+ ref iid,
+ out managerRef
+ );
+ s_ManagerRef = managerRef as IInternetSecurityManager;
+#else
+ s_ManagerRef = (IInternetSecurityManager)new InternetSecurityManager();
+#endif // !FEATURE_PAL
+ }
+ }
+ }
+
+ try{
+ s_ManagerRef.MapUrlToZone(schemeHost.TrimStart(_WSchars), out zone, 0);
+ }
+ catch (COMException ex){
+ if (ex.ErrorCode == E_FAIL){ // E_FAIL
+ error = true;
+ }
+ }
+ // If s_ManagerRef was initilized on an STA thread then it cannot be accessed from other threads.
+ // Visual Studio Unit Tests are the primary scenario for this.
+ catch (InvalidComObjectException) {
+ error = true;
+ }
+
+ if(zone == (int) SecurityZone.Intranet)
+ return true;
+
+ // Do dot check for intranet if zone is trusted or untrusted
+ // since an intranet zone may be in these zones as well
+ if ((zone == (int)SecurityZone.Trusted) ||
+ (zone == (int)SecurityZone.Untrusted) || error)
+ {
+ // do dot check
+ for (int i = 0; i < schemeHost.Length; ++i)
+ {
+ if (schemeHost[i] == '.')
+ return false;
+ }
+ return true;
+ }
+ return false;
+ }
+
+ internal bool UserDrivenParsing
+ {
+ get {
+ return (m_Flags & Flags.UserDrivenParsing) != 0;
+ }
+ }
+ private void SetUserDrivenParsing()
+ {
+ // we use = here to clear all parsing flags for a uri that we think is invalid.
+ m_Flags = Flags.UserDrivenParsing | (m_Flags & Flags.UserEscaped);
+ }
+
+ private ushort SecuredPathIndex {
+ get {
+ // This is one more trouble with a Dos Path.
+ // This property gets "safe" first path slash that is not the first if path = c:\
+ if (IsDosPath) {
+ char ch = m_String[m_Info.Offset.Path];
+ return (ushort)((ch == '/' || ch == '\\')? 3 :2);
+ }
+ return (ushort)0;
+ }
+ }
+
+ private bool NotAny(Flags flags) {
+ return (m_Flags & flags) == 0;
+ }
+
+ private bool InFact(Flags flags) {
+ return (m_Flags & flags) != 0;
+ }
+
+ private static bool StaticNotAny(Flags allFlags, Flags checkFlags) {
+ return (allFlags & checkFlags) == 0;
+ }
+
+ private static bool StaticInFact(Flags allFlags, Flags checkFlags) {
+ return (allFlags & checkFlags) != 0;
+ }
+
+ //
+ //
+ private UriInfo EnsureUriInfo() {
+ Flags cF = m_Flags;
+ if ((m_Flags & Flags.MinimalUriInfoSet) == 0) {
+ CreateUriInfo(cF);
+ }
+ return m_Info;
+ }
+ //
+ //
+ private void EnsureParseRemaining() {
+ if ((m_Flags & Flags.AllUriInfoSet) == 0) {
+ ParseRemaining();
+ }
+ }
+ //
+ //
+ private void EnsureHostString(bool allowDnsOptimization) {
+ EnsureUriInfo();
+ if ((object)m_Info.Host == null) {
+ if (allowDnsOptimization && InFact(Flags.CanonicalDnsHost)) {
+ /* Optimization for a canonical DNS name
+ * ATTN: the host string won't be created,
+ * Hence ALL m_Info.Host callers first call EnsureHostString(false)
+ * For example IsLoopBack property is one of such callers.
+ */
+ return;
+ }
+ CreateHostString();
+ }
+ }
+
+ //
+ // Uri(string)
+ //
+ // We expect to create a Uri from a display name - e.g. that was typed by
+ // a user, or that was copied & pasted from a document. That is, we do not
+ // expect already encoded URI to be supplied.
+ //
+ public Uri(string uriString){
+ if ((object)uriString == null)
+ throw new ArgumentNullException("uriString");
+
+ CreateThis(uriString, false, UriKind.Absolute);
+ }
+
+
+ //
+ // Uri(string, bool)
+ //
+ // Uri constructor. Assumes that input string is canonically escaped
+ //
+ [Obsolete("The constructor has been deprecated. Please use new Uri(string). The dontEscape parameter is deprecated and is always false. http://go.microsoft.com/fwlink/?linkid=14202")]
+ public Uri(string uriString, bool dontEscape) {
+ if ((object)uriString == null)
+ throw new ArgumentNullException("uriString");
+
+ CreateThis(uriString, dontEscape, UriKind.Absolute);
+ }
+
+ //
+ // Uri(Uri, string, bool)
+ //
+ // Uri combinatorial constructor. Do not perform character escaping if
+ // DontEscape is true
+ //
+ [Obsolete("The constructor has been deprecated. Please new Uri(Uri, string). The dontEscape parameter is deprecated and is always false. http://go.microsoft.com/fwlink/?linkid=14202")]
+ public Uri(Uri baseUri, string relativeUri, bool dontEscape){
+ if ((object)baseUri == null)
+ throw new ArgumentNullException("baseUri");
+
+ if (!baseUri.IsAbsoluteUri)
+ throw new ArgumentOutOfRangeException("baseUri");
+
+ CreateUri(baseUri, relativeUri, dontEscape);
+ }
+
+ //
+ // Uri(string, UriKind);
+ //
+ public Uri(string uriString, UriKind uriKind)
+ {
+ if ((object)uriString == null)
+ throw new ArgumentNullException("uriString");
+
+ CreateThis(uriString, false, uriKind);
+ }
+
+
+ //
+ // Uri(Uri, string)
+ //
+ // Construct a new Uri from a base and relative URI. The relative URI may
+ // also be an absolute URI, in which case the resultant URI is constructed
+ // entirely from it
+ //
+ public Uri(Uri baseUri, string relativeUri){
+ if ((object)baseUri == null)
+ throw new ArgumentNullException("baseUri");
+
+ if (!baseUri.IsAbsoluteUri)
+ throw new ArgumentOutOfRangeException("baseUri");
+
+ CreateUri(baseUri, relativeUri, false);
+ }
+
+ private void CreateUri(Uri baseUri, string relativeUri, bool dontEscape)
+ {
+ // Parse relativeUri and populate Uri internal data.
+ CreateThis(relativeUri, dontEscape, UriKind.RelativeOrAbsolute);
+
+ UriFormatException e;
+ if (baseUri.Syntax.IsSimple)
+ {
+ // Resolve Uris if possible OR get merged Uri String to re-parse below
+ Uri uriResult = ResolveHelper(baseUri, this, ref relativeUri, ref dontEscape, out e);
+
+ if (e != null)
+ throw e;
+
+ // If resolved into a Uri then we build from that Uri
+ if (uriResult != null)
+ {
+ if ((object)uriResult != (object)this)
+ CreateThisFromUri(uriResult);
+
+ return;
+ }
+ }
+ else
+ {
+ dontEscape = false;
+ relativeUri = baseUri.Syntax.InternalResolve(baseUri, this, out e);
+ if (e != null)
+ throw e;
+ }
+
+ m_Flags = Flags.Zero;
+ m_Info = null;
+ m_Syntax = null;
+ // If not resolved, we reparse modified Uri string and populate Uri internal data.
+ CreateThis(relativeUri, dontEscape, UriKind.Absolute);
+ }
+
+ //
+ // Uri(Uri , Uri )
+ // Note: a static Create() method should be used by users, not this .ctor
+ //
+ public Uri(Uri baseUri, Uri relativeUri)
+ {
+ if ((object)baseUri == null)
+ throw new ArgumentNullException("baseUri");
+
+ if (!baseUri.IsAbsoluteUri)
+ throw new ArgumentOutOfRangeException("baseUri");
+
+ CreateThisFromUri(relativeUri);
+
+ string newUriString = null;
+ UriFormatException e;
+ bool dontEscape;
+
+ if (baseUri.Syntax.IsSimple)
+ {
+ dontEscape = InFact(Flags.UserEscaped);
+ relativeUri = ResolveHelper(baseUri, this, ref newUriString, ref dontEscape, out e);
+
+ if (e != null)
+ throw e;
+
+ if (relativeUri != null)
+ {
+ if ((object)relativeUri != (object)this)
+ CreateThisFromUri(relativeUri);
+
+ return;
+ }
+ }
+ else
+ {
+ dontEscape = false;
+ newUriString = baseUri.Syntax.InternalResolve(baseUri, this, out e);
+ if (e != null)
+ throw e;
+ }
+
+ m_Flags = Flags.Zero;
+ m_Info = null;
+ m_Syntax = null;
+ CreateThis(newUriString, dontEscape, UriKind.Absolute);
+ }
+
+ //
+ // This method is shared by base+relative Uris constructors and is only called from them.
+ // The assumptions:
+ // - baseUri is a valid absolute Uri
+ // - relative part is not null and not empty
+ private unsafe static ParsingError GetCombinedString(Uri baseUri, string relativeStr,
+ bool dontEscape, ref string result)
+ {
+ // NB: This is not RFC2396 compliant although it is inline with w3c.org recommendations
+ // This parser will allow the relativeStr to be an absolute Uri with the different scheme
+ // In fact this is strict violation of RFC2396
+ //
+ for (int i=0; i < relativeStr.Length; ++i)
+ {
+ if (relativeStr[i] == '/' || relativeStr[i] == '\\' || relativeStr[i] == '?' || relativeStr[i] == '#')
+ {
+ break;
+ }
+ else if (relativeStr[i] == ':')
+ {
+ if (i < 2)
+ {
+ // Note we don't support one-letter Uri schemes.
+ // Hence anything like x:sdsd is a relative path and be added to the baseUri Path
+ break;
+ }
+ string scheme = relativeStr.Substring(0, i);
+ fixed (char* sptr = scheme) {
+ UriParser syntax = null;
+ if (CheckSchemeSyntax(sptr, (ushort) scheme.Length, ref syntax) == ParsingError.None) {
+ if (baseUri.Syntax == syntax) {
+ //Remove the scheme for backward Uri parsers compatibility
+ if (i+1 < relativeStr.Length) {
+ relativeStr = relativeStr.Substring(i+1);
+ }
+ else {
+ relativeStr = string.Empty;
+ }
+ }
+ else {
+ // This is the place where we switch the scheme.
+ // Return relative part as the result Uri.
+ result = relativeStr;
+ return ParsingError.None;
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ if (relativeStr.Length == 0) {
+ result = baseUri.OriginalString;
+ return ParsingError.None;
+ }
+
+ result = CombineUri(baseUri, relativeStr, dontEscape? UriFormat.UriEscaped: UriFormat.SafeUnescaped);
+ return ParsingError.None;
+ }
+ //
+ private static UriFormatException GetException(ParsingError err)
+ {
+ switch (err)
+ {
+ case ParsingError.None:
+ return null;
+ // Could be OK for Relative Uri
+ case ParsingError.BadFormat:
+ return new UriFormatException(SR.GetString(SR.net_uri_BadFormat));
+ case ParsingError.BadScheme:
+ return new UriFormatException(SR.GetString(SR.net_uri_BadScheme));
+ case ParsingError.BadAuthority:
+ return new UriFormatException(SR.GetString(SR.net_uri_BadAuthority));
+ case ParsingError.EmptyUriString:
+ return new UriFormatException(SR.GetString(SR.net_uri_EmptyUri));
+ // Fatal
+ case ParsingError.SchemeLimit:
+ return new UriFormatException(SR.GetString(SR.net_uri_SchemeLimit));
+ case ParsingError.SizeLimit:
+ return new UriFormatException(SR.GetString(SR.net_uri_SizeLimit));
+ case ParsingError.MustRootedPath:
+ return new UriFormatException(SR.GetString(SR.net_uri_MustRootedPath));
+ // Derived class controllable
+ case ParsingError.BadHostName:
+ return new UriFormatException(SR.GetString(SR.net_uri_BadHostName));
+ case ParsingError.NonEmptyHost: //unix-only
+ return new UriFormatException(SR.GetString(SR.net_uri_BadFormat));
+ case ParsingError.BadPort:
+ return new UriFormatException(SR.GetString(SR.net_uri_BadPort));
+ case ParsingError.BadAuthorityTerminator:
+ return new UriFormatException(SR.GetString(SR.net_uri_BadAuthorityTerminator));
+ case ParsingError.CannotCreateRelative:
+ return new UriFormatException(SR.GetString(SR.net_uri_CannotCreateRelative));
+ default:
+ break;
+ }
+ return new UriFormatException(SR.GetString(SR.net_uri_BadFormat));
+ }
+
+ #region !Silverlight
+
+ //
+ // ISerializable constructor
+ //
+ protected Uri(SerializationInfo serializationInfo, StreamingContext streamingContext)
+ {
+ string uriString = serializationInfo.GetString("AbsoluteUri");
+
+ if (uriString.Length != 0)
+ {
+ CreateThis(uriString, false, UriKind.Absolute);
+ return;
+ }
+
+ uriString = serializationInfo.GetString("RelativeUri");
+ if ((object)uriString == null)
+ throw new ArgumentNullException("uriString");
+
+ CreateThis(uriString, false, UriKind.Relative);
+ }
+
+ //
+ // ISerializable method
+ //
+ /// <internalonly/>
+ [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase", Justification = "System.dll is still using pre-v4 security model and needs this demand")]
+ [SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter=true)]
+ void ISerializable.GetObjectData(SerializationInfo serializationInfo, StreamingContext streamingContext)
+ {
+ GetObjectData(serializationInfo, streamingContext);
+ }
+
+ //
+ // FxCop: provide some way for derived classes to access GetObjectData even if the derived class
+ // explicitly re-inherits ISerializable.
+ //
+ [SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter=true)]
+ protected void GetObjectData(SerializationInfo serializationInfo, StreamingContext streamingContext)
+ {
+
+ if (IsAbsoluteUri)
+ serializationInfo.AddValue("AbsoluteUri", GetParts(UriComponents.SerializationInfoString, UriFormat.UriEscaped));
+ else
+ {
+ serializationInfo.AddValue("AbsoluteUri", string.Empty);
+ serializationInfo.AddValue("RelativeUri", GetParts(UriComponents.SerializationInfoString, UriFormat.UriEscaped));
+ }
+ }
+
+ #endregion !Silverlight
+
+ //
+ //
+ //
+ public string AbsolutePath {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ string path = PrivateAbsolutePath;
+ //
+ //
+
+
+ if (IsDosPath && path[0] == '/') {
+ path = path.Substring(1);
+ }
+ return path;
+ }
+ }
+ //
+ private string PrivateAbsolutePath {
+ get {
+ UriInfo info = EnsureUriInfo();
+ if ((object) info.MoreInfo == null) {
+ info.MoreInfo = new MoreInfo();
+ }
+ string result = info.MoreInfo.Path;
+ if ((object) result == null) {
+ result = GetParts(UriComponents.Path | UriComponents.KeepDelimiter, UriFormat.UriEscaped);
+ info.MoreInfo.Path = result;
+ }
+ return result;
+ }
+ }
+
+ //
+ //
+ //
+ public string AbsoluteUri {
+ get {
+ if (m_Syntax == null){
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ UriInfo info = EnsureUriInfo();
+ if ((object) info.MoreInfo == null) {
+ info.MoreInfo = new MoreInfo();
+ }
+ string result = info.MoreInfo.AbsoluteUri;
+ if ((object) result == null) {
+ result = GetParts(UriComponents.AbsoluteUri, UriFormat.UriEscaped);
+ info.MoreInfo.AbsoluteUri = result;
+ }
+ return result;
+ }
+ }
+
+ //
+ // LocalPath
+ //
+ // Returns a 'local' version of the path. This is mainly for file: URI
+ // such that DOS and UNC paths are returned with '/' converted back to
+ // '\', and any escape sequences converted
+ //
+ // The form of the returned path is in NOT Escaped
+ //
+ public string LocalPath {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+ return GetLocalPath();
+ }
+ }
+
+ #region !Silverlight
+ //
+ //
+ // The result is of the form "hostname[:port]" Port is omitted if default
+ //
+ public string Authority {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ //
+ return GetParts(UriComponents.Host | UriComponents.Port, UriFormat.UriEscaped);
+ }
+ }
+ //
+ //
+ public UriHostNameType HostNameType {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ if (m_Syntax.IsSimple)
+ EnsureUriInfo();
+ else
+ {
+ // For a custom parser we request HostString creation to confirm HostType
+ EnsureHostString(false);
+ }
+
+ switch (HostType) {
+ case Flags.DnsHostType: return UriHostNameType.Dns;
+ case Flags.IPv4HostType: return UriHostNameType.IPv4;
+ case Flags.IPv6HostType: return UriHostNameType.IPv6;
+ case Flags.BasicHostType: return UriHostNameType.Basic;
+#if !PLATFORM_UNIX
+ case Flags.UncHostType: return UriHostNameType.Basic; //return (UriHostNameType)(UriHostNameType.Basic+10);
+#endif // !PLATFORM_UNIX
+ case Flags.UnknownHostType: return UriHostNameType.Unknown;
+ default:
+ break;
+ }
+ return UriHostNameType.Unknown;
+ }
+ }
+ //
+ //
+ public bool IsDefaultPort {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+ if (m_Syntax.IsSimple)
+ EnsureUriInfo();
+ else
+ {
+ // For a custom parser we request HostString creation that will aso set the port
+ EnsureHostString(false);
+ }
+
+ return NotAny(Flags.NotDefaultPort);
+ }
+ }
+ //
+ //
+ public bool IsFile {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ return (object)m_Syntax.SchemeName == (object)UriSchemeFile;
+ }
+ }
+ //
+ //
+ public bool IsLoopback {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ EnsureHostString(false);
+
+ return InFact(Flags.LoopbackHost);
+ }
+ }
+
+ //
+ //
+ // Gets the escaped Uri.AbsolutePath and Uri.Query
+ // properties separated by a "?" character.
+ public string PathAndQuery {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ string result = GetParts(UriComponents.PathAndQuery, UriFormat.UriEscaped);
+ //
+ //
+
+
+ if (IsDosPath && result[0] == '/') {
+ result = result.Substring(1);
+ }
+ return result;
+ }
+ }
+
+ //
+ //
+ // Gets an array of the segments that make up a URI.
+ public string[] Segments {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ string[] segments = null; // used to be a class cached result
+ if (segments == null) {
+
+ string path = PrivateAbsolutePath;
+
+ if (path.Length == 0) {
+ segments = new string[0];
+ }
+ else {
+ System.Collections.ArrayList pathSegments = new System.Collections.ArrayList();
+ int current = 0;
+ while (current < path.Length) {
+ int next = path.IndexOf('/', current);
+ if (next == -1) {
+ next = path.Length - 1;
+ }
+ pathSegments.Add(path.Substring(current, (next - current) + 1));
+ current = next + 1;
+ }
+ segments = (string[])(pathSegments.ToArray(typeof(string)));
+ }
+ }
+ return segments;
+ }
+ }
+
+ #endregion !Silverlight
+
+ //
+ //
+ public bool IsUnc {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+ return IsUncPath;
+ }
+ }
+
+ //
+ // Gets a hostname part (special formatting for IPv6 form)
+ public string Host {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ return GetParts(UriComponents.Host, UriFormat.UriEscaped);
+ }
+ }
+
+ private static bool StaticIsFile(UriParser syntax)
+ {
+ return syntax.InFact(UriSyntaxFlags.FileLikeUri);
+ }
+
+ private static volatile bool s_ConfigInitialized; // Have the config values been initalized from config file
+ private static volatile bool s_ConfigInitializing; // used for recursion detection while init. config values
+
+ // Value from config Uri section
+ // The use of this IDN mechanic is discouraged on Win8+ due to native platform improvements.
+ private static volatile UriIdnScope s_IdnScope = IdnElement.EnabledDefaultValue;
+
+ // Value from config Uri section
+ // On by default in .NET 4.5+ and cannot be disabled by config.
+ private static volatile bool s_IriParsing =
+ (UriParser.ShouldUseLegacyV2Quirks ? IriParsingElement.EnabledDefaultValue : true);
+
+ private static object s_initLock;
+
+ private static object InitializeLock {
+ get {
+ if (s_initLock == null) {
+ object o = new object();
+ Interlocked.CompareExchange(ref s_initLock, o, null);
+ }
+ return s_initLock;
+ }
+ }
+
+ //
+ // Reads values from config uri section
+ //
+ // This method is called if:
+ // - a Uri is constructed, we parse the string and we find '%', >127 chars, or 'xn--'
+ // - we parse the host and figure out if it is an IPv6 address
+ private static void InitializeUriConfig()
+ {
+ if (!s_ConfigInitialized) {
+ lock(InitializeLock) {
+ if (!s_ConfigInitialized && !s_ConfigInitializing) {
+
+ // setting s_ConfigInitializing to true makes sure, that in web scenarios,
+ // where Uri instances may be created while parsing the web.config files, will not
+ // call into this code block again. We'll enter the following code only once per
+ // AppDomain.
+ s_ConfigInitializing = true;
+ UriSectionInternal section = UriSectionInternal.GetSection();
+
+ if (section != null) {
+ s_IdnScope = section.IdnScope;
+ // Iri can no longer be altered by the config, it is always on.
+ if (UriParser.ShouldUseLegacyV2Quirks) {
+ s_IriParsing = section.IriParsing;
+ }
+
+ SetEscapedDotSlashSettings(section, "http");
+ SetEscapedDotSlashSettings(section, "https");
+ SetEscapedDotSlashSettings(section, Uri.UriSchemeWs);
+ SetEscapedDotSlashSettings(section, Uri.UriSchemeWss);
+ }
+
+ s_ConfigInitialized = true;
+ s_ConfigInitializing = false;
+ }
+ }
+ }
+ }
+
+ // Legacy - This no longer has any affect in .NET 4.5 (non-quirks). See UriParser.HttpSyntaxFlags.
+ private static void SetEscapedDotSlashSettings(UriSectionInternal uriSection, string scheme)
+ {
+ // Currently we only support setting DontUnescapePathDotsAndSlashes for HTTP and HTTPS schemes.
+ // We ignore all other values. We won't throw for two reasons:
+ // - backward compatibility: Uri didn't throw so far.
+ // - the config section gets only read if we actually find e.g. a %-character in the Uri. If not, this
+ // code never gets executed, resulting in a weird behavior for the customer: If one application run
+ // doesn't use Uris with %-characters, it doesn't throw, if another run uses %-characters it throws.
+ // => If we want to throw we have to rethink the current implementation.
+ SchemeSettingInternal schemeSetting = uriSection.GetSchemeSetting(scheme);
+ if (schemeSetting != null) {
+ // We check for equality, not if Options contains DontUnescapePathDotsAndSlashes:
+ // Currently we only support this flag. If more than this flag are set, then it is an invalid
+ // setting and we ignore it.
+ if (schemeSetting.Options == GenericUriParserOptions.DontUnescapePathDotsAndSlashes) {
+ UriParser parser = UriParser.GetSyntax(scheme);
+ parser.SetUpdatableFlags(UriSyntaxFlags.None);
+ }
+ }
+ }
+
+ private string GetLocalPath(){
+ EnsureParseRemaining();
+
+ //Other cases will get a Unix-style path
+ if (IsUncOrDosPath)
+ {
+ EnsureHostString(false);
+ int start;
+
+ // Do we have a valid local path right in m_string?
+ if (NotAny(Flags.HostNotCanonical|Flags.PathNotCanonical|Flags.ShouldBeCompressed)) {
+
+ start = IsUncPath? m_Info.Offset.Host-2 :m_Info.Offset.Path;
+
+ string str = (IsImplicitFile && m_Info.Offset.Host == (IsDosPath ? 0 : 2) &&
+ m_Info.Offset.Query == m_Info.Offset.End)
+ ? m_String
+ : (IsDosPath && (m_String[start] == '/' || m_String[start] == '\\'))
+ ? m_String.Substring(start + 1, m_Info.Offset.Query - start - 1)
+ : m_String.Substring(start, m_Info.Offset.Query - start);
+
+ // Should be a rare case, convert c|\ into c:\
+ if (IsDosPath && str[1] == '|') {
+ // Sadly, today there is no method for replacong just one occurrence
+ str = str.Remove(1, 1);
+ str = str.Insert(1, ":");
+ }
+
+ // check for all back slashes (though may be string.Replace is smart?)
+ for (int i = 0; i < str.Length; ++i) {
+ if (str[i] == '/') {
+ str = str.Replace('/', '\\');
+ break;
+ }
+ }
+
+ return str;
+ }
+
+ // Not everything went well, trying harder
+
+ char[] result;
+ int count = 0;
+ start = m_Info.Offset.Path;
+
+ string host = m_Info.Host;
+ result = new char [host.Length + 3 + m_Info.Offset.Fragment - m_Info.Offset.Path ];
+
+ if (IsUncPath)
+ {
+ result[0] = '\\';
+ result[1] = '\\';
+ count = 2;
+
+ UriHelper.UnescapeString(host, 0, host.Length, result, ref count, c_DummyChar, c_DummyChar,
+ c_DummyChar, UnescapeMode.CopyOnly, m_Syntax, false);
+
+ }
+ else {
+ // Dos path
+ if(m_String[start] == '/' || m_String[start] == '\\') {
+ // Skip leading slash for a DOS path
+ ++start;
+ }
+ }
+
+
+ ushort pathStart = (ushort)count; //save for optional Compress() call
+
+ UnescapeMode mode = (InFact(Flags.PathNotCanonical) && !IsImplicitFile)
+ ? (UnescapeMode.Unescape | UnescapeMode.UnescapeAll): UnescapeMode.CopyOnly;
+ UriHelper.UnescapeString(m_String, start, m_Info.Offset.Query, result, ref count, c_DummyChar,
+ c_DummyChar, c_DummyChar, mode, m_Syntax, true);
+
+ // Possibly convert c|\ into c:\
+ if (result[1] == '|')
+ result[1] = ':';
+
+ if (InFact(Flags.ShouldBeCompressed)) {
+ // suspecting not compressed path
+ // For a dos path we won't compress the "x:" part if found /../ sequences
+ result = Compress(result, (ushort)(IsDosPath? pathStart + 2: pathStart), ref count, m_Syntax);
+ }
+
+ // We don't know whether all slashes were the back ones
+ // Plus going through Compress will turn them into / anyway
+ // Converting / back into \
+ for (ushort i = 0; i < (ushort) count; ++i) {
+ if (result[i] == '/') {
+ result[i] = '\\';
+ }
+ }
+
+ return new string(result, 0, count);
+
+ }
+ else {
+ // Return unescaped canonical path
+ // Note we cannot call GetParts here because it has circular dependancy on GelLocalPath method
+ return GetUnescapedParts(UriComponents.Path | UriComponents.KeepDelimiter, UriFormat.Unescaped);
+ }
+ }
+
+ //
+ //
+ //
+ //
+ public int Port {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ if (m_Syntax.IsSimple)
+ EnsureUriInfo();
+ else
+ {
+ // For a custom parser we request HostString creation that will aso set the port
+ EnsureHostString(false);
+ }
+
+ if (InFact(Flags.NotDefaultPort)) {
+ return (int)m_Info.Offset.PortValue;
+ }
+ return m_Syntax.DefaultPort;
+ }
+ }
+ //
+ //
+ //
+ // Gets the escaped query.
+ public string Query {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ UriInfo info = EnsureUriInfo();
+ if ((object)info.MoreInfo == null) {
+ info.MoreInfo = new MoreInfo();
+ }
+ string result = info.MoreInfo.Query;
+ if ((object)result == null) {
+ result = GetParts(UriComponents.Query | UriComponents.KeepDelimiter, UriFormat.UriEscaped);
+ info.MoreInfo.Query = result;
+ }
+ return result;
+ }
+ }
+ //
+ //
+ //
+ // Gets the escaped fragment.
+ public string Fragment {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ UriInfo info = EnsureUriInfo();
+ if ((object)info.MoreInfo == null) {
+ info.MoreInfo = new MoreInfo();
+ }
+ string result = info.MoreInfo.Fragment;
+ if ((object)result == null) {
+ result = GetParts(UriComponents.Fragment | UriComponents.KeepDelimiter, UriFormat.UriEscaped);
+ info.MoreInfo.Fragment = result;
+ }
+ return result;
+ }
+ }
+
+ //
+ // Gets the Scheme string of this Uri
+ //
+ //
+ public string Scheme {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ return m_Syntax.SchemeName;
+ }
+ }
+
+ //
+ // Was the original string switched from m_String to m_OriginalUnicodeString
+ // Will happen when Iri is turned on and we have unicode chars or of idn is
+ // is on and we have an idn or unicode host.
+ //
+ private bool OriginalStringSwitched
+ {
+ get{return ((m_iriParsing && InFact(Flags.HasUnicode)) ||
+ (AllowIdn && (InFact(Flags.IdnHost) || InFact(Flags.UnicodeHost))));}
+ }
+ //
+ // Gets the exact string passed by a user.
+ public String OriginalString {
+ get {
+ return OriginalStringSwitched ? m_originalUnicodeString : m_String;
+ }
+ }
+
+ //
+ // Gets the host string that is unescaped and if it's Ipv6 host,
+ // then the returned string is suitable for DNS lookup.
+ //
+ // For Ipv6 this will strip [] and add ScopeId if was found in the original string
+ public string DnsSafeHost {
+ get {
+
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ if (AllowIdn && (((m_Flags & Flags.IdnHost) != 0) || ((m_Flags & Flags.UnicodeHost) != 0))){
+ // return pre generated idn
+ EnsureUriInfo();
+ return m_Info.DnsSafeHost;
+ }
+
+ EnsureHostString(false);
+
+ if (!String.IsNullOrEmpty(m_Info.DnsSafeHost)) {
+ // Cached
+ return m_Info.DnsSafeHost;
+ } else if (m_Info.Host.Length == 0) {
+ // Empty host, no possible processing
+ return String.Empty;
+ }
+
+ // Special case, will include ScopeID and strip [] around IPv6
+ // This will also unescape the host string
+ string ret = m_Info.Host;
+
+ if (HostType == Flags.IPv6HostType) {
+ ret = ret.Substring(1, ret.Length - 2);
+ if ((object)m_Info.ScopeId != null) {
+ ret += m_Info.ScopeId;
+ }
+ }
+ // Validate that this basic host qualifies as Dns safe,
+ // It has looser parsing rules that might allow otherwise.
+ // It might be a registry-based host from RFC 2396 Section 3.2.1
+ else if (HostType == Flags.BasicHostType
+ && InFact(Flags.HostNotCanonical | Flags.E_HostNotCanonical)) {
+ // Unescape everything
+ char[] dest = new char[ret.Length];
+ int count = 0;
+ UriHelper.UnescapeString(ret, 0, ret.Length, dest, ref count, c_DummyChar, c_DummyChar,
+ c_DummyChar, UnescapeMode.Unescape | UnescapeMode.UnescapeAll, m_Syntax, false);
+ ret = new string(dest, 0, count);
+ }
+
+ m_Info.DnsSafeHost = ret;
+
+ return ret;
+ }
+ }
+
+ // Returns the host name represented as IDN (using punycode encoding) regardless of app.config settings
+ public string IdnHost {
+ get {
+ string host = this.DnsSafeHost;
+
+ if (HostType == Flags.DnsHostType) {
+ host = DomainNameHelper.IdnEquivalent(host);
+ }
+
+ return host;
+ }
+ }
+
+ //
+ // Returns false if the string passed in the constructor cannot be parsed as
+ // valid AbsoluteUri. This could be a relative Uri instead.
+ //
+ public bool IsAbsoluteUri {
+ get {
+ return m_Syntax != null;
+ }
+ }
+ //
+ //
+ // Returns 'true' if the 'dontEscape' parameter was set to 'true ' when the Uri instance was created.
+ public bool UserEscaped {
+ get {
+ return InFact(Flags.UserEscaped);
+ }
+ }
+ //
+ //
+ // Gets the user name, password, and other user specific information associated
+ // with the Uniform Resource Identifier (URI).
+ public string UserInfo {
+ get {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ return GetParts(UriComponents.UserInfo, UriFormat.UriEscaped);
+ }
+ }
+
+ #region !Silverlight
+
+ //
+ // CheckHostName
+ //
+ // Determines whether a host name authority is a valid Host name according
+ // to DNS naming rules and IPv4 canonicalization rules
+ //
+ // Returns:
+ // true if <name> is valid else false
+ //
+ // Throws:
+ // Nothing
+ //
+ public static UriHostNameType CheckHostName(string name) {
+
+ if ((object)name == null || name.Length == 0 || name.Length > short.MaxValue) {
+ return UriHostNameType.Unknown;
+ }
+ int end = name.Length;
+ unsafe {
+ fixed (char* fixedName = name) {
+
+ if (name[0] == '[' && name[name.Length-1] == ']') {
+ // we require that _entire_ name is recognized as ipv6 address
+ if (IPv6AddressHelper.IsValid(fixedName, 1, ref end) && end == name.Length) {
+ return UriHostNameType.IPv6;
+ }
+ }
+ end = name.Length;
+ if (IPv4AddressHelper.IsValid(fixedName, 0 , ref end, false, false, false) && end == name.Length) {
+ return UriHostNameType.IPv4;
+ }
+ end = name.Length;
+ bool dummyBool = false;
+ if (DomainNameHelper.IsValid(fixedName, 0, ref end, ref dummyBool, false) && end == name.Length) {
+ return UriHostNameType.Dns;
+ }
+
+ end = name.Length;
+ dummyBool = false;
+ if (DomainNameHelper.IsValidByIri(fixedName, 0, ref end, ref dummyBool, false)
+ && end == name.Length) {
+ return UriHostNameType.Dns;
+ }
+ }
+
+ //This checks the form without []
+ end = name.Length+2;
+ // we require that _entire_ name is recognized as ipv6 address
+ name = "["+name+"]";
+ fixed (char* newFixedName = name) {
+ if (IPv6AddressHelper.IsValid(newFixedName, 1, ref end) && end == name.Length) {
+ return UriHostNameType.IPv6;
+ }
+ }
+ }
+ return UriHostNameType.Unknown;
+ }
+
+ //
+ // GetLeftPart
+ //
+ // Returns part of the URI based on the parameters:
+ //
+ // Inputs:
+ // <argument> part
+ // Which part of the URI to return
+ //
+ // Returns:
+ // The requested substring
+ //
+ // Throws:
+ // UriFormatException if URI type doesn't have host-port or authority parts
+ //
+ public string GetLeftPart(UriPartial part) {
+ if (IsNotAbsoluteUri) {
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ EnsureUriInfo();
+ const UriComponents NonPathPart = (UriComponents.Scheme | UriComponents.UserInfo | UriComponents.Host | UriComponents.Port);
+
+ switch (part) {
+ case UriPartial.Scheme:
+
+ return GetParts(UriComponents.Scheme | UriComponents.KeepDelimiter, UriFormat.UriEscaped);
+
+ case UriPartial.Authority:
+
+ if (NotAny(Flags.AuthorityFound) || IsDosPath) {
+
+ //
+
+
+
+ // From V1.0 comments:
+
+ // anything that didn't have "//" after the scheme name
+ // (mailto: and news: e.g.) doesn't have an authority
+ //
+
+ return String.Empty;
+ }
+ return GetParts(NonPathPart, UriFormat.UriEscaped);
+
+ case UriPartial.Path:
+ return GetParts(NonPathPart | UriComponents.Path, UriFormat.UriEscaped);
+
+ case UriPartial.Query:
+ return GetParts(NonPathPart | UriComponents.Path | UriComponents.Query, UriFormat.UriEscaped);
+
+ }
+ throw new ArgumentException("part");
+ }
+
+ //
+ //
+ /// Transforms a character into its hexadecimal representation.
+ public static string HexEscape(char character) {
+ if (character > '\xff') {
+ throw new ArgumentOutOfRangeException("character");
+ }
+ char[] chars = new char[3];
+ int pos = 0;
+ UriHelper.EscapeAsciiChar(character, chars, ref pos);
+ return new string(chars);
+ }
+
+ //
+ // HexUnescape
+ //
+ // Converts a substring of the form "%XX" to the single character represented
+ // by the hexadecimal value XX. If the substring s[Index] does not conform to
+ // the hex encoding format then the character at s[Index] is returned
+ //
+ // Inputs:
+ // <argument> pattern
+ // String from which to read the hexadecimal encoded substring
+ //
+ // <argument> index
+ // Offset within <pattern> from which to start reading the hexadecimal
+ // encoded substring
+ //
+ // Outputs:
+ // <argument> index
+ // Incremented to the next character position within the string. This
+ // may be EOS if this was the last character/encoding within <pattern>
+ //
+ // Returns:
+ // Either the converted character if <pattern>[<index>] was hex encoded, or
+ // the character at <pattern>[<index>]
+ //
+ // Throws:
+ // ArgumentOutOfRangeException
+ //
+
+ public static char HexUnescape(string pattern, ref int index) {
+ if ((index < 0) || (index >= pattern.Length)) {
+ throw new ArgumentOutOfRangeException("index");
+ }
+ if ((pattern[index] == '%')
+ && (pattern.Length - index >= 3)) {
+ char ret = UriHelper.EscapedAscii(pattern[index + 1], pattern[index + 2]);
+ if (ret != c_DummyChar) {
+ index += 3;
+ return ret;
+ }
+ }
+ return pattern[index++];
+ }
+
+ //
+ // IsHexEncoding
+ //
+ // Determines whether a substring has the URI hex encoding format of '%'
+ // followed by 2 hexadecimal characters
+ //
+ // Inputs:
+ // <argument> pattern
+ // String to check
+ //
+ // <argument> index
+ // Offset in <pattern> at which to check substring for hex encoding
+ //
+ // Assumes:
+ // 0 <= <index> < <pattern>.Length
+ //
+ // Returns:
+ // true if <pattern>[<index>] is hex encoded, else false
+ //
+ // Throws:
+ // Nothing
+ //
+ public static bool IsHexEncoding(string pattern, int index) {
+ if ((pattern.Length - index) < 3) {
+ return false;
+ }
+ if ((pattern[index] == '%') && UriHelper.EscapedAscii(pattern[index + 1], pattern[index + 2]) != c_DummyChar) {
+ return true;
+ }
+ return false;
+ }
+
+ //
+ // Is this a gen delim char from RFC 3986
+ //
+ internal static bool IsGenDelim(char ch)
+ {
+ return (ch == ':' || ch == '/' || ch == '?' || ch == '#' || ch == '[' || ch == ']' || ch == '@');
+ }
+
+ #endregion !Silverlight
+
+ //
+ // CheckSchemeName
+ //
+ // Determines whether a string is a valid scheme name according to RFC 2396.
+ // Syntax is:
+ // scheme = alpha *(alpha | digit | '+' | '-' | '.')
+ //
+ public static bool CheckSchemeName(string schemeName) {
+ if (((object)schemeName == null)
+ || (schemeName.Length == 0)
+ || !IsAsciiLetter(schemeName[0])) {
+ return false;
+ }
+ for (int i = schemeName.Length - 1; i > 0; --i) {
+ if (!(IsAsciiLetterOrDigit(schemeName[i])
+ || (schemeName[i] == '+')
+ || (schemeName[i] == '-')
+ || (schemeName[i] == '.'))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ //
+ // IsHexDigit
+ //
+ // Determines whether a character is a valid hexadecimal digit in the range
+ // [0..9] | [A..F] | [a..f]
+ //
+ // Inputs:
+ // <argument> character
+ // Character to test
+ //
+ // Returns:
+ // true if <character> is a hexadecimal digit character
+ //
+ // Throws:
+ // Nothing
+ //
+ public static bool IsHexDigit(char character) {
+ return ((character >= '0') && (character <= '9'))
+ || ((character >= 'A') && (character <= 'F'))
+ || ((character >= 'a') && (character <= 'f'));
+ }
+
+ //
+ // Returns:
+ // Number in the range 0..15
+ //
+ // Throws:
+ // ArgumentException
+ //
+ public static int FromHex(char digit) {
+ if (((digit >= '0') && (digit <= '9'))
+ || ((digit >= 'A') && (digit <= 'F'))
+ || ((digit >= 'a') && (digit <= 'f'))) {
+ return (digit <= '9')
+ ? ((int)digit - (int)'0')
+ : (((digit <= 'F')
+ ? ((int)digit - (int)'A')
+ : ((int)digit - (int)'a'))
+ + 10);
+ }
+ throw new ArgumentException("digit");
+ }
+ //
+ // GetHashCode
+ //
+ // Overrides default function (in Object class)
+ //
+ //
+ [SecurityPermission(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)]
+ public override int GetHashCode() {
+ if (IsNotAbsoluteUri)
+ {
+ return CalculateCaseInsensitiveHashCode(OriginalString);
+ }
+
+ // Consider moving hash code storage from m_Info.MoreInfo to m_Info
+ UriInfo info = EnsureUriInfo();
+ if ((object)info.MoreInfo == null) {
+ info.MoreInfo = new MoreInfo();
+ }
+ int tempHash = info.MoreInfo.Hash;
+ if (tempHash == 0) {
+ string chkString = info.MoreInfo.RemoteUrl;
+ if ((object) chkString == null)
+ chkString = GetParts(UriComponents.HttpRequestUrl, UriFormat.SafeUnescaped);
+ tempHash = CalculateCaseInsensitiveHashCode(chkString);
+ if (tempHash == 0) {
+ tempHash = 0x1000000; //making it not zero still large enough to be maped to zero by a hashtable
+ }
+ info.MoreInfo.Hash = tempHash;
+ }
+ return tempHash;
+ }
+
+ //
+ // ToString
+ //
+ // The better implementation would be just
+ //
+ private const UriFormat V1ToStringUnescape = (UriFormat)0x7FFF;
+
+ [SecurityPermission(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)]
+ public override string ToString()
+ {
+ if (m_Syntax == null) {
+ return (m_iriParsing && InFact(Flags.HasUnicode)) ? m_String : OriginalString;
+ }
+
+ EnsureUriInfo();
+ if ((object)m_Info.String == null)
+ {
+
+ // V1.1 compat unless #353711 is appoved, otheriwse it should be just a call into GetParts() as shown below
+ // m_Info.String = GetParts(UriComponents.AbsoluteUri, UriFormat.SafeUnescaped);
+
+ if (Syntax.IsSimple)
+ m_Info.String = GetComponentsHelper(UriComponents.AbsoluteUri, V1ToStringUnescape);
+ else
+ m_Info.String = GetParts(UriComponents.AbsoluteUri, UriFormat.SafeUnescaped);
+
+ }
+ return m_Info.String;
+ }
+
+ //
+ //
+ // A static shortcut to Uri.Equals
+ //
+ [SecurityPermission(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)]
+ public static bool operator == (Uri uri1, Uri uri2) {
+ if ((object)uri1 == (object)uri2) {
+ return true;
+ }
+ if ((object)uri1 == null || (object)uri2 == null) {
+ return false;
+ }
+ return uri2.Equals(uri1);
+ }
+
+ //
+ //
+ // A static shortcut to !Uri.Equals
+ //
+ [SecurityPermission(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)]
+ public static bool operator != (Uri uri1, Uri uri2) {
+ if ((object)uri1 == (object)uri2) {
+ return false;
+ }
+
+ if ((object)uri1 == null || (object)uri2 == null) {
+ return true;
+ }
+
+ return !uri2.Equals(uri1);
+ }
+
+
+
+ //
+ // Equals
+ //
+ // Overrides default function (in Object class)
+ //
+ // Assumes:
+ // <comparand> is an object of class Uri
+ //
+ // Returns:
+ // true if objects have the same value, else false
+ //
+ // Throws:
+ // Nothing
+ //
+ [SecurityPermission(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)]
+ public override bool Equals(object comparand) {
+ if ((object) comparand == null) {
+ return false;
+ }
+
+ if ((object)this == (object)comparand) {
+ return true;
+ }
+
+ Uri obj = comparand as Uri;
+
+ //
+ // we allow comparisons of Uri and String objects only. If a string
+ // is passed, convert to Uri. This is inefficient, but allows us to
+ // canonicalize the comparand, making comparison possible
+ //
+ if ((object)obj == null) {
+ string s = comparand as string;
+
+ if ((object)s == null)
+ return false;
+
+ if (!TryCreate(s, UriKind.RelativeOrAbsolute, out obj))
+ return false;
+ }
+
+ // Since v1.0 two Uris are equal if everything but fragment and UserInfo does match
+
+ // This check is for a case where we already fixed up the equal references
+ if ((object)this.m_String == (object)obj.m_String) {
+ return true;
+ }
+
+ if (IsAbsoluteUri != obj.IsAbsoluteUri)
+ return false;
+
+ if (IsNotAbsoluteUri)
+ return OriginalString.Equals(obj.OriginalString);
+
+ if (NotAny(Flags.AllUriInfoSet) || obj.NotAny(Flags.AllUriInfoSet)) {
+ // Try raw compare for m_Strings as the last chance to keep the working set small
+ if (!IsUncOrDosPath ) {
+ if (m_String.Length == obj.m_String.Length) {
+ unsafe {
+ // Try case sensitive compare on m_Strings
+ fixed (char* pMe = m_String) {
+ fixed (char* pShe = obj.m_String) {
+ // This will never go negative since m_String is checked to be a valid URI
+ int i = (m_String.Length-1);
+ for ( ;i >= 0 ; --i) {
+ if (*(pMe+i) != *(pShe+i)) {
+ break;
+ }
+ }
+ if (i == -1) {
+ return true;
+ }
+ }
+ }
+ }
+ }
+ }
+ else if (String.Compare(m_String, obj.m_String, StringComparison.OrdinalIgnoreCase) == 0) {
+ return true;
+ }
+ }
+
+ // Note that equality test will bring the working set of both
+ // objects up to creation of m_Info.MoreInfo member
+ EnsureUriInfo();
+ obj.EnsureUriInfo();
+
+ if (!UserDrivenParsing && !obj.UserDrivenParsing && Syntax.IsSimple && obj.Syntax.IsSimple)
+ {
+ // Optimization of canonical DNS names by avoiding host string creation.
+ // Note there could be explicit ports specified that would invalidate path offsets
+ if (InFact(Flags.CanonicalDnsHost) && obj.InFact(Flags.CanonicalDnsHost)) {
+ ushort i1 = m_Info.Offset.Host;
+ ushort end1 = m_Info.Offset.Path;
+
+ ushort i2 = obj.m_Info.Offset.Host;
+ ushort end2 = obj.m_Info.Offset.Path;
+ string str = obj.m_String;
+ //Taking the shortest part
+ if (end1-i1 > end2-i2) {
+ end1 = (ushort)(i1 + end2-i2);
+ }
+ // compare and break on ':' if found
+ while (i1 < end1) {
+ if (m_String[i1] != str[i2]) {
+ return false;
+ }
+ if (str[i2] == ':') {
+ // The other must have ':' too to have equal host
+ break;
+ }
+ ++i1;++i2;
+ }
+
+ // The longest host must have ':' or be of the same size
+ if (i1 < m_Info.Offset.Path && m_String[i1] != ':') {
+ return false;
+ }
+ if (i2 < end2 && str[i2] != ':') {
+ return false;
+ }
+ //hosts are equal!
+ }
+ else {
+ EnsureHostString(false);
+ obj.EnsureHostString(false);
+ if (!m_Info.Host.Equals(obj.m_Info.Host)) {
+ return false;
+ }
+ }
+
+ if (Port != obj.Port) {
+ return false;
+ }
+ }
+
+ // see Whidbey#21590
+ // We want to cache RemoteUrl to improve perf for Uri as a key.
+ // We should consider reducing the overall working set by not caching some other properties mentioned in MoreInfo
+
+ // Mutli-threading!
+ UriInfo meInfo = m_Info;
+ UriInfo sheInfo = obj.m_Info;
+ if ((object)meInfo.MoreInfo == null) {
+ meInfo.MoreInfo = new MoreInfo();
+ }
+ if ((object)sheInfo.MoreInfo == null) {
+ sheInfo.MoreInfo = new MoreInfo();
+ }
+
+ // NB: To avoid a race condition when creating MoreInfo field
+ // "meInfo" and "sheInfo" shall remain as local copies.
+ string me = meInfo.MoreInfo.RemoteUrl;
+ if ((object)me == null) {
+ me = GetParts(UriComponents.HttpRequestUrl, UriFormat.SafeUnescaped);
+ meInfo.MoreInfo.RemoteUrl = me;
+ }
+ string she = sheInfo.MoreInfo.RemoteUrl;
+ if ((object)she == null) {
+ she = obj.GetParts(UriComponents.HttpRequestUrl, UriFormat.SafeUnescaped);
+ sheInfo.MoreInfo.RemoteUrl = she;
+ }
+
+ if (!IsUncOrDosPath ) {
+ if (me.Length != she.Length) {
+ return false;
+ }
+ unsafe {
+ // Try case sensitive compare on m_Strings
+ fixed (char* pMe = me) {
+ fixed (char* pShe = she) {
+ char *endMe = pMe + me.Length;
+ char *endShe = pShe + me.Length;
+ while (endMe != pMe) {
+ if (*--endMe != *--endShe) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+ }
+ }
+
+
+ // if IsUncOrDosPath is true then we ignore case in the path comparison
+ // Get Unescaped form as most safe for the comparison
+ // Fragment AND UserInfo are ignored
+ //
+ return (String.Compare(meInfo.MoreInfo.RemoteUrl,
+ sheInfo.MoreInfo.RemoteUrl,
+ IsUncOrDosPath ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal ) == 0);
+ }
+ //
+ public Uri MakeRelativeUri(Uri uri)
+ {
+ if ((object)uri == null)
+ throw new ArgumentNullException("uri");
+
+ if (IsNotAbsoluteUri || uri.IsNotAbsoluteUri)
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+
+ // Note that the UserInfo part is ignored when computing a relative Uri.
+ if ((Scheme == uri.Scheme) && (Host == uri.Host) && (Port == uri.Port))
+ {
+ String otherPath = uri.AbsolutePath;
+
+ // Relative Path
+ String relativeUriString = PathDifference(AbsolutePath, otherPath, !IsUncOrDosPath);
+
+ // Relative Uri's cannot have a colon ':' in the first path segment (RFC 3986, Section 4.2)
+ if (CheckForColonInFirstPathSegment(relativeUriString)
+ // Except for full implicit dos file paths
+ && !(uri.IsDosPath && otherPath.Equals(relativeUriString, StringComparison.Ordinal)))
+ relativeUriString = "./" + relativeUriString;
+
+ // Query & Fragment
+ relativeUriString += uri.GetParts(UriComponents.Query | UriComponents.Fragment, UriFormat.UriEscaped);
+
+ return new Uri(relativeUriString, UriKind.Relative);
+ }
+ return uri;
+ }
+
+ //
+ // http://www.ietf.org/rfc/rfc3986.txt
+ //
+ // 3.3. Path
+ // In addition, a URI reference (Section 4.1) may be a relative-path reference, in which case the first
+ // path segment cannot contain a colon (":") character.
+ //
+ // 4.2. Relative Reference
+ // A path segment that contains a colon character (e.g., "this:that") cannot be used as the first segment
+ // of a relative-path reference, as it would be mistaken for a scheme name. Such a segment must be
+ // preceded by a dot-segment (e.g., "./this:that") to make a relative-path reference.
+ //
+ // 5.4.2. Abnormal Examples
+ // http:(relativeUri) may be considered a valid relative Uri.
+ //
+ // Returns true if a colon is found in the first path segment, false otherwise
+ //
+ private static bool CheckForColonInFirstPathSegment(String uriString)
+ {
+ // Check for anything that may terminate the first regular path segment
+ // or an illegal colon
+ char[] pathDelims = new char[] { ':', '\\', '/', '?', '#' };
+ int index = uriString.IndexOfAny(pathDelims);
+
+ return (index >= 0 && uriString[index] == ':');
+ }
+ // This is used by UriBuilder,
+
+ internal unsafe static string InternalEscapeString(string rawString) {
+ if ((object)rawString == null)
+ return String.Empty;
+
+ int position = 0;
+ char[] dest = UriHelper.EscapeString(rawString, 0, rawString.Length, null, ref position, true, '?', '#', '%');
+ if ((object)dest == null)
+ return rawString;
+
+ return new string(dest, 0, position);
+ }
+
+ //
+ // This method is called first to figure out the scheme or a simple file path
+ // Is called only at the .ctor time
+ //
+ private static unsafe ParsingError ParseScheme(string uriString, ref Flags flags, ref UriParser syntax)
+ {
+ int length = uriString.Length;
+ if (length == 0)
+ return ParsingError.EmptyUriString;
+
+ // we don;t work with >= 64k Uris
+ if (length >= c_MaxUriBufferSize)
+ return ParsingError.SizeLimit;
+
+ //STEP1: parse scheme, lookup this Uri Syntax or create one using UnknownV1SyntaxFlags uri syntax template
+ fixed (char* pUriString = uriString)
+ {
+ ParsingError err = ParsingError.None;
+ ushort idx = ParseSchemeCheckImplicitFile(pUriString, (ushort)length, ref err, ref flags, ref syntax);
+
+ if (err != ParsingError.None)
+ return err;
+
+ flags |= (Flags)idx;
+ }
+ return ParsingError.None;
+ }
+
+ //
+ // A wrapper for ParseMinimal() called from a user parser
+ // It signals back that the call has been done
+ // plus it communicates back a flag for an error if any
+ //
+ internal UriFormatException ParseMinimal()
+ {
+ ParsingError result = PrivateParseMinimal();
+ if (result == ParsingError.None)
+ return null;
+
+ // Means the we think the Uri is invalid, bu that can be later overriden by a user parser
+ m_Flags |= Flags.ErrorOrParsingRecursion;
+
+ return GetException(result);
+ }
+ //
+ //
+ // This method tries to parse the minimal information needed to certify the valifity
+ // of a uri string
+ //
+ // scheme://userinfo@host:Port/Path?Query#Fragment
+ //
+ // The method must be called only at the .ctor time
+ //
+ // Returns ParsingError.None if the Uri syntax is valid, an error otheriwse
+ //
+ private unsafe ParsingError PrivateParseMinimal()
+ {
+ ushort idx = (ushort) (m_Flags & Flags.IndexMask);
+ ushort length = (ushort) m_String.Length;
+ string newHost = null; // stores newly parsed host when original strings are being switched
+
+ // Means a custom UriParser did call "base" InitializeAndValidate()
+ m_Flags &= ~(Flags.IndexMask | Flags.UserDrivenParsing);
+
+ //STEP2: Parse up to the port
+
+ fixed (char* pUriString = ((m_iriParsing &&
+ ((m_Flags & Flags.HasUnicode)!=0) &&
+ ((m_Flags & Flags.HostUnicodeNormalized) == 0)) ? m_originalUnicodeString : m_String))
+ {
+ // Cut trailing spaces in m_String
+ if (length > idx && IsLWS(pUriString[length-1]))
+ {
+ --length;
+ while (length != idx && IsLWS(pUriString[--length]))
+ ;
+ ++length;
+ }
+
+ // Microsoft codereview:
+ // Old Uri parser tries to figure out on a DosPath in all cases.
+ // Hence http://c:/ is treated as as DosPath without the host while it should be a host "c", port 80
+ //
+ // This block is compatible with Old Uri parser in terms it will look for the DosPath if the scheme
+ // syntax allows both empty hostnames and DosPath
+ //
+#if !PLATFORM_UNIX
+ if (m_Syntax.IsAllSet(UriSyntaxFlags.AllowEmptyHost | UriSyntaxFlags.AllowDOSPath)
+ && NotAny(Flags.ImplicitFile) && (idx + 1 < length)) {
+
+ char c;
+ ushort i = (ushort) idx;
+
+ // V1 Compat: Allow _compression_ of > 3 slashes only for File scheme, see VsWhidbey 87448.
+ // This will skip all slashes and if their number is 2+ it sets the AuthorityFound flag
+ for (; i < length; ++i) {
+ if (!((c=pUriString[i])== '\\' || c == '/'))
+ break;
+ }
+
+ if (m_Syntax.InFact(UriSyntaxFlags.FileLikeUri) || i-idx <= 3) {
+ // if more than one slash after the scheme, the authority is present
+ if (i-idx >= 2) {
+ m_Flags |= Flags.AuthorityFound;
+ }
+ // DOS-like path?
+ if (i+1 < (ushort) length && ((c=pUriString[i+1]) == ':' || c == '|') &&
+ IsAsciiLetter(pUriString[i])) {
+
+ if (i+2 >= (ushort) length || ((c=pUriString[i+2]) != '\\' && c != '/'))
+ {
+ // report an error but only for a file: scheme
+ if (m_Syntax.InFact(UriSyntaxFlags.FileLikeUri))
+ return ParsingError.MustRootedPath;
+ }
+ else
+ {
+ // This will set IsDosPath
+ m_Flags |= Flags.DosPath;
+
+ if (m_Syntax.InFact(UriSyntaxFlags.MustHaveAuthority)) {
+ // when DosPath found and Authority is required, set this flag even if Authority is empty
+ m_Flags |= Flags.AuthorityFound;
+ }
+ if (i != idx && i-idx != 2) {
+ //This will remember that DosPath is rooted
+ idx = (ushort)(i-1);
+ }
+ else {
+ idx = i;
+ }
+ }
+ }
+ else if (m_Syntax.InFact(UriSyntaxFlags.FileLikeUri) && (i - idx >= 2 && i - idx != 3 &&
+ i < length && pUriString[i] != '?' && pUriString[i] != '#'))
+ {
+ // see VsWhidbey#226745 V1.0 did not support file:///, fixing it with minimal behavior change impact
+ // Only FILE scheme may have UNC Path flag set
+ m_Flags |= Flags.UncPath;
+ idx = i;
+ }
+ }
+ }
+#endif // !PLATFORM_UNIX
+ //
+ //STEP 1.5 decide on the Authority component
+ //
+#if !PLATFORM_UNIX
+ if ((m_Flags & (Flags.UncPath|Flags.DosPath)) != 0) {
+ }
+#else
+ if ((m_Flags & Flags.ImplicitFile) != 0) {
+ // Already parsed up to the path
+ }
+#endif // !PLATFORM_UNIX
+ else if ((idx+2) <= length) {
+ char first = pUriString[idx];
+ char second = pUriString[idx+1];
+
+ if (m_Syntax.InFact(UriSyntaxFlags.MustHaveAuthority)) {
+ // (V1.0 compatiblity) This will allow http:\\ http:\/ http:/\
+#if !PLATFORM_UNIX
+ if ((first == '/' || first == '\\') && (second == '/' || second == '\\'))
+#else
+ if (first == '/' && second == '/')
+#endif // !PLATFORM_UNIX
+ {
+ m_Flags |= Flags.AuthorityFound;
+ idx+=2;
+ }
+ else {
+ return ParsingError.BadAuthority;
+ }
+ }
+ else if (m_Syntax.InFact(UriSyntaxFlags.OptionalAuthority) && (InFact(Flags.AuthorityFound) ||
+ (first == '/' && second == '/'))) {
+ m_Flags |= Flags.AuthorityFound;
+ idx+=2;
+ }
+ //
+ else if (m_Syntax.NotAny(UriSyntaxFlags.MailToLikeUri)) {
+ // By now we know the URI has no Authority, so if the URI must be normalized, initialize it without one.
+ if (m_iriParsing && (m_Flags & Flags.HasUnicode) != 0 && (m_Flags & Flags.HostUnicodeNormalized) == 0)
+ {
+ m_String = m_String.Substring(0, idx);
+ }
+ // Since there is no Authority, the path index is just the end of the scheme.
+ m_Flags |= ((Flags)idx | Flags.UnknownHostType);
+ return ParsingError.None;
+ }
+ }
+ else if (m_Syntax.InFact(UriSyntaxFlags.MustHaveAuthority)) {
+ return ParsingError.BadAuthority;
+ }
+ //
+ else if (m_Syntax.NotAny(UriSyntaxFlags.MailToLikeUri)) {
+ // By now we know the URI has no Authority, so if the URI must be normalized, initialize it without one.
+ if (m_iriParsing && (m_Flags & Flags.HasUnicode) != 0 && (m_Flags & Flags.HostUnicodeNormalized) == 0)
+ {
+ m_String = m_String.Substring(0, idx);
+ }
+ // Since there is no Authority, the path index is just the end of the scheme.
+ m_Flags |= ((Flags)idx | Flags.UnknownHostType);
+ return ParsingError.None;
+ }
+
+#if !PLATFORM_UNIX
+ // The following sample taken from the original parser comments makes the whole story sad
+ // vsmacros://c:\path\file
+ // Note that two slashes say there must be an Authority but instead the path goes
+ // Fro V1 compat the next block allow this case but not for schemes like http
+ if (InFact(Flags.DosPath)) {
+
+ m_Flags |= (((m_Flags & Flags.AuthorityFound)!= 0)? Flags.BasicHostType :Flags.UnknownHostType);
+ m_Flags |= (Flags)idx;
+ return ParsingError.None;
+ }
+#endif // !PLATFORM_UNIX
+
+ //STEP 2: Check the syntax of authority expecting at least one character in it
+ //
+ // Note here we do know that there is an authority in the string OR it's a DOS path
+
+ // We may find a userInfo and the port when parsing an authority
+ // Also we may find a registry based authority.
+ // We must ensure that known schemes do use a server-based authority
+ {
+ ParsingError err = ParsingError.None;
+ idx = CheckAuthorityHelper(pUriString, idx, (ushort)length, ref err, ref m_Flags, m_Syntax, ref newHost);
+ if (err != ParsingError.None)
+ return err;
+
+ // This will disallow '\' as the host terminator for any scheme that is not implicitFile or cannot have a Dos Path
+ if ((idx < (ushort)length && pUriString[idx] == '\\') && NotAny(Flags.ImplicitFile) &&
+ m_Syntax.NotAny(UriSyntaxFlags.AllowDOSPath)) {
+ return ParsingError.BadAuthorityTerminator;
+ }
+
+ }
+
+ // The Path (or Port) parsing index is reloaded on demand in CreateUriInfo when accessing a Uri property
+ m_Flags |= (Flags)idx;
+
+ // The rest of the string will be parsed on demand
+ // The Host/Authorty is all checked, the type is known but the host value string
+ // is not created/canonicalized at this point.
+ }
+
+ if((s_IdnScope != UriIdnScope.None) || m_iriParsing)
+ PrivateParseMinimalIri(newHost, idx);
+
+ return ParsingError.None;
+ }
+
+ private void PrivateParseMinimalIri(string newHost, ushort idx)
+ {
+ // we have a new host!
+ if (newHost != null)
+ m_String = newHost;
+
+ // conditions where we dont need to go to parseremaining, so we copy the rest of the
+ // original string.. and switch offsets
+ if ((!m_iriParsing && AllowIdn && (((m_Flags & Flags.IdnHost) != 0) || ((m_Flags & Flags.UnicodeHost) != 0))) ||
+ (m_iriParsing && ((m_Flags & Flags.HasUnicode) == 0) && AllowIdn && ((m_Flags & Flags.IdnHost) != 0))){
+ // update the start of path from the end of new string
+ m_Flags &= ~(Flags.IndexMask);
+ m_Flags |= (Flags)m_String.Length;
+
+ m_String += m_originalUnicodeString.Substring(idx, m_originalUnicodeString.Length - idx);
+ }
+
+ // Indicate to createuriinfo that offset is in m_originalUnicodeString
+ if (m_iriParsing && ((m_Flags & Flags.HasUnicode) != 0)){
+ // offset in Flags.IndexMask refers to m_originalUnicodeString
+ m_Flags |= Flags.UseOrigUncdStrOffset;
+ }
+ }
+
+ //
+ //
+ // The method is called when we have to access m_Info members
+ // This will create the m_Info based on the copied parser context
+ // Under milti-threading ---- this method may do duplicated yet harmless work
+ //
+ private unsafe void CreateUriInfo(Flags cF) {
+
+ UriInfo info = new UriInfo();
+
+ // This will be revisited in ParseRemaining but for now just have it at least m_String.Length
+ info.Offset.End = (ushort)m_String.Length;
+
+ if (UserDrivenParsing)
+ goto Done;
+
+ ushort idx;
+ bool notCanonicalScheme = false;
+
+ // The m_String may have leading spaces, figure that out
+ // plus it will set idx value for next steps
+ if ((cF & Flags.ImplicitFile) != 0) {
+ idx = (ushort)0;
+ while (IsLWS(m_String[idx])) {
+ ++idx;
+ ++info.Offset.Scheme;
+ }
+
+#if !PLATFORM_UNIX
+ if (StaticInFact(cF, Flags.UncPath)) {
+ // For implicit file AND Unc only
+ idx += 2;
+ //skip any other slashes (compatibility with V1.0 parser)
+ while(idx < (ushort)(cF & Flags.IndexMask) && (m_String[idx] == '/' || m_String[idx] == '\\')) {
+ ++idx;
+ }
+ }
+#endif // !PLATFORM_UNIX
+ }
+ else {
+ // This is NOT an ImplicitFile uri
+ idx = (ushort)m_Syntax.SchemeName.Length;
+
+ while (m_String[idx++] != ':') {
+ ++info.Offset.Scheme;
+ }
+
+ if ((cF & Flags.AuthorityFound) != 0)
+ {
+ if (m_String[idx] == '\\' || m_String[idx+1] == '\\')
+ notCanonicalScheme = true;
+
+ idx+=2;
+#if !PLATFORM_UNIX
+ if ((cF & (Flags.UncPath|Flags.DosPath)) != 0) {
+ // Skip slashes if it was allowed during ctor time
+ // NB: Today this is only allowed if a Unc or DosPath was found after the scheme
+ while( idx < (ushort)(cF & Flags.IndexMask) && (m_String[idx] == '/' || m_String[idx] == '\\')) {
+ notCanonicalScheme = true;
+ ++idx;
+ }
+ }
+#endif // !PLATFORM_UNIX
+ }
+ }
+
+ // This is weird but some schemes (mailto) do not have Authority-based syntax, still they do have a port
+ if (m_Syntax.DefaultPort != UriParser.NoDefaultPort)
+ info.Offset.PortValue = (ushort)m_Syntax.DefaultPort;
+
+ //Here we set the indexes for already parsed components
+ if ((cF & Flags.HostTypeMask) == Flags.UnknownHostType
+#if !PLATFORM_UNIX
+ || StaticInFact(cF, Flags.DosPath)
+#endif // !PLATFORM_UNIX
+ ) {
+ //there is no Authotity component defined
+ info.Offset.User = (ushort) (cF & Flags.IndexMask);
+ info.Offset.Host = info.Offset.User;
+ info.Offset.Path = info.Offset.User;
+ cF &= ~Flags.IndexMask;
+ if (notCanonicalScheme) {
+ cF |= Flags.SchemeNotCanonical;
+ }
+ goto Done;
+ }
+
+ info.Offset.User = idx;
+
+ //Basic Host Type does not have userinfo and port
+ if (HostType == Flags.BasicHostType) {
+ info.Offset.Host = idx;
+ info.Offset.Path = (ushort) (cF & Flags.IndexMask);
+ cF &= ~Flags.IndexMask;
+ goto Done;
+ }
+
+ if ((cF & Flags.HasUserInfo) != 0) {
+ // we previously found a userinfo, get it again
+ while (m_String[idx] != '@') {
+ ++idx;
+ }
+ ++idx;
+ info.Offset.Host = idx;
+ }
+ else {
+ info.Offset.Host = idx;
+ }
+
+ //Now reload the end of the parsed host
+
+ idx = (ushort) (cF & Flags.IndexMask);
+
+ //From now on we do not need IndexMask bits, and reuse the space for X_NotCanonical flags
+ //clear them now
+ cF &= ~Flags.IndexMask;
+
+ // If this is not canonical, don't count on user input to be good
+ if (notCanonicalScheme) {
+ cF |= Flags.SchemeNotCanonical;
+ }
+
+ //Guessing this is a path start
+ info.Offset.Path = idx;
+
+ // parse Port if any. The new spec allows a port after ':' to be empty (assuming default?)
+ bool notEmpty = false;
+ // Note we already checked on general port syntax in ParseMinimal()
+
+ // If iri parsing is on with unicode chars then the end of parsed host
+ // points to m_orig string and not m_String
+
+ bool UseOrigUnicodeStrOffset = ((cF& Flags.UseOrigUncdStrOffset) != 0);
+ // This should happen only once. Reset it
+ cF &= ~Flags.UseOrigUncdStrOffset;
+
+ if (UseOrigUnicodeStrOffset)
+ info.Offset.End = (ushort)m_originalUnicodeString.Length;
+
+ if (idx < info.Offset.End ){
+ fixed (char* userString = UseOrigUnicodeStrOffset ? m_originalUnicodeString : m_String){
+ if (userString[idx] == ':'){
+ int port = 0;
+
+ //Check on some noncanonical cases http://host:0324/, http://host:03, http://host:0, etc
+ if (++idx < info.Offset.End){
+ port = (ushort)(userString[idx] - '0');
+ if (!(port == unchecked((ushort)('/' - '0')) || port == (ushort)('?' - '0') ||
+ port == unchecked((ushort)('#' - '0')))) {
+ notEmpty = true;
+ if (port == 0){
+ cF |= (Flags.PortNotCanonical | Flags.E_PortNotCanonical);
+ }
+ for (++idx; idx < info.Offset.End; ++idx){
+ ushort val = (ushort)((ushort)userString[idx] - (ushort)'0');
+ if (val == unchecked((ushort)('/' - '0')) || val == (ushort)('?' - '0') ||
+ val == unchecked((ushort)('#' - '0'))){
+ break;
+ }
+ port = (port * 10 + val);
+ }
+ }
+ }
+ if (notEmpty && info.Offset.PortValue != (ushort)port){
+ info.Offset.PortValue = (ushort)port;
+ cF |= Flags.NotDefaultPort;
+ }
+ else{
+ //This will tell that we do have a ':' but the port value does
+ //not follow to canonical rules
+ cF |= (Flags.PortNotCanonical | Flags.E_PortNotCanonical);
+ }
+ info.Offset.Path = (ushort)idx;
+ }
+ }
+ }
+
+ Done:
+ cF |= Flags.MinimalUriInfoSet;
+/*********
+ // The spinlock would be better than below lock but it's too late for Beta2, consider for RTM
+ // Also DON'T forget to check EnsureUriInfo method
+ int copyF = m_Flags;
+ while ((copyF & Flags.MinimalUriInfoSet) == 0)
+ {
+ if (copyF != (copyF = Interlocked.CompareExchange(ref m_Flags, cF | (copyF & ~Flags.IndexMask), copyF))
+ continue;
+ m_Info = info;
+ }
+*********/
+ info.DnsSafeHost = m_DnsSafeHost;
+ lock (m_String)
+ {
+ if (( m_Flags & Flags.MinimalUriInfoSet) == 0)
+ {
+ m_Info = info;
+ m_Flags = (m_Flags & ~Flags.IndexMask) | cF;
+ }
+ }
+
+ }
+
+ //
+ // This will create a Host string. The validity has been already checked
+ //
+ // Assuming: UriInfo memeber is already set at this point
+ private unsafe void CreateHostString() {
+ //
+ // Mutlithrreading!
+ //
+ if (!m_Syntax.IsSimple)
+ {
+ lock (m_Info)
+ {
+ // ATTN: Avoid possible recursion through
+ // CreateHostString->Syntax.GetComponents->Uri.GetComponentsHelper->CreateHostString
+ if (NotAny(Flags.ErrorOrParsingRecursion))
+ {
+ m_Flags |= Flags.ErrorOrParsingRecursion;
+ // Need to get host string through the derived type
+ GetHostViaCustomSyntax();
+ m_Flags &= ~Flags.ErrorOrParsingRecursion;
+ return;
+ }
+ }
+ }
+ Flags flags = m_Flags;
+ string host = CreateHostStringHelper(m_String, m_Info.Offset.Host, m_Info.Offset.Path, ref flags, ref m_Info.ScopeId);
+
+ // now check on canonical host representation
+ if (host.Length != 0)
+ {
+ // An Authority may need escaping except when it's an inet server address
+ //
+ // We do not escape UNC names and will get rid of this type when switching to IDN spec
+ //
+ if (HostType == Flags.BasicHostType) {
+ ushort idx = 0;
+ Check result;
+ fixed (char* pHost = host) {
+ result = CheckCanonical(pHost, ref idx, (ushort)host.Length, c_DummyChar);
+ }
+
+ if ((result & Check.DisplayCanonical) == 0) {
+ // For implicit file the user string must be in perfect display format,
+ // Hence, ignoring complains from CheckCanonical()
+ if (NotAny(Flags.ImplicitFile) || (result & Check.ReservedFound) != 0) {
+ flags |= Flags.HostNotCanonical;
+ }
+ }
+
+ if (InFact(Flags.ImplicitFile) && (result & (Check.ReservedFound | Check.EscapedCanonical)) != 0) {
+ // need to re-escape this host if any escaped sequence was found
+ result &= ~Check.EscapedCanonical;
+ }
+
+ if ((result & (Check.EscapedCanonical|Check.BackslashInPath)) != Check.EscapedCanonical) {
+ // we will make a canonical host in m_Info.Host, but mark that m_String holds wrong data
+ flags |= Flags.E_HostNotCanonical;
+ if (NotAny(Flags.UserEscaped))
+ {
+ int position = 0;
+ char[] dest = UriHelper.EscapeString(host, 0, host.Length, null, ref position, true, '?',
+ '#', IsImplicitFile ? c_DummyChar : '%');
+ if ((object)dest != null)
+ host = new string(dest, 0, position);
+ }
+ else {
+ //
+
+ }
+ }
+ }
+ else if (NotAny(Flags.CanonicalDnsHost)){
+ // Check to see if we can take the canonical host string out of m_String
+ if ((object)m_Info.ScopeId != null) {
+ // IPv6 ScopeId is included when serializing a Uri
+ flags |= (Flags.HostNotCanonical | Flags.E_HostNotCanonical);
+ }
+ else {
+ for (int i=0 ; i < host.Length; ++i) {
+ if ((m_Info.Offset.Host + i) >= m_Info.Offset.End ||
+ host[i] != m_String[m_Info.Offset.Host + i]) {
+ flags |= (Flags.HostNotCanonical | Flags.E_HostNotCanonical);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ m_Info.Host = host;
+ lock (m_Info)
+ {
+ m_Flags |= flags;
+ }
+ }
+ //
+ private static string CreateHostStringHelper(string str, ushort idx, ushort end, ref Flags flags, ref string scopeId)
+ {
+ bool loopback = false;
+ string host;
+ switch (flags & Flags.HostTypeMask) {
+
+ case Flags.DnsHostType:
+ host = DomainNameHelper.ParseCanonicalName(str, idx, end, ref loopback);
+ break;
+
+ case Flags.IPv6HostType:
+ //Microsoft codereview
+ // The helper will return [...] string that is not suited for Dns.Resolve()
+ host = IPv6AddressHelper.ParseCanonicalName(str, idx, ref loopback, ref scopeId);
+ break;
+
+ case Flags.IPv4HostType:
+ host = IPv4AddressHelper.ParseCanonicalName(str, idx, end, ref loopback);
+ break;
+
+#if !PLATFORM_UNIX
+ case Flags.UncHostType:
+ host = UncNameHelper.ParseCanonicalName(str, idx, end, ref loopback);
+ break;
+#endif // !PLATFORM_UNIX
+
+ case Flags.BasicHostType:
+#if !PLATFORM_UNIX
+ if (StaticInFact(flags, Flags.DosPath)) {
+ host = string.Empty;
+ }
+ else
+#endif // !PLATFORM_UNIX
+ {
+ // This is for a registry-based authority, not relevant for known schemes
+ host = str.Substring(idx, end-idx);
+ }
+ // A empty host would count for a loopback
+ if (host.Length == 0) {
+ loopback = true;
+ }
+ //there will be no port
+ break;
+
+ case Flags.UnknownHostType:
+ //means the host is *not expected* for this uri type
+ host = string.Empty;
+ break;
+
+ default: //it's a bug
+ throw GetException(ParsingError.BadHostName);
+ }
+
+ if (loopback) {
+ flags |= Flags.LoopbackHost;
+ }
+ return host;
+ }
+ //
+ // Called under lock()
+ //
+ private unsafe void GetHostViaCustomSyntax()
+ {
+ // A multithreading check
+ if (m_Info.Host != null)
+ return;
+
+ string host = m_Syntax.InternalGetComponents(this, UriComponents.Host, UriFormat.UriEscaped);
+
+ // ATTN: Check on whether recursion has not happened
+ if ((object)m_Info.Host == null)
+ {
+ if (host.Length >= c_MaxUriBufferSize)
+ throw GetException(ParsingError.SizeLimit);
+
+ ParsingError err = ParsingError.None;
+ Flags flags = m_Flags & ~Flags.HostTypeMask;
+
+ fixed (char *pHost = host)
+ {
+ string newHost = null;
+ if (CheckAuthorityHelper(pHost, 0, (ushort)host.Length, ref err, ref flags, m_Syntax, ref newHost) !=
+ (ushort)host.Length)
+ {
+ // We cannot parse the entire host string
+ flags &= ~Flags.HostTypeMask;
+ flags |= Flags.UnknownHostType;
+ }
+ }
+
+ if (err != ParsingError.None || (flags & Flags.HostTypeMask) == Flags.UnknownHostType)
+ {
+ // Well, custom parser has returned a not known host type, take it as Basic then.
+ m_Flags = (m_Flags & ~Flags.HostTypeMask) | Flags.BasicHostType;
+ }
+ else
+ {
+ host = CreateHostStringHelper(host, 0, (ushort)host.Length, ref flags, ref m_Info.ScopeId);
+ for (int i=0 ; i < host.Length; ++i) {
+ if ((m_Info.Offset.Host + i) >= m_Info.Offset.End || host[i] != m_String[m_Info.Offset.Host + i]) {
+ m_Flags |= (Flags.HostNotCanonical | Flags.E_HostNotCanonical);
+ break;
+ }
+ }
+ m_Flags = (m_Flags & ~Flags.HostTypeMask) | (flags & Flags.HostTypeMask);
+ }
+ }
+ //
+ // This is a chance for a custom parser to report a different port value
+ //
+ string portStr = m_Syntax.InternalGetComponents(this, UriComponents.StrongPort, UriFormat.UriEscaped);
+ int port = 0;
+ if ((object)portStr == null || portStr.Length == 0)
+ {
+ // It's like no port
+ m_Flags &= ~Flags.NotDefaultPort;
+ m_Flags |= (Flags.PortNotCanonical|Flags.E_PortNotCanonical);
+ m_Info.Offset.PortValue = 0;
+ }
+ else
+ {
+ for (int idx=0; idx < portStr.Length; ++idx)
+ {
+ int val = portStr[idx] - '0';
+ if (val < 0 || val > 9 || (port = (port * 10 + val)) > 0xFFFF)
+ throw new UriFormatException(SR.GetString(SR.net_uri_PortOutOfRange, m_Syntax.GetType().FullName, portStr));
+ }
+ if (port != m_Info.Offset.PortValue)
+ {
+ if (port == m_Syntax.DefaultPort)
+ m_Flags &= ~Flags.NotDefaultPort;
+ else
+ m_Flags |= Flags.NotDefaultPort;
+
+ m_Flags |= (Flags.PortNotCanonical|Flags.E_PortNotCanonical);
+ m_Info.Offset.PortValue = (ushort) port;
+ }
+ }
+ // This must be done as the last thing in this method
+ m_Info.Host = host;
+ }
+ //
+ // An internal shortcut into Uri extenisiblity API
+ //
+ internal string GetParts(UriComponents uriParts, UriFormat formatAs)
+ {
+ return GetComponents(uriParts, formatAs);
+ }
+
+ //
+ //
+ //
+ private string GetEscapedParts(UriComponents uriParts) {
+ // Which Uri parts are not escaped canonically ?
+ // Notice that public UriPart and private Flags must me in Sync so below code can work
+ //
+ ushort nonCanonical = (ushort)(((ushort)m_Flags & ((ushort)Flags.CannotDisplayCanonical<<7)) >> 6);
+ if (InFact(Flags.SchemeNotCanonical)) {
+ nonCanonical |= (ushort)Flags.SchemeNotCanonical;
+ }
+
+ // We keep separate flags for some of path canonicalization facts
+ if ((uriParts & UriComponents.Path) != 0) {
+ if (InFact(Flags.ShouldBeCompressed|Flags.FirstSlashAbsent|Flags.BackslashInPath)) {
+ nonCanonical |= (ushort)Flags.PathNotCanonical;
+ }
+ else if (IsDosPath && m_String[m_Info.Offset.Path + SecuredPathIndex - 1] == '|') {
+ // A rare case of c|\
+ nonCanonical |= (ushort)Flags.PathNotCanonical;
+ }
+ }
+
+ if (((ushort)uriParts & nonCanonical) == 0) {
+ string ret = GetUriPartsFromUserString(uriParts);
+ if ((object)ret != null) {
+ return ret;
+ }
+ }
+
+ return ReCreateParts(uriParts, nonCanonical, UriFormat.UriEscaped);
+ }
+
+ private string GetUnescapedParts(UriComponents uriParts, UriFormat formatAs) {
+ // Which Uri parts are not escaped canonically ?
+ // Notice that public UriComponents and private Uri.Flags must me in Sync so below code can work
+ //
+ ushort nonCanonical = (ushort)((ushort)m_Flags & (ushort)Flags.CannotDisplayCanonical);
+
+ // We keep separate flags for some of path canonicalization facts
+ if ((uriParts & UriComponents.Path) != 0) {
+ if ((m_Flags & (Flags.ShouldBeCompressed|Flags.FirstSlashAbsent|Flags.BackslashInPath)) !=0) {
+ nonCanonical |= (ushort)Flags.PathNotCanonical;
+ }
+ else if (IsDosPath && m_String[m_Info.Offset.Path + SecuredPathIndex - 1] == '|') {
+ // A rare case of c|\
+ nonCanonical |= (ushort)Flags.PathNotCanonical;
+ }
+
+ }
+
+ if (((ushort)uriParts & nonCanonical) == 0) {
+ string ret = GetUriPartsFromUserString(uriParts);
+ if ((object)ret != null) {
+ return ret;
+ }
+ }
+
+ return ReCreateParts(uriParts, nonCanonical, formatAs);
+ }
+
+ //
+ //
+ //
+ private string ReCreateParts(UriComponents parts, ushort nonCanonical, UriFormat formatAs)
+ {
+ // going hard core
+ EnsureHostString(false);
+ string stemp = (parts & UriComponents.Host) == 0? string.Empty: m_Info.Host;
+ // we reserve more space than required because a canonical Ipv6 Host
+ // may take more characteres than in original m_String
+ // Also +3 is for :// and +1 is for absent first slash
+ // Also we may escape every character, hence multiplying by 12
+ // UTF-8 can use up to 4 bytes per char * 3 chars per byte (%A4) = 12 encoded chars
+ int count = (m_Info.Offset.End-m_Info.Offset.User) * (formatAs == UriFormat.UriEscaped?12:1);
+ char[] chars = new char[stemp.Length + count + m_Syntax.SchemeName.Length + 3 + 1];
+ count = 0;
+
+ //Scheme and slashes
+ if ((parts & UriComponents.Scheme) != 0) {
+ m_Syntax.SchemeName.CopyTo(0, chars, count, m_Syntax.SchemeName.Length);
+ count += m_Syntax.SchemeName.Length;
+ if (parts != UriComponents.Scheme) {
+ chars[count++] = ':';
+ if (InFact(Flags.AuthorityFound)) {
+ chars[count++] = '/';
+ chars[count++] = '/';
+ }
+ }
+ }
+
+ //UserInfo
+ if ((parts & UriComponents.UserInfo) != 0 && InFact(Flags.HasUserInfo))
+ {
+ if ((nonCanonical & (ushort)UriComponents.UserInfo) != 0) {
+ switch (formatAs) {
+ case UriFormat.UriEscaped:
+ if (NotAny(Flags.UserEscaped))
+ {
+ chars = UriHelper.EscapeString(m_String, m_Info.Offset.User, m_Info.Offset.Host, chars,
+ ref count, true, '?', '#', '%');
+ }
+ else {
+ if (InFact(Flags.E_UserNotCanonical)) {
+ //
+
+ }
+ m_String.CopyTo(m_Info.Offset.User, chars, count, m_Info.Offset.Host - m_Info.Offset.User);
+ count += (m_Info.Offset.Host - m_Info.Offset.User);
+ }
+ break;
+
+ case UriFormat.SafeUnescaped:
+ chars = UriHelper.UnescapeString(m_String, m_Info.Offset.User, m_Info.Offset.Host - 1,
+ chars, ref count, '@', '/', '\\', InFact(Flags.UserEscaped) ? UnescapeMode.Unescape :
+ UnescapeMode.EscapeUnescape, m_Syntax, false);
+ chars[count++] = '@';
+ break;
+
+ case UriFormat.Unescaped:
+ chars = UriHelper.UnescapeString(m_String, m_Info.Offset.User, m_Info.Offset.Host, chars,
+ ref count, c_DummyChar, c_DummyChar, c_DummyChar,
+ UnescapeMode.Unescape | UnescapeMode.UnescapeAll, m_Syntax, false);
+ break;
+
+ default: //V1ToStringUnescape
+ chars = UriHelper.UnescapeString(m_String, m_Info.Offset.User, m_Info.Offset.Host, chars,
+ ref count, c_DummyChar, c_DummyChar, c_DummyChar, UnescapeMode.CopyOnly, m_Syntax,
+ false);
+ break;
+ }
+ }
+ else {
+ UriHelper.UnescapeString(m_String, m_Info.Offset.User, m_Info.Offset.Host, chars, ref count,
+ c_DummyChar, c_DummyChar, c_DummyChar, UnescapeMode.CopyOnly, m_Syntax, false);
+ }
+ if (parts == UriComponents.UserInfo)
+ {
+ //strip '@' delimiter
+ --count;
+ }
+ }
+
+ // Host
+ if ((parts & UriComponents.Host) != 0 && stemp.Length != 0)
+ {
+ UnescapeMode mode;
+ if (formatAs != UriFormat.UriEscaped && HostType == Flags.BasicHostType
+ && (nonCanonical & (ushort)UriComponents.Host) != 0) {
+ // only Basic host could be in the escaped form
+ mode = formatAs == UriFormat.Unescaped
+ ? (UnescapeMode.Unescape | UnescapeMode.UnescapeAll) :
+ (InFact(Flags.UserEscaped) ? UnescapeMode.Unescape : UnescapeMode.EscapeUnescape);
+
+ }
+ else {
+ mode = UnescapeMode.CopyOnly;
+ }
+ // NormalizedHost
+ if ((parts & UriComponents.NormalizedHost) != 0)
+ {
+ unsafe
+ {
+ fixed (char* hostPtr = stemp)
+ {
+ bool allAscii = false;
+ bool atLeastOneValidIdn = false;
+ try
+ {
+ // Upconvert any punycode to unicode, xn--pck -> ?
+ stemp = DomainNameHelper.UnicodeEquivalent(
+ hostPtr, 0, stemp.Length, ref allAscii, ref atLeastOneValidIdn);
+ }
+ // The host may be invalid punycode (www.xn--?-pck.com),
+ // but we shouldn't throw after the constructor.
+ catch (UriFormatException) { }
+ }
+ }
+ }
+ chars = UriHelper.UnescapeString(stemp, 0, stemp.Length, chars, ref count, '/', '?', '#', mode,
+ m_Syntax, false);
+
+ // A fix up only for SerializationInfo and IpV6 host with a scopeID
+ if ((parts & UriComponents.SerializationInfoString) != 0 && HostType == Flags.IPv6HostType &&
+ (object)m_Info.ScopeId != null)
+ {
+ m_Info.ScopeId.CopyTo(0, chars, count-1, m_Info.ScopeId.Length);
+ count += m_Info.ScopeId.Length;
+ chars[count-1] = ']';
+ }
+ }
+
+ //Port (always wants a ':' delimiter if got to this method)
+ if ((parts & UriComponents.Port) != 0)
+ {
+ if ((nonCanonical & (ushort)UriComponents.Port) == 0) {
+ //take it from m_String
+ if (InFact(Flags.NotDefaultPort)) {
+ ushort start = m_Info.Offset.Path;
+ while (m_String[--start] != ':') {
+ ;
+ }
+ m_String.CopyTo(start, chars, count, m_Info.Offset.Path - start);
+ count += (m_Info.Offset.Path - start);
+ }
+ else if ((parts & UriComponents.StrongPort) != 0 && m_Syntax.DefaultPort != UriParser.NoDefaultPort) {
+ chars[count++]= ':';
+ stemp = m_Info.Offset.PortValue.ToString(CultureInfo.InvariantCulture);
+ stemp.CopyTo(0, chars, count, stemp.Length);
+ count += stemp.Length;
+ }
+ }
+ else if (InFact(Flags.NotDefaultPort) || ((parts & UriComponents.StrongPort) != 0 &&
+ m_Syntax.DefaultPort != UriParser.NoDefaultPort)) {
+ // recreate string from port value
+ chars[count++]= ':';
+ stemp = m_Info.Offset.PortValue.ToString(CultureInfo.InvariantCulture);
+ stemp.CopyTo(0, chars, count, stemp.Length);
+ count += stemp.Length;
+ }
+ }
+
+ ushort delimiterAwareIndex;
+
+ //Path
+ if ((parts & UriComponents.Path) != 0)
+ {
+ chars = GetCanonicalPath(chars, ref count, formatAs);
+
+ // (possibly strip the leading '/' delimiter)
+ if (parts == UriComponents.Path)
+ {
+ if (InFact(Flags.AuthorityFound) && count !=0 && chars[0] == '/')
+ {
+ delimiterAwareIndex = 1; --count;
+ }
+ else
+ {
+ delimiterAwareIndex = 0;
+ }
+ return count == 0? string.Empty: new string(chars, delimiterAwareIndex, count);
+ }
+ }
+
+ //Query (possibly strip the '?' delimiter)
+ if ((parts & UriComponents.Query) != 0 && m_Info.Offset.Query < m_Info.Offset.Fragment)
+ {
+ delimiterAwareIndex = (ushort)(m_Info.Offset.Query+1);
+ if(parts != UriComponents.Query)
+ chars[count++] = '?'; //see Fragment+1 below
+
+ if ((nonCanonical & (ushort)UriComponents.Query) != 0)
+ {
+ switch (formatAs)
+ {
+ case UriFormat.UriEscaped:
+ //Can Assert IsImplicitfile == false
+ if (NotAny(Flags.UserEscaped))
+ chars = UriHelper.EscapeString(m_String, delimiterAwareIndex, m_Info.Offset.Fragment, chars,
+ ref count, true, '#', c_DummyChar, '%');
+ else
+ {
+ //
+
+
+ UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.Fragment, chars,
+ ref count, c_DummyChar, c_DummyChar, c_DummyChar, UnescapeMode.CopyOnly, m_Syntax,
+ true);
+ }
+ break;
+
+ case V1ToStringUnescape:
+
+ chars = UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.Fragment, chars,
+ ref count, '#', c_DummyChar, c_DummyChar, (InFact(Flags.UserEscaped) ?
+ UnescapeMode.Unescape : UnescapeMode.EscapeUnescape) | UnescapeMode.V1ToStringFlag,
+ m_Syntax, true);
+ break;
+
+ case UriFormat.Unescaped:
+
+ chars = UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.Fragment, chars,
+ ref count, '#', c_DummyChar, c_DummyChar,
+ (UnescapeMode.Unescape | UnescapeMode.UnescapeAll), m_Syntax, true);
+ break;
+
+ default: // UriFormat.SafeUnescaped
+
+ chars = UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.Fragment, chars,
+ ref count, '#', c_DummyChar, c_DummyChar, (InFact(Flags.UserEscaped) ?
+ UnescapeMode.Unescape : UnescapeMode.EscapeUnescape), m_Syntax, true);
+ break;
+ }
+ }
+ else
+ {
+ UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.Fragment, chars, ref count,
+ c_DummyChar, c_DummyChar, c_DummyChar, UnescapeMode.CopyOnly, m_Syntax, true);
+ }
+ }
+
+ //Fragment (possibly strip the '#' delimiter)
+ if ((parts & UriComponents.Fragment) != 0 && m_Info.Offset.Fragment < m_Info.Offset.End)
+ {
+ delimiterAwareIndex = (ushort)(m_Info.Offset.Fragment+1);
+ if(parts != UriComponents.Fragment)
+ chars[count++] = '#'; //see Fragment+1 below
+
+ if ((nonCanonical & (ushort)UriComponents.Fragment) != 0)
+ {
+ switch (formatAs) {
+ case UriFormat.UriEscaped:
+ if (NotAny(Flags.UserEscaped))
+ chars = UriHelper.EscapeString(m_String, delimiterAwareIndex, m_Info.Offset.End, chars,
+ ref count, true, UriParser.ShouldUseLegacyV2Quirks ? '#' : c_DummyChar, c_DummyChar, '%');
+ else
+ {
+ //
+
+
+ UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.End, chars,
+ ref count, c_DummyChar, c_DummyChar, c_DummyChar, UnescapeMode.CopyOnly, m_Syntax,
+ false);
+ }
+ break;
+
+ case V1ToStringUnescape:
+
+ chars = UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.End, chars,
+ ref count, '#', c_DummyChar, c_DummyChar, (InFact(Flags.UserEscaped) ?
+ UnescapeMode.Unescape : UnescapeMode.EscapeUnescape) | UnescapeMode.V1ToStringFlag,
+ m_Syntax, false);
+ break;
+ case UriFormat.Unescaped:
+
+ chars = UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.End, chars,
+ ref count, '#', c_DummyChar, c_DummyChar,
+ UnescapeMode.Unescape | UnescapeMode.UnescapeAll, m_Syntax, false);
+ break;
+
+ default: // UriFormat.SafeUnescaped
+
+ chars = UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.End, chars,
+ ref count, '#', c_DummyChar, c_DummyChar, (InFact(Flags.UserEscaped) ?
+ UnescapeMode.Unescape : UnescapeMode.EscapeUnescape), m_Syntax, false);
+ break;
+ }
+ }
+ else
+ {
+ UriHelper.UnescapeString(m_String, delimiterAwareIndex, m_Info.Offset.End, chars, ref count,
+ c_DummyChar, c_DummyChar, c_DummyChar, UnescapeMode.CopyOnly, m_Syntax, false);
+ }
+ }
+
+ return new string(chars, 0, count);
+ }
+
+ //
+ // This method is called only if the user string has a canonical representation
+ // of requested parts
+ //
+ private string GetUriPartsFromUserString(UriComponents uriParts) {
+
+ ushort delimiterAwareIdx;
+
+ switch (uriParts & ~UriComponents.KeepDelimiter) {
+ // For FindServicePoint perf
+ case UriComponents.Scheme | UriComponents.Host | UriComponents.Port:
+ if (!InFact(Flags.HasUserInfo))
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.Path - m_Info.Offset.Scheme);
+
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.User - m_Info.Offset.Scheme)
+ + m_String.Substring(m_Info.Offset.Host, m_Info.Offset.Path - m_Info.Offset.Host);
+
+ // For HttpWebRequest.ConnectHostAndPort perf
+ case UriComponents.HostAndPort: //Host|StrongPort
+
+ if (!InFact(Flags.HasUserInfo))
+ goto case UriComponents.StrongAuthority;
+
+ if (InFact(Flags.NotDefaultPort) || m_Syntax.DefaultPort == UriParser.NoDefaultPort)
+ return m_String.Substring(m_Info.Offset.Host, m_Info.Offset.Path - m_Info.Offset.Host);
+
+ return m_String.Substring(m_Info.Offset.Host, m_Info.Offset.Path - m_Info.Offset.Host)
+ + ':' + m_Info.Offset.PortValue.ToString(CultureInfo.InvariantCulture);
+
+ // For an obvious common case perf
+ case UriComponents.AbsoluteUri: //Scheme|UserInfo|Host|Port|Path|Query|Fragment,
+ if (m_Info.Offset.Scheme == 0 && m_Info.Offset.End == m_String.Length)
+ return m_String;
+
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.End - m_Info.Offset.Scheme);
+
+ // For Uri.Equals() and HttpWebRequest through a proxy perf
+ case UriComponents.HttpRequestUrl: //Scheme|Host|Port|Path|Query,
+ if (InFact(Flags.HasUserInfo)) {
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.User - m_Info.Offset.Scheme)
+ + m_String.Substring(m_Info.Offset.Host, m_Info.Offset.Fragment - m_Info.Offset.Host);
+ }
+ if (m_Info.Offset.Scheme == 0 && m_Info.Offset.Fragment == m_String.Length)
+ return m_String;
+
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.Fragment - m_Info.Offset.Scheme);
+
+ // For CombineUri() perf
+ case UriComponents.SchemeAndServer|UriComponents.UserInfo:
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.Path - m_Info.Offset.Scheme);
+
+ // For Cache perf
+ case (UriComponents.AbsoluteUri & ~UriComponents.Fragment):
+ if (m_Info.Offset.Scheme == 0 && m_Info.Offset.Fragment == m_String.Length)
+ return m_String;
+
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.Fragment - m_Info.Offset.Scheme);
+
+
+ // Strip scheme delimiter if was not requested
+ case UriComponents.Scheme:
+ if (uriParts != UriComponents.Scheme)
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.User - m_Info.Offset.Scheme);
+
+ return m_Syntax.SchemeName;
+
+ // KeepDelimiter makes no sense for this component
+ case UriComponents.Host:
+ ushort idx = m_Info.Offset.Path;
+ if (InFact(Flags.NotDefaultPort|Flags.PortNotCanonical)) {
+ //Means we do have ':' after the host
+ while (m_String[--idx] != ':')
+ ;
+ }
+ return (idx - m_Info.Offset.Host == 0)? string.Empty: m_String.Substring(m_Info.Offset.Host,
+ idx - m_Info.Offset.Host);
+
+ case UriComponents.Path:
+
+ // Strip the leading '/' for a hierarchical URI if no delimiter was requested
+ if (uriParts == UriComponents.Path && InFact(Flags.AuthorityFound) &&
+ m_Info.Offset.End > m_Info.Offset.Path && m_String[m_Info.Offset.Path] == '/')
+ delimiterAwareIdx = (ushort)(m_Info.Offset.Path + 1);
+ else
+ delimiterAwareIdx = m_Info.Offset.Path;
+
+ if (delimiterAwareIdx >= m_Info.Offset.Query)
+ return string.Empty;
+
+
+ return m_String.Substring(delimiterAwareIdx, m_Info.Offset.Query - delimiterAwareIdx);
+
+ case UriComponents.Query:
+ // Strip the '?' if no delimiter was requested
+ if (uriParts == UriComponents.Query)
+ delimiterAwareIdx = (ushort)(m_Info.Offset.Query + 1);
+ else
+ delimiterAwareIdx = m_Info.Offset.Query;
+
+ if (delimiterAwareIdx >= m_Info.Offset.Fragment)
+ return string.Empty;
+
+ return m_String.Substring(delimiterAwareIdx, m_Info.Offset.Fragment - delimiterAwareIdx);
+
+ case UriComponents.Fragment:
+ // Strip the '#' if no delimiter was requested
+ if (uriParts == UriComponents.Fragment)
+ delimiterAwareIdx = (ushort)(m_Info.Offset.Fragment + 1);
+ else
+ delimiterAwareIdx = m_Info.Offset.Fragment;
+
+ if (delimiterAwareIdx >= m_Info.Offset.End)
+ return string.Empty;
+
+ return m_String.Substring(delimiterAwareIdx, m_Info.Offset.End - delimiterAwareIdx);
+
+ case UriComponents.UserInfo | UriComponents.Host | UriComponents.Port:
+ return (m_Info.Offset.Path - m_Info.Offset.User == 0) ? string.Empty :
+ m_String.Substring(m_Info.Offset.User, m_Info.Offset.Path - m_Info.Offset.User);
+
+ case UriComponents.StrongAuthority: //UserInfo|Host|StrongPort
+ if (InFact(Flags.NotDefaultPort) || m_Syntax.DefaultPort == UriParser.NoDefaultPort)
+ goto case UriComponents.UserInfo | UriComponents.Host | UriComponents.Port;
+
+ return m_String.Substring(m_Info.Offset.User, m_Info.Offset.Path - m_Info.Offset.User)
+ + ':' + m_Info.Offset.PortValue.ToString(CultureInfo.InvariantCulture);
+
+ case UriComponents.PathAndQuery: //Path|Query,
+ return m_String.Substring(m_Info.Offset.Path, m_Info.Offset.Fragment - m_Info.Offset.Path);
+
+ case UriComponents.HttpRequestUrl|UriComponents.Fragment: //Scheme|Host|Port|Path|Query|Fragment,
+ if (InFact(Flags.HasUserInfo)) {
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.User - m_Info.Offset.Scheme)
+ + m_String.Substring(m_Info.Offset.Host, m_Info.Offset.End - m_Info.Offset.Host);
+ }
+ if (m_Info.Offset.Scheme == 0 && m_Info.Offset.End == m_String.Length)
+ return m_String;
+
+ return m_String.Substring(m_Info.Offset.Scheme, m_Info.Offset.End - m_Info.Offset.Scheme);
+
+ case UriComponents.PathAndQuery|UriComponents.Fragment: //LocalUrl|Fragment
+ return m_String.Substring(m_Info.Offset.Path, m_Info.Offset.End - m_Info.Offset.Path);
+
+ case UriComponents.UserInfo:
+ // Strip the '@' if no delimiter was requested
+
+ if (NotAny(Flags.HasUserInfo))
+ return string.Empty;
+
+ if (uriParts == UriComponents.UserInfo)
+ delimiterAwareIdx = (ushort)(m_Info.Offset.Host - 1);
+ else
+ delimiterAwareIdx = m_Info.Offset.Host;
+
+ if (m_Info.Offset.User >= delimiterAwareIdx)
+ return string.Empty;
+
+ return m_String.Substring(m_Info.Offset.User, delimiterAwareIdx - m_Info.Offset.User);
+
+ default:
+ return null;
+ }
+ }
+
+
+ //
+ //This method does:
+ // - Creates m_Info member
+ // - checks all componenets up to path on their canonical representation
+ // - continues parsing starting the path position
+ // - Sets the offsets of remaining components
+ // - Sets the Canonicalization flags if applied
+ // - Will NOT create MoreInfo members
+ //
+ private unsafe void ParseRemaining() {
+
+ // ensure we parsed up to the path
+ EnsureUriInfo();
+
+ Flags cF = Flags.Zero;
+
+ if (UserDrivenParsing)
+ goto Done;
+
+ // Do we have to continue building Iri'zed string from original string
+ bool buildIriStringFromPath = m_iriParsing && ((m_Flags & Flags.HasUnicode) != 0) && ((m_Flags & Flags.RestUnicodeNormalized) == 0);
+
+ ushort origIdx; // stores index to switched original string
+ ushort idx = m_Info.Offset.Scheme;
+ ushort length = (ushort)m_String.Length;
+ Check result = Check.None;
+ UriSyntaxFlags syntaxFlags = m_Syntax.Flags; // perf
+
+ // Multithreading!
+ // m_Info.Offset values may be parsed twice but we lock only on m_Flags update.
+
+ fixed (char* str = m_String){
+ // Cut trailing spaces in m_String
+ if (length > idx && IsLWS(str[length - 1]))
+ {
+ --length;
+ while (length != idx && IsLWS(str[--length]))
+ ;
+ ++length;
+ }
+
+ if (IsImplicitFile){
+ cF |= Flags.SchemeNotCanonical;
+ }
+ else {
+ ushort i = 0;
+ ushort syntaxLength = (ushort)m_Syntax.SchemeName.Length;
+ for (; i < syntaxLength; ++i)
+ {
+ if (m_Syntax.SchemeName[i] != str[idx + i])
+ cF |= Flags.SchemeNotCanonical;
+ }
+ // For an authority Uri only // after the scheme would be canonical
+ // (compatibility bug http:\\host)
+ if (((m_Flags & Flags.AuthorityFound) != 0) && (idx + i + 3 >= length || str[idx + i + 1] != '/' ||
+ str[idx + i + 2] != '/'))
+ {
+ cF |= Flags.SchemeNotCanonical;
+ }
+ }
+
+
+ //Check the form of the user info
+ if ((m_Flags & Flags.HasUserInfo) != 0){
+ idx = m_Info.Offset.User;
+ result = CheckCanonical(str, ref idx, m_Info.Offset.Host, '@');
+ if ((result & Check.DisplayCanonical) == 0){
+ cF |= Flags.UserNotCanonical;
+ }
+ if ((result & (Check.EscapedCanonical | Check.BackslashInPath)) != Check.EscapedCanonical){
+ cF |= Flags.E_UserNotCanonical;
+ }
+ if (m_iriParsing && ((result & (Check.DisplayCanonical | Check.EscapedCanonical | Check.BackslashInPath
+ | Check.FoundNonAscii | Check.NotIriCanonical))
+ == (Check.DisplayCanonical | Check.FoundNonAscii))){
+ cF |= Flags.UserIriCanonical;
+ }
+ }
+ }
+ //
+ // Delay canonical Host checking to avoid creation of a host string
+ // Will do that on demand.
+ //
+
+
+ //
+ //We have already checked on the port in EnsureUriInfo() that calls CreateUriInfo
+ //
+
+ //
+ // Parsing the Path if any
+ //
+
+ // For iri parsing if we found unicode the idx has offset into m_orig string..
+ // so restart parsing from there and make m_Info.Offset.Path as m_string.length
+
+ idx = m_Info.Offset.Path;
+ origIdx = m_Info.Offset.Path;
+
+ //Some uris do not have a query
+ // When '?' is passed as delimiter, then it's special case
+ // so both '?' and '#' will work as delimiters
+ if (buildIriStringFromPath){
+
+ // Dos paths have no host. Other schemes cleared/set m_String with host information in PrivateParseMinimal.
+ if (IsDosPath) {
+ if (IsImplicitFile) {
+ m_String = String.Empty;
+ }
+ else {
+ m_String = m_Syntax.SchemeName + SchemeDelimiter;
+ }
+ }
+
+ m_Info.Offset.Path = (ushort)m_String.Length;
+ idx = m_Info.Offset.Path;
+
+ ushort offset = origIdx;
+ if (IsImplicitFile || ((syntaxFlags & (UriSyntaxFlags.MayHaveQuery | UriSyntaxFlags.MayHaveFragment)) == 0)){
+ FindEndOfComponent(m_originalUnicodeString, ref origIdx, (ushort)m_originalUnicodeString.Length, c_DummyChar);
+ }
+ else{
+ FindEndOfComponent(m_originalUnicodeString, ref origIdx, (ushort)m_originalUnicodeString.Length,
+ (m_Syntax.InFact(UriSyntaxFlags.MayHaveQuery) ? '?' : m_Syntax.InFact(UriSyntaxFlags.MayHaveFragment) ? '#' : c_EOL));
+ }
+
+ // Correctly escape unescape
+ string escapedPath = EscapeUnescapeIri(m_originalUnicodeString, offset, origIdx, UriComponents.Path);
+
+ // Normalize path
+ try{
+ if (UriParser.ShouldUseLegacyV2Quirks)
+ m_String += escapedPath.Normalize(NormalizationForm.FormC);
+ else
+ m_String += escapedPath;
+ }
+ catch (ArgumentException){
+ UriFormatException e = GetException(ParsingError.BadFormat);
+ throw e;
+ }
+
+ if (!ServicePointManager.AllowAllUriEncodingExpansion && m_String.Length > ushort.MaxValue){
+ UriFormatException e = GetException(ParsingError.SizeLimit);
+ throw e;
+ }
+
+ length = (ushort)m_String.Length;
+ }
+
+ fixed (char* str = m_String){
+ if (IsImplicitFile || ((syntaxFlags & (UriSyntaxFlags.MayHaveQuery | UriSyntaxFlags.MayHaveFragment)) == 0)){
+ result = CheckCanonical(str, ref idx, length, c_DummyChar);
+ }
+ else {
+ result = CheckCanonical(str, ref idx, length, (((syntaxFlags & UriSyntaxFlags.MayHaveQuery) != 0)
+ ? '?' : m_Syntax.InFact(UriSyntaxFlags.MayHaveFragment) ? '#' : c_EOL));
+ }
+
+ // ATTN:
+ // This may render problems for unknown schemes, but in general for an authority based Uri
+ // (that has slashes) a path should start with "/"
+ // This becomes more interesting knowning how a file uri is used in "file://c:/path"
+ // It will be converted to file:///c:/path
+ //
+ // However, even more interesting is that vsmacros://c:\path will not add the third slash in the _canoical_ case
+ // (vsmacros inventors have violated the RFC)
+ //
+ // We use special syntax flag to check if the path is rooted, i.e. has a first slash
+ //
+ if (((m_Flags & Flags.AuthorityFound) != 0) && ((syntaxFlags & UriSyntaxFlags.PathIsRooted) != 0)
+ && (m_Info.Offset.Path == length || (str[m_Info.Offset.Path] != '/' && str[m_Info.Offset.Path] != '\\'))){
+ cF |= Flags.FirstSlashAbsent;
+ }
+ }
+ // Check the need for compression or backslashes conversion
+ // we included IsDosPath since it may come with other than FILE uri, for ex. scheme://C:\path
+ // (This is very unfortunate that the original design has included that feature)
+ bool nonCanonical = false;
+ if (IsDosPath || (((m_Flags & Flags.AuthorityFound) != 0) &&
+ (((syntaxFlags & (UriSyntaxFlags.CompressPath | UriSyntaxFlags.ConvertPathSlashes)) != 0) ||
+ m_Syntax.InFact(UriSyntaxFlags.UnEscapeDotsAndSlashes))))
+ {
+ if (((result & Check.DotSlashEscaped) != 0) && m_Syntax.InFact(UriSyntaxFlags.UnEscapeDotsAndSlashes))
+ {
+ cF |= (Flags.E_PathNotCanonical | Flags.PathNotCanonical);
+ nonCanonical = true;
+ }
+
+ if (((syntaxFlags & (UriSyntaxFlags.ConvertPathSlashes)) != 0) && (result & Check.BackslashInPath) != 0){
+ cF |= (Flags.E_PathNotCanonical | Flags.PathNotCanonical);
+ nonCanonical = true;
+ }
+
+ if (((syntaxFlags & (UriSyntaxFlags.CompressPath)) != 0) && ((cF & Flags.E_PathNotCanonical) != 0 ||
+ (result & Check.DotSlashAttn) != 0))
+ {
+ cF |= Flags.ShouldBeCompressed;
+ }
+
+ if ((result & Check.BackslashInPath) != 0)
+ cF |= Flags.BackslashInPath;
+
+ }
+ else if ((result & Check.BackslashInPath) != 0){
+ // for a "generic" path '\' should be escaped
+ cF |= Flags.E_PathNotCanonical;
+ nonCanonical = true;
+ }
+
+ if ((result & Check.DisplayCanonical) == 0){
+ // For implicit file the user string is usually in perfect display format,
+ // Hence, ignoring complains from CheckCanonical()
+ //
+
+ if (((m_Flags & Flags.ImplicitFile) == 0) || ((m_Flags & Flags.UserEscaped) != 0) ||
+ (result & Check.ReservedFound) != 0) {
+ //means it's found as escaped or has unescaped Reserved Characters
+ cF |= Flags.PathNotCanonical;
+ nonCanonical = true;
+ }
+ }
+
+ if (((m_Flags & Flags.ImplicitFile) != 0) && (result & (Check.ReservedFound | Check.EscapedCanonical)) != 0){
+ // need to escape reserved chars or re-escape '%' if an "escaped sequence" was found
+ result &= ~Check.EscapedCanonical;
+ }
+
+ if ((result & Check.EscapedCanonical) == 0){
+ //means it's found as not completely escaped
+ cF |= Flags.E_PathNotCanonical;
+ }
+
+ if (m_iriParsing && !nonCanonical & ((result & (Check.DisplayCanonical | Check.EscapedCanonical
+ | Check.FoundNonAscii | Check.NotIriCanonical))
+ == (Check.DisplayCanonical | Check.FoundNonAscii))){
+ cF |= Flags.PathIriCanonical;
+ }
+
+ //
+ //Now we've got to parse the Query if any. Note that Query requires the presence of '?'
+ //
+ if (buildIriStringFromPath){
+ ushort offset = origIdx;
+
+ if (origIdx < m_originalUnicodeString.Length && m_originalUnicodeString[origIdx] == '?'){
+ ++origIdx; // This is to exclude first '?' character from checking
+ FindEndOfComponent(m_originalUnicodeString, ref origIdx, (ushort)m_originalUnicodeString.Length, ((syntaxFlags &(UriSyntaxFlags.MayHaveFragment)) != 0) ? '#' : c_EOL);
+
+ // Correctly escape unescape
+ string escapedPath = EscapeUnescapeIri(m_originalUnicodeString, offset, origIdx, UriComponents.Query);
+
+ // Normalize path
+ try{
+ if (UriParser.ShouldUseLegacyV2Quirks)
+ m_String += escapedPath.Normalize(NormalizationForm.FormC);
+ else
+ m_String += escapedPath;
+ }
+ catch (ArgumentException){
+ UriFormatException e = GetException(ParsingError.BadFormat);
+ throw e;
+ }
+
+ if (!ServicePointManager.AllowAllUriEncodingExpansion && m_String.Length > ushort.MaxValue){
+ UriFormatException e = GetException(ParsingError.SizeLimit);
+ throw e;
+ }
+
+ length = (ushort)m_String.Length;
+ }
+ }
+
+ m_Info.Offset.Query = idx;
+
+ fixed (char* str = m_String){
+ if (idx < length && str[idx] == '?'){
+ ++idx; // This is to exclude first '?' character from checking
+ result = CheckCanonical(str, ref idx, length, ((syntaxFlags & (UriSyntaxFlags.MayHaveFragment)) != 0)
+ ? '#' : c_EOL);
+ if ((result & Check.DisplayCanonical) == 0){
+ cF |= Flags.QueryNotCanonical;
+ }
+
+ if ((result & (Check.EscapedCanonical | Check.BackslashInPath)) != Check.EscapedCanonical){
+ cF |= Flags.E_QueryNotCanonical;
+ }
+
+ if (m_iriParsing && ((result & (Check.DisplayCanonical | Check.EscapedCanonical | Check.BackslashInPath
+ | Check.FoundNonAscii | Check.NotIriCanonical))
+ == (Check.DisplayCanonical | Check.FoundNonAscii))){
+ cF |= Flags.QueryIriCanonical;
+ }
+
+ }
+ }
+ //
+ //Now we've got to parse the Fragment if any. Note that Fragment requires the presense of '#'
+ //
+ if (buildIriStringFromPath){
+ ushort offset = origIdx;
+
+ if (origIdx < m_originalUnicodeString.Length && m_originalUnicodeString[origIdx] == '#')
+ {
+ ++origIdx; // This is to exclude first '#' character from checking
+ FindEndOfComponent(m_originalUnicodeString, ref origIdx, (ushort)m_originalUnicodeString.Length, c_EOL);
+
+ // Correctly escape unescape
+ string escapedPath = EscapeUnescapeIri(m_originalUnicodeString, offset, origIdx, UriComponents.Fragment);
+
+ // Normalize path
+ try{
+ if (UriParser.ShouldUseLegacyV2Quirks)
+ m_String += escapedPath.Normalize(NormalizationForm.FormC);
+ else
+ m_String += escapedPath;
+ }
+ catch (ArgumentException){
+ UriFormatException e = GetException(ParsingError.BadFormat);
+ throw e;
+ }
+
+ if (!ServicePointManager.AllowAllUriEncodingExpansion && m_String.Length > ushort.MaxValue){
+ UriFormatException e = GetException(ParsingError.SizeLimit);
+ throw e;
+ }
+
+ length = (ushort)m_String.Length;
+ }
+ }
+
+ m_Info.Offset.Fragment = idx;
+
+ fixed (char* str = m_String){
+ if (idx < length && str[idx] == '#'){
+ ++idx; // This is to exclude first '#' character from checking
+ //We don't using c_DummyChar since want to allow '?' and '#' as unescaped
+ result = CheckCanonical(str, ref idx, length, c_EOL);
+ if ((result & Check.DisplayCanonical) == 0){
+ cF |= Flags.FragmentNotCanonical;
+ }
+
+ if ((result & (Check.EscapedCanonical | Check.BackslashInPath)) != Check.EscapedCanonical){
+ cF |= Flags.E_FragmentNotCanonical;
+ }
+
+ if (m_iriParsing && ((result & (Check.DisplayCanonical | Check.EscapedCanonical | Check.BackslashInPath
+ | Check.FoundNonAscii | Check.NotIriCanonical))
+ == (Check.DisplayCanonical | Check.FoundNonAscii))){
+ cF |= Flags.FragmentIriCanonical;
+ }
+
+ }
+ }
+ m_Info.Offset.End = idx;
+ Done:
+
+ cF |= Flags.AllUriInfoSet;
+ lock (m_Info)
+ {
+ m_Flags |= cF;
+ }
+ m_Flags |= Flags.RestUnicodeNormalized;
+ }
+
+ //
+ //
+ // verifies the syntax of the scheme part
+ // Checks on implicit File: scheme due to simple Dos/Unc path passed
+ // returns the start of the next component position
+ // throws UriFormatException if invalid scheme
+ //
+ unsafe static private ushort ParseSchemeCheckImplicitFile(char *uriString, ushort length,
+ ref ParsingError err, ref Flags flags, ref UriParser syntax) {
+
+ ushort idx = 0;
+
+ //skip whitespaces
+ while(idx < length && IsLWS(uriString[idx])) {
+ ++idx;
+ }
+
+ // sets the recognizer for well known registered schemes
+ // file, ftp, http, https, uuid, etc
+ // Note that we don't support one-letter schemes that will be put into a DOS path bucket
+
+ //
+ ushort end = idx;
+ while (end < length && uriString[end] != ':') {
+ ++end;
+ }
+
+ // NB: On 64-bits we will use less optimized code from CheckSchemeSyntax()
+ //
+ if (IntPtr.Size == 4) {
+ // long = 4chars: The minimal size of a known scheme is 2 + ':'
+ if (end != length && end >= idx+2 &&
+ CheckKnownSchemes((long*) (uriString + idx), (ushort)(end-idx), ref syntax)) {
+ return (ushort)(end+1);
+ }
+ }
+
+ //NB: A string must have at least 3 characters and at least 1 before ':'
+ if (idx+2 >= length || end == idx) {
+ err = ParsingError.BadFormat;
+ return 0;
+ }
+
+ //Check for supported special cases like a DOS file path OR a UNC share path
+ //NB: A string may not have ':' if this is a UNC path
+ {
+ char c;
+ if ((c=uriString[idx+1]) == ':' || c == '|') {
+#if !PLATFORM_UNIX
+ //DOS-like path?
+ if (IsAsciiLetter(uriString[idx])) {
+ if((c=uriString[idx+2]) == '\\' || c== '/') {
+ flags |= (Flags.DosPath|Flags.ImplicitFile|Flags.AuthorityFound);
+ syntax = UriParser.FileUri;
+ return idx;
+ }
+ err = ParsingError.MustRootedPath;
+ return 0;
+ }
+#endif // !PLATFORM_UNIX
+ if (c == ':')
+ err = ParsingError.BadScheme;
+ else
+ err = ParsingError.BadFormat;
+ return 0;
+ }
+#if !PLATFORM_UNIX
+ else if ((c=uriString[idx]) == '/' || c == '\\') {
+ //UNC share ?
+ if ((c=uriString[idx+1]) == '\\' || c == '/') {
+ flags |= (Flags.UncPath|Flags.ImplicitFile|Flags.AuthorityFound);
+ syntax = UriParser.FileUri;
+ idx+=2;
+ // V1.1 compat this will simply eat any slashes prepended to a UNC path
+ while (idx < length && ((c=uriString[idx]) == '/' || c == '\\'))
+ ++idx;
+
+ return idx;
+ }
+ err = ParsingError.BadFormat;
+ return 0;
+ }
+#else
+ else if (uriString[idx] == '/') {
+ // On UNIX an implicit file has the form /<path> or scheme:///<path>
+ if (idx == 0 || uriString[idx-1] != ':' ) {
+ // No scheme present; implicit /<path> starting at idx
+ flags |= (Flags.ImplicitFile|Flags.AuthorityFound);
+ syntax = UriParser.FileUri;
+ return idx;
+ } else if (uriString[idx+1] == '/' && uriString[idx+2] == '/') {
+ // scheme present; rooted path starts at idx + 2
+ flags |= (Flags.ImplicitFile|Flags.AuthorityFound);
+ syntax = UriParser.FileUri;
+ idx+=2;
+ return idx;
+ }
+ }
+ else if (uriString[idx] == '\\') {
+ err = ParsingError.BadFormat;
+ return 0;
+ }
+#endif // !PLATFORM_UNIX
+ }
+
+ if (end == length) {
+ err = ParsingError.BadFormat;
+ return 0;
+ }
+
+ // Here could be a possibly valid, and not well-known scheme
+ // Finds the scheme delimiter
+ // we don;t work with the schemes names > c_MaxUriSchemeName (should be ~1k)
+ if ((end-idx) > c_MaxUriSchemeName) {
+ err = ParsingError.SchemeLimit;
+ return 0;
+ }
+
+ //Check the syntax, canonicalize and avoid a GC call
+ char* schemePtr = stackalloc char[end-idx];
+ for (length = 0; idx < end; ++idx) {
+ schemePtr[length++] = uriString[idx];
+ }
+ err = CheckSchemeSyntax(schemePtr, length, ref syntax);
+ if (err != ParsingError.None) {
+ return 0;
+ }
+ return (ushort)(end+1);
+ }
+ //
+ // Quickly parses well known schemes.
+ // nChars does not include the last ':'. Assuming there is one at the end of passed buffer
+ unsafe static private bool CheckKnownSchemes(long *lptr, ushort nChars, ref UriParser syntax) {
+ //NOTE beware of too short input buffers!
+
+ const long _HTTP_Mask0 = 'h'|('t'<<16)|((long)'t'<<32)|((long)'p'<<48);
+ const char _HTTPS_Mask1 = 's';
+ const int _WS_Mask = 'w'|('s'<<16);
+ const long _WSS_Mask = 'w'|('s'<<16)|((long)'s'<<32)|((long)':'<<48);
+ const long _FTP_Mask = 'f'|('t'<<16)|((long)'p'<<32)|((long)':'<<48);
+ const long _FILE_Mask0 = 'f'|('i'<<16)|((long)'l'<<32)|((long)'e'<<48);
+ const long _GOPHER_Mask0 = 'g'|('o'<<16)|((long)'p'<<32)|((long)'h'<<48);
+ const int _GOPHER_Mask1 = 'e'|('r'<<16);
+ const long _MAILTO_Mask0 = 'm'|('a'<<16)|((long)'i'<<32)|((long)'l'<<48);
+ const int _MAILTO_Mask1 = 't'|('o'<<16);
+ const long _NEWS_Mask0 = 'n'|('e'<<16)|((long)'w'<<32)|((long)'s'<<48);
+ const long _NNTP_Mask0 = 'n'|('n'<<16)|((long)'t'<<32)|((long)'p'<<48);
+ const long _UUID_Mask0 = 'u'|('u'<<16)|((long)'i'<<32)|((long)'d'<<48);
+
+ const long _TELNET_Mask0 = 't'|('e'<<16)|((long)'l'<<32)|((long)'n'<<48);
+ const int _TELNET_Mask1 = 'e'|('t'<<16);
+
+ const long _NETXXX_Mask0 = 'n'|('e'<<16)|((long)'t'<<32)|((long)'.'<<48);
+ const long _NETTCP_Mask1 = 't'|('c'<<16)|((long)'p'<<32)|((long)':'<<48);
+ const long _NETPIPE_Mask1 = 'p'|('i'<<16)|((long)'p'<<32)|((long)'e'<<48);
+
+ const long _LDAP_Mask0 = 'l'|('d'<<16)|((long)'a'<<32)|((long)'p'<<48);
+
+
+ const long _LOWERCASE_Mask = 0x0020002000200020L;
+ const int _INT_LOWERCASE_Mask = 0x00200020;
+
+ if (nChars == 2) {
+ // This is the only known scheme of length 2
+ if ((((int)*lptr) | _INT_LOWERCASE_Mask) == _WS_Mask) {
+ syntax = UriParser.WsUri;
+ return true;
+ }
+ return false;
+ }
+
+ //Map to a known scheme if possible
+ //upgrade 4 letters to ASCII lower case, keep a false case to stay false
+ switch (*lptr | _LOWERCASE_Mask) {
+ case _HTTP_Mask0:
+ if (nChars == 4) {
+ syntax = UriParser.HttpUri;
+ return true;
+ }
+ if (nChars == 5 && ((*(char*)(lptr+1))|0x20) == _HTTPS_Mask1) {
+ syntax = UriParser.HttpsUri;
+ return true;
+ }
+ break;
+ case _WSS_Mask:
+ if (nChars == 3)
+ {
+ syntax = UriParser.WssUri;
+ return true;
+ }
+ break;
+ case _FILE_Mask0:
+ if (nChars == 4) {
+ syntax = UriParser.FileUri;
+ return true;
+ }
+ break;
+ case _FTP_Mask:
+ if (nChars == 3) {
+ syntax = UriParser.FtpUri;
+ return true;
+ }
+ break;
+
+ case _NEWS_Mask0:
+ if (nChars == 4) {
+ syntax = UriParser.NewsUri;
+ return true;
+ }
+ break;
+
+ case _NNTP_Mask0:
+ if (nChars == 4) {
+ syntax = UriParser.NntpUri;
+ return true;
+ }
+ break;
+
+ case _UUID_Mask0:
+ if (nChars == 4) {
+ syntax = UriParser.UuidUri;
+ return true;
+ }
+ break;
+
+ case _GOPHER_Mask0:
+ if (nChars == 6 && (*(int*)(lptr+1)|_INT_LOWERCASE_Mask) == _GOPHER_Mask1) {
+ syntax = UriParser.GopherUri;
+ return true;
+ }
+ break;
+ case _MAILTO_Mask0:
+ if (nChars == 6 && (*(int*)(lptr+1)|_INT_LOWERCASE_Mask) == _MAILTO_Mask1) {
+ syntax = UriParser.MailToUri;
+ return true;
+ }
+ break;
+
+ case _TELNET_Mask0:
+ if (nChars == 6 && (*(int*)(lptr+1)|_INT_LOWERCASE_Mask) == _TELNET_Mask1) {
+ syntax = UriParser.TelnetUri;
+ return true;
+ }
+ break;
+
+ case _NETXXX_Mask0:
+ if (nChars == 8 && (*(lptr+1)|_LOWERCASE_Mask) == _NETPIPE_Mask1) {
+ syntax = UriParser.NetPipeUri;
+ return true;
+ }
+ else if (nChars == 7 && (*(lptr+1)|_LOWERCASE_Mask) == _NETTCP_Mask1) {
+ syntax = UriParser.NetTcpUri;
+ return true;
+ }
+ break;
+
+ case _LDAP_Mask0:
+ if (nChars == 4) {
+ syntax = UriParser.LdapUri;
+ return true;
+ }
+ break;
+ default: break;
+ }
+ return false;
+ }
+
+ //
+ //
+ // This will check whether a scheme string follows the rules
+ //
+ unsafe static private ParsingError CheckSchemeSyntax(char* ptr, ushort length, ref UriParser syntax) {
+ //First character must be an alpha
+ {
+ char c = *ptr;
+ if (c >= 'a' && c <= 'z') {
+ ;
+ } else if (c >= 'A' && c <= 'Z') {
+ *ptr = (char)(c | 0x20); //make it lowercase
+ } else {
+ return ParsingError.BadScheme;
+ }
+ }
+
+ for (ushort i = 1; i < length; ++i) {
+ char c = ptr[i];
+ if (c >= 'a' && c <= 'z') {
+ ;
+ } else if (c >= 'A' && c <= 'Z') {
+ ptr[i] = (char)(c | 0x20); //make it lowercase
+ } else if (c >= '0' && c <= '9') {
+ ;
+ } else if (c == '+' || c == '-' || c == '.') {
+ ;
+ } else {
+ return ParsingError.BadScheme;
+ }
+ }
+ // A not well-known scheme, needs string creation
+ // Note it is already in the lower case as required.
+ string str = new string(ptr, 0, length);
+ syntax = UriParser.FindOrFetchAsUnknownV1Syntax(str);
+ return ParsingError.None;
+ }
+ //
+ //
+ // Checks the syntax of an authority component. It may also get a userInfo if present
+ // Returns an error if no/mailformed authority found
+ // Does not NOT touch m_Info
+ // Returns position of the Path component
+ //
+ // Must be called in the ctor only
+ private unsafe ushort CheckAuthorityHelper( char* pString, ushort idx, ushort length,
+ ref ParsingError err, ref Flags flags, UriParser syntax, ref string newHost )
+ {
+ int end = length;
+ char ch;
+ int startInput = idx;
+ ushort start = idx;
+ newHost = null;
+ bool justNormalized = false;
+ bool iriParsing = (s_IriParsing && IriParsingStatic(syntax)); // perf
+ bool hasUnicode = ((flags & Flags.HasUnicode) != 0); // perf
+ bool hostNotUnicodeNormalized = ((flags & Flags.HostUnicodeNormalized) == 0); // perf
+ UriSyntaxFlags syntaxFlags = syntax.Flags;
+
+ // need to build new Iri'zed string
+ if (hasUnicode && iriParsing && hostNotUnicodeNormalized){
+ newHost = m_originalUnicodeString.Substring(0, startInput);
+ }
+
+ //Special case is an empty authority
+ if (idx == length || ((ch=pString[idx]) == '/' || (ch == '\\' && StaticIsFile(syntax)) || ch == '#' || ch == '?'))
+ {
+ if (syntax.InFact(UriSyntaxFlags.AllowEmptyHost))
+ {
+ flags &= ~Flags.UncPath; //UNC cannot have an empty hostname
+ if (StaticInFact(flags, Flags.ImplicitFile))
+ err = ParsingError.BadHostName;
+ else
+ flags |= Flags.BasicHostType;
+ }
+ else
+ err = ParsingError.BadHostName;
+
+ if (hasUnicode && iriParsing && hostNotUnicodeNormalized){
+ flags |= Flags.HostUnicodeNormalized;// no host
+ }
+
+ return idx;
+ }
+
+//#if PLATFORM_UNIX
+// if (StaticIsFile(syntax) && ch != '/') {
+// // On UNIX a file URL may only have an empty authority
+// err = ParsingError.NonEmptyHost;
+// return idx;
+// }
+//#endif // PLATFORM_UNIX
+
+ string userInfoString = null;
+ // Attempt to parse user info first
+
+ if ((syntaxFlags & UriSyntaxFlags.MayHaveUserInfo) != 0)
+ {
+ for (; start < end; ++start)
+ {
+ if (start == end - 1 || pString[start] == '?' || pString[start] == '#' || pString[start] == '\\' ||
+ pString[start] == '/')
+ {
+ start = idx;
+ break;
+ }
+ else if (pString[start] == '@')
+ {
+ flags |= Flags.HasUserInfo;
+
+ // Iri'ze userinfo
+ if (iriParsing || (s_IdnScope != UriIdnScope.None)){
+ if (iriParsing && hasUnicode && hostNotUnicodeNormalized){
+ // Normalize user info
+ userInfoString = IriHelper.EscapeUnescapeIri(pString, startInput, start + 1, UriComponents.UserInfo);
+ try{
+ if (UriParser.ShouldUseLegacyV2Quirks)
+ userInfoString = userInfoString.Normalize(NormalizationForm.FormC);
+ }
+ catch (ArgumentException){
+ err = ParsingError.BadFormat;
+ return idx;
+ }
+
+ newHost += userInfoString;
+
+ if (!ServicePointManager.AllowAllUriEncodingExpansion && newHost.Length > ushort.MaxValue){
+ err = ParsingError.SizeLimit;
+ return idx;
+ }
+ }
+ else{
+ userInfoString = new string(pString, startInput, start - startInput + 1);
+ }
+ }
+ ++start;
+ ch = pString[start];
+ break;
+ }
+ }
+ }
+
+ // DNS name only optimization
+ // Fo an overriden parsing the optimization is suppressed since hostname can be changed to anything
+ bool dnsNotCanonical = ((syntaxFlags & UriSyntaxFlags.SimpleUserSyntax) == 0);
+
+ if (ch == '[' && syntax.InFact(UriSyntaxFlags.AllowIPv6Host)
+ && IPv6AddressHelper.IsValid(pString, (int)start+1, ref end))
+ {
+ flags |= Flags.IPv6HostType;
+
+ // Force load config here if config not loaded earlier since we handle IsWellFormed differently
+ // for IPv6 if the iri parsing flag is on or off
+ if (!s_ConfigInitialized) {
+ InitializeUriConfig();
+ m_iriParsing = (s_IriParsing && IriParsingStatic(syntax));
+ }
+
+ if (hasUnicode && iriParsing && hostNotUnicodeNormalized) {
+ newHost += new string(pString, start, end - start);
+ flags |= Flags.HostUnicodeNormalized;
+ justNormalized = true;
+ }
+ }
+ else if ( ch <= '9' && ch >= '0' && syntax.InFact(UriSyntaxFlags.AllowIPv4Host) &&
+ IPv4AddressHelper.IsValid(pString, (int) start, ref end, false, StaticNotAny(flags, Flags.ImplicitFile), syntax.InFact(UriSyntaxFlags.V1_UnknownUri)))
+ {
+ flags |= Flags.IPv4HostType;
+
+ if (hasUnicode && iriParsing && hostNotUnicodeNormalized){
+ newHost += new string(pString, start, end - start);
+ flags |= Flags.HostUnicodeNormalized;
+ justNormalized = true;
+ }
+ }
+ else if (((syntaxFlags & UriSyntaxFlags.AllowDnsHost)!= 0) && !iriParsing &&
+ DomainNameHelper.IsValid(pString, start, ref end, ref dnsNotCanonical, StaticNotAny(flags, Flags.ImplicitFile)))
+ {
+ // comes here if there are only ascii chars in host with original parsing and no Iri
+
+ flags |= Flags.DnsHostType;
+ if (!dnsNotCanonical) {
+ flags |= Flags.CanonicalDnsHost;
+ }
+
+ if ((s_IdnScope != UriIdnScope.None)){
+ // check if intranet
+ //
+ if ((s_IdnScope == UriIdnScope.AllExceptIntranet) && IsIntranet(new string(pString, 0, end))){
+ flags |= Flags.IntranetUri;
+ }
+ if (AllowIdnStatic(syntax, flags)){
+ bool allAscii = true;
+ bool atLeastOneIdn = false;
+
+ string idnValue = DomainNameHelper.UnicodeEquivalent(pString, start, end, ref allAscii, ref atLeastOneIdn);
+
+ // did we find at least one valid idn
+ if (atLeastOneIdn)
+ {
+ // need to switch string here since we didnt know before hand there there was an idn host
+ if (StaticNotAny(flags, Flags.HasUnicode))
+ m_originalUnicodeString = m_String; // lazily switching strings
+ flags |= Flags.IdnHost;
+
+ // need to build string for this special scenario
+ newHost = m_originalUnicodeString.Substring(0, startInput) + userInfoString + idnValue;
+ flags |= Flags.CanonicalDnsHost;
+ m_DnsSafeHost = new string(pString, start, end - start);
+ justNormalized = true;
+ }
+ flags |= Flags.HostUnicodeNormalized;
+ }
+ }
+ }
+ else if (((syntaxFlags & UriSyntaxFlags.AllowDnsHost) != 0)
+ && ((syntax.InFact(UriSyntaxFlags.AllowIriParsing) && hostNotUnicodeNormalized)
+ || syntax.InFact(UriSyntaxFlags.AllowIdn))
+ && DomainNameHelper.IsValidByIri(pString, start, ref end, ref dnsNotCanonical,
+ StaticNotAny(flags, Flags.ImplicitFile)))
+ {
+ CheckAuthorityHelperHandleDnsIri(pString, start, end, startInput, iriParsing, hasUnicode, syntax,
+ userInfoString, ref flags, ref justNormalized, ref newHost, ref err);
+ }
+#if !PLATFORM_UNIX
+ else if ((syntaxFlags & UriSyntaxFlags.AllowUncHost) != 0)
+ {
+ //
+ // This must remain as the last check befor BasicHost type
+ //
+ if (UncNameHelper.IsValid(pString, start, ref end, StaticNotAny(flags, Flags.ImplicitFile)))
+ {
+ if (end - start <= UncNameHelper.MaximumInternetNameLength)
+ {
+ flags |= Flags.UncHostType;
+ if (hasUnicode && iriParsing && hostNotUnicodeNormalized)
+ {
+ newHost += new string(pString, start, end - start);
+ flags |= Flags.HostUnicodeNormalized;
+ justNormalized = true;
+ }
+ }
+ }
+ }
+#endif // !PLATFORM_UNIX
+
+ // The deal here is that we won't allow '\' host terminator except for the File scheme
+ // If we see '\' we try to make it a part of of a Basic host
+ if (end < length && pString[end] == '\\' && (flags & Flags.HostTypeMask) != Flags.HostNotParsed
+ && !StaticIsFile(syntax))
+ {
+ if (syntax.InFact(UriSyntaxFlags.V1_UnknownUri))
+ {
+ err = ParsingError.BadHostName;
+ flags |= Flags.UnknownHostType;
+ return (ushort) end;
+ }
+ flags &= ~Flags.HostTypeMask;
+ }
+ // Here we have checked the syntax up to the end of host
+ // The only thing that can cause an exception is the port value
+ // Spend some (duplicated) cycles on that.
+ else if (end < length && pString[end] == ':')
+ {
+ if (syntax.InFact(UriSyntaxFlags.MayHavePort))
+ {
+ int port = 0;
+ int startPort = end;
+ for (idx = (ushort)(end+1); idx < length; ++idx) {
+ ushort val = (ushort)((ushort)pString[idx] - (ushort)'0');
+ if ((val >= 0) && (val <= 9))
+ {
+ if ((port = (port * 10 + val)) > 0xFFFF)
+ break;
+ }
+ else if (val == unchecked((ushort)('/' - '0')) || val == (ushort)('?' - '0')
+ || val == unchecked((ushort)('#' - '0')))
+ {
+ break;
+ }
+ else
+ {
+ // The second check is to keep compatibility with V1 until the UriParser is registered
+ if(syntax.InFact(UriSyntaxFlags.AllowAnyOtherHost)
+ && syntax.NotAny(UriSyntaxFlags.V1_UnknownUri))
+ {
+ flags &= ~Flags.HostTypeMask;
+ break;
+ }
+ else
+ {
+ err = ParsingError.BadPort;
+ return idx;
+ }
+ }
+ }
+ // check on 0-ffff range
+ if (port > 0xFFFF)
+ {
+ if (syntax.InFact(UriSyntaxFlags.AllowAnyOtherHost))
+ {
+ flags &= ~Flags.HostTypeMask;
+ }
+ else
+ {
+ err = ParsingError.BadPort;
+ return idx;
+ }
+ }
+
+ if (iriParsing && hasUnicode && justNormalized){
+ newHost += new string(pString, startPort, idx - startPort);
+ }
+ }
+ else
+ {
+ flags &= ~Flags.HostTypeMask;
+ }
+
+ }
+
+ // check on whether nothing has worked out
+ if ((flags & Flags.HostTypeMask) == Flags.HostNotParsed)
+ {
+ //No user info for a Basic hostname
+ flags &= ~Flags.HasUserInfo;
+ // Some schemes do not allow HostType = Basic (plus V1 almost never understands this cause of a bug)
+ //
+ if(syntax.InFact(UriSyntaxFlags.AllowAnyOtherHost))
+ {
+ flags |= Flags.BasicHostType;
+ for (end = idx; end < length; ++end) {
+ if (pString[end] == '/' || (pString[end] == '?' || pString[end] == '#')) {
+ break;
+ }
+ }
+ CheckAuthorityHelperHandleAnyHostIri(pString, startInput, end, iriParsing, hasUnicode, syntax,
+ ref flags, ref newHost, ref err);
+ }
+ else
+ {
+ //
+ // ATTN V1 compat: V1 supports hostnames like ".." and ".", and so we do but only for unknown schemes.
+ // (VsWhidbey#438821)
+ if (syntax.InFact(UriSyntaxFlags.V1_UnknownUri))
+ {
+ // Can assert here that the host is not empty so we will set dotFound
+ // at least once or fail before exiting the loop
+ bool dotFound = false;
+ int startOtherHost = idx;
+ for (end = idx; end < length; ++end)
+ {
+ if (dotFound && (pString[end] == '/' || pString[end] == '?' || pString[end] == '#'))
+ break;
+ else if (end < (idx + 2) && pString[end] == '.')
+ {
+ // allow one or two dots
+ dotFound = true;
+ }
+ else
+ {
+ //failure
+ err = ParsingError.BadHostName;
+ flags |= Flags.UnknownHostType;
+ return idx;
+ }
+ }
+ //success
+ flags |= Flags.BasicHostType;
+
+ if (iriParsing && hasUnicode
+ && StaticNotAny(flags, Flags.HostUnicodeNormalized)){
+ // Normalize any other host
+ String user = new string(pString, startOtherHost, end - startOtherHost);
+ try
+ {
+ newHost += user.Normalize(NormalizationForm.FormC);
+ }
+ catch (ArgumentException){
+ err = ParsingError.BadFormat;
+ return idx;
+ }
+
+ flags |= Flags.HostUnicodeNormalized;
+ }
+ }
+ else if (syntax.InFact(UriSyntaxFlags.MustHaveAuthority) ||
+ (syntax.InFact(UriSyntaxFlags.MailToLikeUri) && !UriParser.ShouldUseLegacyV2Quirks))
+ {
+ err = ParsingError.BadHostName;
+ flags |= Flags.UnknownHostType;
+ return idx;
+ }
+ }
+ }
+ return (ushort) end;
+ }
+
+ unsafe void CheckAuthorityHelperHandleDnsIri( char* pString, ushort start, int end, int startInput,
+ bool iriParsing, bool hasUnicode, UriParser syntax, string userInfoString, ref Flags flags,
+ ref bool justNormalized, ref string newHost, ref ParsingError err)
+ {
+ // comes here only if host has unicode chars and iri is on or idn is allowed
+
+ flags |= Flags.DnsHostType;
+
+ // check if intranet
+ //
+ if ((s_IdnScope == UriIdnScope.AllExceptIntranet) && IsIntranet(new string(pString, 0, end)))
+ {
+ flags |= Flags.IntranetUri;
+ }
+
+ if (AllowIdnStatic(syntax, flags))
+ {
+ bool allAscii = true;
+ bool atLeastOneIdn = false;
+
+ string idnValue = DomainNameHelper.IdnEquivalent(pString, start, end, ref allAscii, ref atLeastOneIdn);
+ string UniEquvlt = DomainNameHelper.UnicodeEquivalent(idnValue, pString, start, end);
+
+ if (!allAscii)
+ flags |= Flags.UnicodeHost; // we have a unicode host
+
+ if (atLeastOneIdn)
+ flags |= Flags.IdnHost; // we have at least one valid idn label
+
+ if (allAscii && atLeastOneIdn && StaticNotAny(flags, Flags.HasUnicode))
+ {
+ // original string location changed lazily
+ m_originalUnicodeString = m_String;
+ newHost = m_originalUnicodeString.Substring(0, startInput) +
+ (StaticInFact(flags, Flags.HasUserInfo) ? userInfoString : null);
+ justNormalized = true;
+ }
+ else if (!iriParsing && (StaticInFact(flags, Flags.UnicodeHost) || StaticInFact(flags, Flags.IdnHost)))
+ {
+ // original string location changed lazily
+ m_originalUnicodeString = m_String;
+ newHost = m_originalUnicodeString.Substring(0, startInput) +
+ (StaticInFact(flags, Flags.HasUserInfo) ? userInfoString : null);
+ justNormalized = true;
+ }
+
+ if (!(allAscii && !atLeastOneIdn))
+ {
+ m_DnsSafeHost = idnValue;
+ newHost += UniEquvlt;
+ justNormalized = true;
+ }
+ else if (allAscii && !atLeastOneIdn && iriParsing && hasUnicode)
+ {
+ newHost += UniEquvlt;
+ justNormalized = true;
+ }
+ }
+ else
+ {
+ if (hasUnicode)
+ {
+ string temp = StripBidiControlCharacter(pString, start, end - start);
+ try{
+ newHost += ((temp != null) ? temp.Normalize(NormalizationForm.FormC) : null);
+ }
+ catch (ArgumentException){
+ err = ParsingError.BadHostName;
+ }
+ justNormalized = true;
+ }
+ }
+ flags |= Flags.HostUnicodeNormalized;
+ }
+
+ unsafe void CheckAuthorityHelperHandleAnyHostIri(char* pString, int startInput, int end,
+ bool iriParsing, bool hasUnicode, UriParser syntax,
+ ref Flags flags, ref string newHost, ref ParsingError err)
+ {
+ if (StaticNotAny(flags, Flags.HostUnicodeNormalized) && (AllowIdnStatic(syntax, flags) ||
+ (iriParsing && hasUnicode)))
+ {
+ // Normalize any other host or do idn
+ String user = new string(pString, startInput, end - startInput);
+
+ if (AllowIdnStatic(syntax, flags))
+ {
+ bool allAscii = true;
+ bool atLeastOneIdn = false;
+
+ string UniEquvlt = DomainNameHelper.UnicodeEquivalent(pString, startInput, end, ref allAscii,
+ ref atLeastOneIdn);
+
+ if (((allAscii && atLeastOneIdn) || !allAscii) && !(iriParsing && hasUnicode))
+ {
+ // original string location changed lazily
+ m_originalUnicodeString = m_String;
+ newHost = m_originalUnicodeString.Substring(0, startInput);
+ flags |= Flags.HasUnicode;
+ }
+ if (atLeastOneIdn || !allAscii)
+ {
+ newHost += UniEquvlt;
+ string bidiStrippedHost = null;
+ m_DnsSafeHost = DomainNameHelper.IdnEquivalent(pString, startInput, end, ref allAscii,
+ ref bidiStrippedHost);
+ if (atLeastOneIdn)
+ flags |= Flags.IdnHost;
+ if (!allAscii)
+ flags |= Flags.UnicodeHost;
+ }
+ else if (iriParsing && hasUnicode)
+ {
+ newHost += user;
+
+ }
+ }
+ else
+ {
+ try{
+ newHost += user.Normalize(NormalizationForm.FormC);
+ }
+ catch (ArgumentException){
+ err = ParsingError.BadHostName;
+ }
+ }
+
+ flags |= Flags.HostUnicodeNormalized;
+ }
+ }
+
+ //
+ //
+ // The method checks whether a string needs transformation before going to display or wire
+ //
+ // Parameters:
+ // - escaped true = treat all valid escape sequences as escaped sequences, false = escape all %
+ // - delim a character signalling the termination of the component being checked
+ //
+ // When delim=='?', then '#' character is also considered as delimiter additionally to passed '?'.
+ //
+ // The method pays attention to the dots and slashes so to signal potential Path compression action needed.
+ // Even that is not required for other components, the cycles are still spent (little inefficiency)
+ //
+
+ internal const char c_DummyChar = (char) 0xFFFF; //An Invalid Unicode character used as a dummy char passed into the parameter
+ internal const char c_EOL = (char) 0xFFFE; //An Invalid Unicode character used by CheckCanonical as "no delimiter condition"
+ [Flags]
+ private enum Check {
+ None = 0x0,
+ EscapedCanonical= 0x1,
+ DisplayCanonical= 0x2,
+ DotSlashAttn = 0x4,
+ DotSlashEscaped = 0x80,
+ BackslashInPath = 0x10,
+ ReservedFound = 0x20,
+ NotIriCanonical = 0x40,
+ FoundNonAscii = 0x8
+ }
+
+ //
+ // Finds the end of component
+ //
+
+ private unsafe void FindEndOfComponent(string input, ref ushort idx, ushort end, char delim)
+ {
+ fixed (char* str = input)
+ {
+ FindEndOfComponent(str, ref idx, end, delim);
+ }
+ }
+ private unsafe void FindEndOfComponent(char* str, ref ushort idx, ushort end, char delim)
+ {
+ char c = c_DummyChar;
+ ushort i=idx;
+ for (; i < end; ++i)
+ {
+ c = str[i];
+ if (c == delim)
+ {
+ break;
+ }
+ else if (delim == '?' && c == '#' && (m_Syntax != null && m_Syntax.InFact(UriSyntaxFlags.MayHaveFragment)))
+ {
+ // this is a special case when deciding on Query/Fragment
+ break;
+ }
+ }
+ idx = i;
+ }
+
+ //
+ // Used by ParseRemaining as well by InternalIsWellFormedOriginalString
+ //
+ private unsafe Check CheckCanonical(char* str, ref ushort idx, ushort end, char delim) {
+ Check res = Check.None;
+ bool needsEscaping = false;
+ bool foundEscaping = false;
+
+ char c = c_DummyChar;
+ ushort i=idx;
+ for (; i < end; ++i)
+ {
+ c = str[i];
+ // Control chars usually should be escaped in any case
+ if (c <= '\x1F' || (c >= '\x7F' && c <= '\x9F'))
+ {
+ needsEscaping = true;
+ foundEscaping = true;
+ res |= Check.ReservedFound;
+ }
+ else if (c > 'z' && c != '~') {
+ if(m_iriParsing){
+ bool valid = false;
+ res |= Check.FoundNonAscii;
+
+ if (Char.IsHighSurrogate(c)){
+ if ((i + 1) < end){
+ bool surrPair = false;
+ valid = IriHelper.CheckIriUnicodeRange(c, str[i + 1], ref surrPair, true);
+ }
+ }
+ else{
+ valid = IriHelper.CheckIriUnicodeRange(c, true);
+ }
+ if (!valid) res |= Check.NotIriCanonical;
+ }
+
+ if (!needsEscaping) needsEscaping = true;
+ }
+ else if (c == delim) {
+ break;
+ }
+ else if (delim == '?' && c == '#' && (m_Syntax != null && m_Syntax.InFact(UriSyntaxFlags.MayHaveFragment))) {
+ // this is a special case when deciding on Query/Fragment
+ break;
+ }
+ else if (c == '?') {
+ if (IsImplicitFile || (m_Syntax != null && !m_Syntax.InFact(UriSyntaxFlags.MayHaveQuery)
+ && delim != c_EOL))
+ {
+ // VsWhidbey#87423
+ // If found as reserved this char is not suitable for safe unescaped display
+ // Will need to escape it when both escaping and unescaping the string
+ res |= Check.ReservedFound;
+ foundEscaping = true;
+ needsEscaping = true;
+ }
+ }
+ else if (c == '#') {
+ needsEscaping = true;
+ if (IsImplicitFile || (m_Syntax != null && !m_Syntax.InFact(UriSyntaxFlags.MayHaveFragment))) {
+ // VsWhidbey#87423, 122037
+ // If found as reserved this char is not suitable for safe unescaped display
+ // Will need to escape it when both escaping and unescaping the string
+ res |= Check.ReservedFound;
+ foundEscaping = true;
+ }
+ }
+ else if (c == '/' || c == '\\') {
+ if ((res & Check.BackslashInPath) == 0 && c == '\\') {
+ res |= Check.BackslashInPath;
+ }
+ if ((res & Check.DotSlashAttn) == 0 && i+1 != end && (str[i+1] == '/' || str[i+1] == '\\' )) {
+ res |= Check.DotSlashAttn;
+ }
+ }
+ else if (c == '.') {
+ if ((res & Check.DotSlashAttn) == 0 && i+1 == end || str[i+1] == '.' || str[i+1] == '/'
+ || str[i+1] == '\\' || str[i+1] == '?' || str[i+1] == '#') {
+ res |= Check.DotSlashAttn;
+ }
+ }
+ else if (!needsEscaping && ((c <= '"' && c != '!') || (c >= '[' && c <= '^') || c == '>'
+ || c == '<' || c == '`')) {
+ needsEscaping = true;
+ }
+ else if (c == '%') {
+ if (!foundEscaping) foundEscaping = true;
+ //try unescape a byte hex escaping
+ if (i + 2 < end && (c = UriHelper.EscapedAscii(str[i + 1], str[i + 2])) != c_DummyChar)
+ {
+ if (c == '.' || c == '/' || c == '\\') {
+ res |= Check.DotSlashEscaped;
+ }
+ i+=2;
+ continue;
+ }
+ // otherwise we follow to non escaped case
+ if (!needsEscaping) {
+ needsEscaping = true;
+ }
+ }
+ }
+
+ if (foundEscaping) {
+ if (!needsEscaping) {
+ res |= Check.EscapedCanonical;
+ }
+ }
+ else {
+ res |= Check.DisplayCanonical;
+ if (!needsEscaping) {
+ res |= Check.EscapedCanonical;
+ }
+ }
+ idx = i;
+ return res;
+ }
+
+ //
+ // Returns the escaped and canonicalized path string
+ // the passed array must be long enough to hold at least
+ // canonical unescaped path representation (allocated by the caller)
+ //
+ private unsafe char[] GetCanonicalPath(char[] dest, ref int pos, UriFormat formatAs)
+ {
+
+ if (InFact(Flags.FirstSlashAbsent))
+ dest[pos++] = '/';
+
+ if (m_Info.Offset.Path == m_Info.Offset.Query)
+ return dest;
+
+ int end = pos;
+
+ int dosPathIdx = SecuredPathIndex;
+
+ // Note that unescaping and then escapig back is not transitive hence not safe.
+ // We are vulnerable due to the way the UserEscaped flag is processed (see NDPWhidbey#10612 bug).
+ // Try to unescape only needed chars.
+ if (formatAs == UriFormat.UriEscaped)
+ {
+ if (InFact(Flags.ShouldBeCompressed))
+ {
+ m_String.CopyTo(m_Info.Offset.Path, dest, end, m_Info.Offset.Query - m_Info.Offset.Path);
+ end += (m_Info.Offset.Query - m_Info.Offset.Path);
+
+ // If the path was found as needed compression and contains escaped characters, unescape only
+ // interesting characters (safe)
+
+ if (m_Syntax.InFact(UriSyntaxFlags.UnEscapeDotsAndSlashes) && InFact(Flags.PathNotCanonical)
+ && !IsImplicitFile)
+ {
+ fixed (char* pdest = dest)
+ {
+ UnescapeOnly(pdest, pos, ref end, '.', '/',
+ m_Syntax.InFact(UriSyntaxFlags.ConvertPathSlashes) ? '\\' : c_DummyChar);
+ }
+ }
+ }
+ else
+ {
+ //
+ if (InFact(Flags.E_PathNotCanonical) && NotAny(Flags.UserEscaped)) {
+ string str = m_String;
+
+ // Check on not canonical disk designation like C|\, should be rare, rare case
+ if (dosPathIdx != 0 && str[dosPathIdx + m_Info.Offset.Path -1] == '|')
+ {
+ str = str.Remove(dosPathIdx + m_Info.Offset.Path -1, 1);
+ str = str.Insert(dosPathIdx + m_Info.Offset.Path -1, ":");
+ }
+ dest = UriHelper.EscapeString(str, m_Info.Offset.Path, m_Info.Offset.Query, dest, ref end, true,
+ '?', '#', IsImplicitFile? c_DummyChar: '%');
+ }
+ else {
+ m_String.CopyTo(m_Info.Offset.Path, dest, end, m_Info.Offset.Query - m_Info.Offset.Path);
+ end += (m_Info.Offset.Query - m_Info.Offset.Path);
+ }
+ }
+ }
+ else
+ {
+ m_String.CopyTo(m_Info.Offset.Path, dest, end, m_Info.Offset.Query - m_Info.Offset.Path);
+ end += (m_Info.Offset.Query - m_Info.Offset.Path);
+
+ if (InFact(Flags.ShouldBeCompressed))
+ {
+ // If the path was found as needed compression and contains escaped characters,
+ // unescape only interesting characters (safe)
+
+ if (m_Syntax.InFact(UriSyntaxFlags.UnEscapeDotsAndSlashes) && InFact(Flags.PathNotCanonical)
+ && !IsImplicitFile)
+ {
+ fixed (char* pdest = dest)
+ {
+ UnescapeOnly(pdest, pos, ref end, '.', '/',
+ m_Syntax.InFact(UriSyntaxFlags.ConvertPathSlashes) ? '\\' : c_DummyChar);
+ }
+ }
+ }
+ }
+
+ // Here we already got output data as copied into dest array
+ // We just may need more processing of that data
+
+ //
+ // if this URI is using 'non-proprietary' disk drive designation, convert to MS-style
+ //
+ // (path is already >= 3 chars if recognized as a DOS-like)
+ //
+ if (dosPathIdx != 0 && dest[dosPathIdx + pos - 1] == '|')
+ dest[dosPathIdx + pos - 1] = ':';
+
+ if (InFact(Flags.ShouldBeCompressed))
+ {
+ // It will also convert back slashes if needed
+ dest = Compress(dest, (ushort)(pos + dosPathIdx), ref end, m_Syntax);
+ if (dest[pos] == '\\')
+ dest[pos] = '/';
+
+ // Escape path if requested and found as not fully escaped
+ if (formatAs == UriFormat.UriEscaped && NotAny(Flags.UserEscaped) && InFact(Flags.E_PathNotCanonical)) {
+ //
+ string srcString = new string(dest, pos, end-pos);
+ dest = UriHelper.EscapeString(srcString, 0, end - pos, dest, ref pos, true, '?', '#',
+ IsImplicitFile ? c_DummyChar : '%');
+ end = pos;
+ }
+ }
+ else if (m_Syntax.InFact(UriSyntaxFlags.ConvertPathSlashes) && InFact(Flags.BackslashInPath))
+ {
+ for (int i = pos; i < end; ++i)
+ if (dest[i] == '\\') dest[i] = '/';
+ }
+
+ if (formatAs != UriFormat.UriEscaped && InFact(Flags.PathNotCanonical))
+ {
+ UnescapeMode mode;
+ if (InFact(Flags.PathNotCanonical))
+ {
+ switch (formatAs)
+ {
+ case V1ToStringUnescape:
+
+ mode = (InFact(Flags.UserEscaped) ? UnescapeMode.Unescape : UnescapeMode.EscapeUnescape)
+ | UnescapeMode.V1ToStringFlag;
+ if (IsImplicitFile)
+ mode &= ~UnescapeMode.Unescape;
+ break;
+
+ case UriFormat.Unescaped:
+ mode = IsImplicitFile ? UnescapeMode.CopyOnly
+ : UnescapeMode.Unescape | UnescapeMode.UnescapeAll;
+ break;
+
+ default: // UriFormat.SafeUnescaped
+
+ mode = InFact(Flags.UserEscaped)? UnescapeMode.Unescape: UnescapeMode.EscapeUnescape;
+ if (IsImplicitFile)
+ mode &= ~UnescapeMode.Unescape;
+ break;
+ }
+ }
+ else {
+ mode = UnescapeMode.CopyOnly;
+ }
+
+ char[] dest1 = new char[dest.Length];
+ Buffer.BlockCopy(dest, 0, dest1, 0, end<<1);
+ fixed (char *pdest = dest1)
+ {
+ dest = UriHelper.UnescapeString(pdest, pos, end, dest, ref pos, '?', '#', c_DummyChar, mode,
+ m_Syntax, false);
+ }
+ }
+ else
+ {
+ pos = end;
+ }
+
+ return dest;
+ }
+
+ // works only with ASCII characters, used to partially unescape path before compressing
+ private unsafe static void UnescapeOnly(char* pch, int start, ref int end, char ch1, char ch2, char ch3) {
+ if (end - start < 3) {
+ //no chance that something is escaped
+ return;
+ }
+
+ char *pend = pch + end-2;
+ pch += start;
+ char *pnew = null;
+
+ over:
+
+ // Just looking for a interested escaped char
+ if (pch >= pend) goto done;
+ if(*pch++ != '%') goto over;
+
+ char ch = UriHelper.EscapedAscii(*pch++, *pch++);
+ if (!(ch == ch1 || ch == ch2 || ch == ch3)) goto over;
+
+ // Here we found something and now start copying the scanned chars
+ pnew = pch-2;
+ *(pnew-1) = ch;
+
+ over_new:
+
+ if (pch >= pend) goto done;
+ if((*pnew++ = *pch++) != '%') goto over_new;
+
+ ch = UriHelper.EscapedAscii((*pnew++ = *pch++), (*pnew++ = *pch++));
+ if (!(ch == ch1 || ch == ch2 || ch == ch3)) {
+ goto over_new;
+ }
+
+ pnew -= 2;
+ *(pnew-1) = ch;
+
+ goto over_new;
+
+ done:
+ pend+=2;
+
+ if (pnew == null) {
+ //nothing was found
+ return;
+ }
+
+ //the tail may be already processed
+ if(pch == pend) {
+ end -= (int) (pch-pnew);
+ return;
+ }
+
+ *pnew++ = *pch++;
+ if(pch == pend) {
+ end -= (int) (pch-pnew);
+ return;
+ }
+ *pnew++ = *pch++;
+ end -= (int) (pch-pnew);
+ }
+
+ //
+ //
+ // This will compress any "\" "/../" "/./" "///" "/..../" /XXX.../, etc found in the input
+ //
+ // The passed syntax controls whether to use agressive compression or the one specified in RFC 2396
+ //
+ //
+ private static char[] Compress(char[] dest, ushort start, ref int destLength, UriParser syntax)
+ {
+ ushort slashCount = 0;
+ ushort lastSlash = 0;
+ ushort dotCount = 0;
+ ushort removeSegments = 0;
+
+ unchecked {
+ //ushort i == -1 and start == -1 overflow is ok here
+ ushort i = (ushort)((ushort)destLength - (ushort)1);
+ start = (ushort)(start-1);
+
+ for (; i != start ; --i) {
+ char ch = dest[i];
+ if (ch == '\\' && syntax.InFact(UriSyntaxFlags.ConvertPathSlashes)) {
+ dest[i] = ch = '/';
+ }
+
+ //
+ // compress multiple '/' for file URI
+ //
+ if (ch == '/') {
+ ++slashCount;
+ /*
+ QFE 4390 - remove the compression of multiple slashes to a single slash
+ if (slashCount > 1) {
+ continue;
+ }
+ */
+ }
+ else {
+ if (slashCount > 1) {
+ /*
+ QFE 4390 - remove the compression of multiple slashes to a single slash
+ if (syntax.InFact(UriSyntaxFlags.CanonicalizeAsFilePath))
+ {
+ // We saw > 1 slashes so remove all but the last one
+ // dest.Remove(i+1, slashCount -1);
+ Buffer.BlockCopy(dest, (i + slashCount) << 1, dest, (i + 1) << 1,
+ (destLength - (i + slashCount)) << 1);
+ destLength -= (slashCount - 1);
+ }
+ */
+ // else preserve repeated slashes
+ lastSlash = (ushort)(i + 1);
+ }
+ slashCount = 0;
+ }
+
+ if (ch == '.') {
+ ++dotCount;
+ continue;
+ }
+ else if (dotCount != 0) {
+
+ bool skipSegment = syntax.NotAny(UriSyntaxFlags.CanonicalizeAsFilePath)
+ && (dotCount > 2 || ch != '/' || i == start);
+
+ //
+ // Cases:
+ // /./ = remove this segment
+ // /../ = remove this segment, mark next for removal
+ // /....x = DO NOT TOUCH, leave as is
+ // x.../ = DO NOT TOUCH, leave as is, except for V2 legacy mode
+ //
+ if (!skipSegment && ch == '/') {
+ if ((lastSlash == i + dotCount + 1 // "/..../"
+ || (lastSlash == 0 && i + dotCount + 1 == destLength)) // "/..."
+ && (UriParser.ShouldUseLegacyV2Quirks || dotCount <= 2)) {
+ //
+ // /./ or /.<eos> or /../ or /..<eos>
+ //
+ // just reusing a variable slot we perform //dest.Remove(i+1, dotCount + (lastSlash==0?0:1));
+ lastSlash = (ushort)(i + 1 + dotCount + (lastSlash==0?0:1));
+ Buffer.BlockCopy(dest, lastSlash<<1, dest, (i+1)<<1, (destLength - lastSlash)<<1);
+ destLength -= (lastSlash-i-1);
+
+ lastSlash = i;
+ if (dotCount == 2) {
+ //
+ // We have 2 dots in between like /../ or /..<eos>,
+ // Mark next segment for removal and remove this /../ or /..
+ //
+ ++removeSegments;
+ }
+ dotCount = 0;
+ continue;
+ }
+ }
+ else if (UriParser.ShouldUseLegacyV2Quirks
+ && !skipSegment
+ && (removeSegments == 0)
+ && (lastSlash == i+dotCount+1 || (lastSlash == 0 && i+dotCount+1 == destLength))) {
+ //
+ // Note if removeSegments!=0, then ignore and remove the whole segment later
+ //
+ // x.../ or x...<eos>
+ // remove trailing dots
+ //
+ //
+ // just reusing a variable slot we perform //dest.Remove(i+1, dotCount);
+ dotCount = (ushort)(i + 1 + dotCount);
+ Buffer.BlockCopy(dest, dotCount<<1, dest, (i+1)<<1, (destLength - dotCount)<<1);
+ destLength -= (dotCount-i-1);
+ lastSlash = 0; //the other dots in this segment will stay intact
+ dotCount = 0;
+ continue;
+ }
+ // .NET 4.5 no longer removes trailing dots in a path segment x.../ or x...<eos>
+ dotCount = 0;
+
+ //
+ // Here all other cases go such as
+ // x.[..]y or /.[..]x or (/x.[...][/] && removeSegments !=0)
+ }
+
+ //
+ // Now we may want to remove a segment because of previous /../
+ //
+ if (ch == '/') {
+ if (removeSegments != 0) {
+ --removeSegments;
+
+ // just reusing a variable slot we perform //dest.Remove(i+1, lastSlash - i);
+ lastSlash = (ushort)(lastSlash + 1);
+ Buffer.BlockCopy(dest, lastSlash<<1, dest, (i+1)<<1, (destLength - lastSlash)<<1);
+ destLength -= (lastSlash-i-1);
+ }
+ lastSlash = i;
+ }
+ }
+
+ start = (ushort)((ushort)start + (ushort)1);
+ } //end of unchecked
+
+ // Dead Code?
+ if ((ushort)destLength > start && syntax.InFact(UriSyntaxFlags.CanonicalizeAsFilePath))
+ {
+ if (slashCount > 1) {
+ /*
+ Buffer.BlockCopy(dest, lastSlash << 1, dest, start << 1, (destLength - lastSlash) << 1);
+ destLength -= (slashCount - 1);
+ */
+ //QFE 4390 - Fall through for compat after not multiple slashes to a single slashl
+ }
+ else if (removeSegments != 0 && dest[start] != '/') {
+ //remove first not rooted segment
+ // dest.Remove(i+1, lastSlash - i);
+ lastSlash = (ushort)(lastSlash + 1);
+ Buffer.BlockCopy(dest, lastSlash<<1, dest, start<<1, (destLength - lastSlash)<<1);
+ destLength -= lastSlash;
+ }
+ else if (dotCount != 0) {
+ // If final string starts with a segment looking like .[...]/ or .[...]<eos>
+ // then we remove this fisrt segment
+ if (lastSlash == dotCount+1 || (lastSlash == 0 && dotCount + 1 == destLength)) {
+ //dest.Remove(0, dotCount + (lastSlash==0?0:1));
+ dotCount = (ushort)(dotCount + (lastSlash==0?0:1));
+ Buffer.BlockCopy(dest, dotCount<<1, dest, start<<1, (destLength - dotCount)<<1);
+ destLength -= dotCount;
+ }
+ }
+ }
+ return dest;
+ }
+
+ //used by DigestClient
+ internal static readonly char[] HexLowerChars = {
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+ };
+
+ internal static int CalculateCaseInsensitiveHashCode(string text)
+ {
+ return StringComparer.InvariantCultureIgnoreCase.GetHashCode(text);
+ }
+ //
+ // CombineUri
+ //
+ // Given 2 URI strings, combine them into a single resultant URI string
+ //
+ // Inputs:
+ // <argument> basePart
+ // Base URI to combine with
+ //
+ // <argument> relativePart
+ // String expected to be relative URI
+ //
+ // Assumes:
+ // <basePart> is in canonic form
+ //
+ // Returns:
+ // Resulting combined URI string
+ //
+ private static string CombineUri(Uri basePart, string relativePart, UriFormat uriFormat) {
+ //NB: relativePart is ensured as not empty by the caller
+ // Another assumption is that basePart is an AbsoluteUri
+
+ // This method was not optimized for efficiency
+ // Means a relative Uri ctor may be relatively slow plus it increases the footprint of the baseUri
+
+ char c1 = relativePart[0];
+
+#if !PLATFORM_UNIX
+ //check a special case for the base as DOS path and a rooted relative string
+ if ( basePart.IsDosPath &&
+ (c1 == '/' || c1 == '\\') &&
+ (relativePart.Length == 1 || (relativePart[1] != '/' && relativePart[1] != '\\')))
+ {
+ // take relative part appended to the base string after the drive letter
+ int idx = basePart.OriginalString.IndexOf(':');
+ if (basePart.IsImplicitFile) {
+ return basePart.OriginalString.Substring(0, idx+1 ) + relativePart;
+ }
+ // The basePart has explicit scheme (could be not file:), take the DOS drive ':' position
+ idx = basePart.OriginalString.IndexOf(':', idx+1);
+ return basePart.OriginalString.Substring(0, idx+1 ) + relativePart;
+ }
+#endif // !PLATFORM_UNIX
+
+ // Check special case for Unc or absolute path in relativePart when base is FILE
+ if (StaticIsFile(basePart.Syntax))
+ {
+
+ if (c1 == '\\' || c1 == '/') {
+
+ if(relativePart.Length >= 2 && (relativePart[1] == '\\' || relativePart[1] == '/')) {
+ //Assuming relative is a Unc path and base is a file uri.
+ return basePart.IsImplicitFile? relativePart: "file:" + relativePart;
+ }
+
+ // here we got an absolute path in relativePart,
+ // For compatibility with V1.0 parser we restrict the compression scope to Unc Share, i.e. \\host\share\
+ if (basePart.IsUnc) {
+ string share = basePart.GetParts(UriComponents.Path | UriComponents.KeepDelimiter,
+ UriFormat.Unescaped);
+ for (int i = 1; i < share.Length; ++i) {
+ if (share[i] == '/') {
+ share = share.Substring(0, i);
+ break;
+ }
+ }
+ if (basePart.IsImplicitFile) {
+ return @"\\"
+ + basePart.GetParts(UriComponents.Host, UriFormat.Unescaped)
+ + share
+ + relativePart;
+ }
+ return "file://"
+ + basePart.GetParts(UriComponents.Host, uriFormat)
+ + share
+ + relativePart;
+
+ }
+ // It's not obvious but we've checked (for this relativePart format) that baseUti is nor UNC nor DOS path
+ //
+ // Means base is a Unix style path and, btw, IsImplicitFile cannot be the case either
+ return "file://" + relativePart;
+ }
+ }
+
+ // If we are here we did not recognize absolute DOS/UNC path for a file: base uri
+ // Note that DOS path may still happen in the relativePart and if so it may override the base uri scheme.
+
+ bool convBackSlashes = basePart.Syntax.InFact(UriSyntaxFlags.ConvertPathSlashes);
+
+ string left = null;
+
+ // check for network or local absolute path
+ if (c1 == '/' || (c1 == '\\' && convBackSlashes)) {
+ if (relativePart.Length >= 2 && relativePart[1] == '/') {
+ // got an authority in relative path and the base scheme is not file (checked)
+ return basePart.Scheme + ':' + relativePart;
+ }
+
+ // Got absolute relative path, and the base is nor FILE nor a DOS path (checked at the method start)
+ if (basePart.HostType == Flags.IPv6HostType) {
+ left = basePart.GetParts(UriComponents.Scheme|UriComponents.UserInfo, uriFormat)
+ + '[' + basePart.DnsSafeHost + ']'
+ + basePart.GetParts(UriComponents.KeepDelimiter|UriComponents.Port, uriFormat);
+ }
+ else {
+ left = basePart.GetParts(UriComponents.SchemeAndServer|UriComponents.UserInfo, uriFormat);
+ }
+ //VsWhidbey#241426
+ if (convBackSlashes && c1 == '\\')
+ relativePart = '/' + relativePart.Substring(1);
+
+ return left + relativePart;
+ }
+
+ // Here we got a relative path
+ // Need to run path Compression because this is how relative Uri combining works
+
+ // Take the base part path up to and including the last slash
+ left = basePart.GetParts(UriComponents.Path | UriComponents.KeepDelimiter,
+ basePart.IsImplicitFile ? UriFormat.Unescaped : uriFormat);
+ int length = left.Length;
+ char[] path = new char[length + relativePart.Length];
+
+ if (length > 0) {
+ left.CopyTo(0, path, 0, length);
+ while(length > 0) {
+ if (path[--length] == '/') {
+ ++length;
+ break;
+ }
+ }
+ }
+
+ //Append relative path to the result
+ relativePart.CopyTo(0, path, length, relativePart.Length);
+
+ // Split relative on path and extra (for compression)
+ c1 = basePart.Syntax.InFact(UriSyntaxFlags.MayHaveQuery)? '?': c_DummyChar;
+
+ // The implcit file check is to avoid a fragment in the implicit file combined uri.
+ // The behavior change request is tracked vis VsWhidbey#261387 ans that was approved through VsWhidbey#266417.
+ char c2 = (!basePart.IsImplicitFile && basePart.Syntax.InFact(UriSyntaxFlags.MayHaveFragment)) ? '#' :
+ c_DummyChar;
+ string extra = String.Empty;
+
+ // assuming c_DummyChar may not happen in an unicode uri string
+ if (!(c1 == c_DummyChar && c2 == c_DummyChar)) {
+ int i=0;
+ for (;i < relativePart.Length; ++i) {
+ if (path[length + i] == c1 || path[length + i] == c2) {
+ break;
+ }
+ }
+ if (i == 0) {
+ extra = relativePart;
+ }
+ else if (i < relativePart.Length) {
+ extra = relativePart.Substring(i);
+ }
+ length += i;
+ }
+ else {
+ length += relativePart.Length;
+ }
+
+ // Take the base part up to the path
+ if (basePart.HostType == Flags.IPv6HostType) {
+ if (basePart.IsImplicitFile) {
+ left = @"\\[" + basePart.DnsSafeHost + ']';
+ }
+ else {
+ left = basePart.GetParts(UriComponents.Scheme|UriComponents.UserInfo, uriFormat)
+ + '[' + basePart.DnsSafeHost + ']'
+ + basePart.GetParts(UriComponents.KeepDelimiter|UriComponents.Port, uriFormat);
+ }
+ }
+ else {
+ if (basePart.IsImplicitFile) {
+#if !PLATFORM_UNIX
+ if (basePart.IsDosPath) {
+ // The FILE DOS path comes as /c:/path, we have to exclude first 3 chars from compression
+ path = Compress(path, 3, ref length, basePart.Syntax);
+ return new string(path, 1, length-1) + extra;
+ }
+ else {
+ left = @"\\" + basePart.GetParts(UriComponents.Host, UriFormat.Unescaped);
+ }
+#else
+ left = basePart.GetParts(UriComponents.Host, UriFormat.Unescaped);
+#endif // !PLATFORM_UNIX
+
+ }
+ else {
+ left = basePart.GetParts(UriComponents.SchemeAndServer|UriComponents.UserInfo, uriFormat);
+ }
+ }
+ //compress the path
+ path = Compress(path, basePart.SecuredPathIndex, ref length, basePart.Syntax);
+ return left + new string(path, 0, length) + extra;
+ }
+
+ //
+ // PathDifference
+ //
+ // Performs the relative path calculation for MakeRelative()
+ //
+ // Inputs:
+ // <argument> path1
+ // <argument> path2
+ // Paths for which we calculate the difference
+ //
+ // <argument> compareCase
+ // False if we consider characters that differ only in case to be
+ // equal
+ //
+ // Returns:
+ // A string which is the relative path difference between <path1> and
+ // <path2> such that if <path1> and the calculated difference are used
+ // as arguments to Combine(), <path2> is returned
+ //
+ // Throws:
+ // Nothing
+ //
+ private static string PathDifference(string path1, string path2, bool compareCase) {
+
+ int i;
+ int si = -1;
+
+ for (i = 0; (i < path1.Length) && (i < path2.Length); ++i) {
+ if ((path1[i] != path2[i])
+ && (compareCase
+ || (Char.ToLower(path1[i], CultureInfo.InvariantCulture)
+ != Char.ToLower(path2[i], CultureInfo.InvariantCulture))))
+ {
+ break;
+
+ } else if (path1[i] == '/') {
+ si = i;
+ }
+ }
+
+ if (i == 0) {
+ return path2;
+ }
+ if ((i == path1.Length) && (i == path2.Length)) {
+ return String.Empty;
+ }
+
+ StringBuilder relPath = new StringBuilder();
+ // Walk down several dirs
+ for (; i < path1.Length; ++i) {
+ if (path1[i] == '/') {
+ relPath.Append("../");
+ }
+ }
+ // Same path except that path1 ended with a file name and path2 didn't
+ if (relPath.Length == 0 && path2.Length - 1 == si)
+ return "./"; // Truncate the file name
+ return relPath.ToString() + path2.Substring(si + 1);
+ }
+
+ //Used by Uribuilder
+ internal bool HasAuthority {
+ get {
+ return InFact(Flags.AuthorityFound);
+ }
+ }
+
+ private static readonly char[] _WSchars = new char[] {' ', '\n', '\r', '\t'};
+ private static bool IsLWS(char ch) {
+
+ return (ch <= ' ') && (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t');
+ }
+
+ //Only consider ASCII characters
+ private static bool IsAsciiLetter(char character) {
+
+ return (character >= 'a' && character <= 'z') ||
+ (character >= 'A' && character <= 'Z');
+ }
+
+ internal static bool IsAsciiLetterOrDigit(char character) {
+ return IsAsciiLetter(character) || (character >= '0' && character <= '9');
+ }
+
+ //
+ // Is this a Bidirectional control char.. These get stripped
+ //
+ internal static bool IsBidiControlCharacter(char ch)
+ {
+ return (ch == '\u200E' /*LRM*/ || ch == '\u200F' /*RLM*/ || ch == '\u202A' /*LRE*/ ||
+ ch == '\u202B' /*RLE*/ || ch == '\u202C' /*PDF*/ || ch == '\u202D' /*LRO*/ ||
+ ch == '\u202E' /*RLO*/);
+ }
+
+ //
+ // Strip Bidirectional control charcters from this string
+ //
+ internal static unsafe string StripBidiControlCharacter(char* strToClean, int start, int length)
+ {
+ if (length <= 0) return "";
+
+ char [] cleanStr = new char[length];
+ int count = 0;
+ for (int i = 0; i < length; ++i){
+ char c = strToClean[start + i];
+ if (c < '\u200E' || c > '\u202E' || !IsBidiControlCharacter(c)){
+ cleanStr[count++] = c;
+ }
+ }
+ return new string(cleanStr, 0, count);
+ }
+
+ //
+ // MakeRelative (toUri)
+ //
+ // Return a relative path which when applied to this Uri would create the
+ // resulting Uri <toUri>
+ //
+ // Inputs:
+ // <argument> toUri
+ // Uri to which we calculate the transformation from this Uri
+ //
+ // Returns:
+ // If the 2 Uri are common except for a relative path difference, then that
+ // difference, else the display name of this Uri
+ //
+ // Throws:
+ // ArgumentNullException, InvalidOperationException
+ //
+ [Obsolete("The method has been deprecated. Please use MakeRelativeUri(Uri uri). http://go.microsoft.com/fwlink/?linkid=14202")]
+ public string MakeRelative(Uri toUri)
+ {
+ if ((object)toUri == null)
+ throw new ArgumentNullException("toUri");
+
+ if (IsNotAbsoluteUri || toUri.IsNotAbsoluteUri)
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+
+ if ((Scheme == toUri.Scheme) && (Host == toUri.Host) && (Port == toUri.Port))
+ return PathDifference(AbsolutePath, toUri.AbsolutePath, !IsUncOrDosPath);
+
+ return toUri.ToString();
+ }
+
+ /// <internalonly/>
+ [Obsolete("The method has been deprecated. It is not used by the system. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected virtual void Parse()
+ {
+ // Microsoft cr: In V1-Everett this method if suppressed by the derived class
+ // would lead to an unconstructed Uri instance.
+ // It does not make any sense and violates Fxcop on calling a virtual method in the ctor.
+ // Should be deprecated and removed asap.
+ }
+ /// <internalonly/>
+ [Obsolete("The method has been deprecated. It is not used by the system. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected virtual void Canonicalize()
+ {
+ // Microsoft cr: In V1-Everett this method if suppressed by the derived class
+ // would lead to supressing of a path compression
+ // It does not make much sense and violates Fxcop on calling a virtual method in the ctor.
+ // Should be deprecated and removed asap.
+ }
+ /// <internalonly/>
+ [Obsolete("The method has been deprecated. It is not used by the system. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected virtual void Escape()
+ {
+ // Microsoft cr: In V1-Everett this method if suppressed by the derived class
+ // would lead to the same effect as dontEscape=true.
+ // It does not make much sense and violates Fxcop on calling a virtual method in the ctor.
+ // Should be deprecated and removed asap.
+ }
+ //
+ // Unescape
+ //
+ // Convert any escape sequences in <path>. Escape sequences can be
+ // hex encoded reserved characters (e.g. %40 == '@') or hex encoded
+ // UTF-8 sequences (e.g. %C4%D2 == 'Latin capital Ligature Ij')
+ //
+ /// <internalonly/>
+ [Obsolete("The method has been deprecated. Please use GetComponents() or static UnescapeDataString() to unescape a Uri component or a string. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected virtual string Unescape(string path) {
+
+ // Microsoft cr: This method is dangerous since it gives path unescaping control
+ // to the derived class without any permission demand.
+ // Should be deprecated and removed asap.
+
+ char[] dest = new char[path.Length];
+ int count = 0;
+ dest = UriHelper.UnescapeString(path, 0, path.Length, dest, ref count, c_DummyChar, c_DummyChar,
+ c_DummyChar, UnescapeMode.Unescape | UnescapeMode.UnescapeAll, null, false);
+ return new string(dest, 0, count);
+ }
+
+ [Obsolete("The method has been deprecated. Please use GetComponents() or static EscapeUriString() to escape a Uri component or a string. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected static string EscapeString(string str) {
+
+ // Microsoft cr: This method just does not make sense sa protected
+ // It should go public static asap
+
+ if ((object)str == null) {
+ return string.Empty;
+ }
+
+ int destStart = 0;
+ char[] dest = UriHelper.EscapeString(str, 0, str.Length, null, ref destStart, true, '?', '#', '%');
+ if ((object)dest == null)
+ return str;
+ return new string(dest, 0, destStart);
+ }
+
+ //
+ // CheckSecurity
+ //
+ // Check for any invalid or problematic character sequences
+ //
+ /// <internalonly/>
+ [Obsolete("The method has been deprecated. It is not used by the system. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected virtual void CheckSecurity() {
+
+ // Microsoft cr: This method just does not make sense
+ // Should be deprecated and removed asap.
+
+ if (Scheme == "telnet") {
+
+ //
+ // remove everything after ';' for telnet
+ //
+
+ }
+ }
+
+ //
+ // IsReservedCharacter
+ //
+ // Determine whether a character is part of the reserved set
+ //
+ // Returns:
+ // true if <character> is reserved else false
+ //
+ /// <internalonly/>
+ [Obsolete("The method has been deprecated. It is not used by the system. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected virtual bool IsReservedCharacter(char character) {
+
+ // Microsoft cr: This method just does not make sense as virtual protected
+ // It should go public static asap
+
+ return (character == ';')
+ || (character == '/')
+ || (character == ':')
+ || (character == '@') // OK FS char
+ || (character == '&')
+ || (character == '=')
+ || (character == '+') // OK FS char
+ || (character == '$') // OK FS char
+ || (character == ',')
+ ;
+ }
+
+ //
+ // IsExcludedCharacter
+ //
+ // Determine if a character should be exluded from a URI and therefore be
+ // escaped
+ //
+ // Returns:
+ // true if <character> should be escaped else false
+ //
+ /// <internalonly/>
+ [Obsolete("The method has been deprecated. It is not used by the system. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected static bool IsExcludedCharacter(char character) {
+
+ // Microsoft cr: This method just does not make sense sa protected
+ // It should go public static asap
+
+ //
+ // the excluded characters...
+ //
+
+ return (character <= 0x20)
+ || (character >= 0x7f)
+ || (character == '<')
+ || (character == '>')
+ || (character == '#')
+ || (character == '%')
+ || (character == '"')
+
+ //
+ // the 'unwise' characters...
+ //
+
+ || (character == '{')
+ || (character == '}')
+ || (character == '|')
+ || (character == '\\')
+ || (character == '^')
+ || (character == '[')
+ || (character == ']')
+ || (character == '`')
+ ;
+ }
+
+ //
+ // IsBadFileSystemCharacter
+ //
+ // Determine whether a character would be an invalid character if used in
+ // a file system name. Note, this is really based on NTFS rules
+ //
+ // Returns:
+ // true if <character> would be a treated as a bad file system character
+ // else false
+ //
+ [Obsolete("The method has been deprecated. It is not used by the system. http://go.microsoft.com/fwlink/?linkid=14202")]
+ protected virtual bool IsBadFileSystemCharacter(char character) {
+
+ // Microsoft cr: This method just does not make sense sa protected virtual
+ // It should go public static asap
+
+ return (character < 0x20)
+ || (character == ';')
+ || (character == '/')
+ || (character == '?')
+ || (character == ':')
+ || (character == '&')
+ || (character == '=')
+ || (character == ',')
+ || (character == '*')
+ || (character == '<')
+ || (character == '>')
+ || (character == '"')
+ || (character == '|')
+ || (character == '\\')
+ || (character == '^')
+ ;
+ }
+
+
+ } // class Uri
+} // namespace System
+
diff --git a/System/net/System/UriExt.cs b/System/net/System/UriExt.cs
new file mode 100644
index 0000000..b9e018e
--- /dev/null
+++ b/System/net/System/UriExt.cs
@@ -0,0 +1,1033 @@
+/*++
+Copyright (c) 2003 Microsoft Corporation
+
+Module Name:
+
+ UriExt.cs
+
+Abstract:
+
+ Uri extensibility model Implementation.
+ This file utilizes partial class feature.
+ Uri.cs file contains core System.Uri functionality.
+
+Author:
+ Alexei Vopilov Nov 21 2003
+
+Revision History:
+
+--*/
+
+namespace System {
+ using System.Globalization;
+ using System.Net;
+ using System.Text;
+ using System.Runtime.InteropServices;
+ using System.Diagnostics;
+
+ public partial class Uri {
+ //
+ // All public ctors go through here
+ //
+ private void CreateThis(string uri, bool dontEscape, UriKind uriKind)
+ {
+ // if (!Enum.IsDefined(typeof(UriKind), uriKind)) -- We currently believe that Enum.IsDefined() is too slow
+ // to be used here.
+ if ((int)uriKind < (int)UriKind.RelativeOrAbsolute || (int)uriKind > (int)UriKind.Relative) {
+ throw new ArgumentException(SR.GetString(SR.net_uri_InvalidUriKind, uriKind));
+ }
+
+ m_String = uri == null? string.Empty: uri;
+
+ if (dontEscape)
+ m_Flags |= Flags.UserEscaped;
+
+ ParsingError err = ParseScheme(m_String, ref m_Flags, ref m_Syntax);
+ UriFormatException e;
+
+ InitializeUri(err, uriKind, out e);
+ if (e != null)
+ throw e;
+ }
+ //
+ private void InitializeUri(ParsingError err, UriKind uriKind, out UriFormatException e)
+ {
+ if (err == ParsingError.None)
+ {
+ if (IsImplicitFile)
+ {
+ // V1 compat VsWhidbey#252282
+ // A relative Uri wins over implicit UNC path unless the UNC path is of the form "\\something" and
+ // uriKind != Absolute
+ if (
+#if !PLATFORM_UNIX
+ NotAny(Flags.DosPath) &&
+#endif // !PLATFORM_UNIX
+ uriKind != UriKind.Absolute &&
+ (uriKind == UriKind.Relative || (m_String.Length >= 2 && (m_String[0] != '\\' || m_String[1] != '\\'))))
+
+ {
+ m_Syntax = null; //make it be relative Uri
+ m_Flags &= Flags.UserEscaped; // the only flag that makes sense for a relative uri
+ e = null;
+ return;
+ // Otheriwse an absolute file Uri wins when it's of the form "\\something"
+ }
+ //
+ // VsWhidbey#423805 and V1 compat issue
+ // We should support relative Uris of the form c:\bla or c:/bla
+ //
+#if !PLATFORM_UNIX
+ else if (uriKind == UriKind.Relative && InFact(Flags.DosPath))
+ {
+ m_Syntax = null; //make it be relative Uri
+ m_Flags &= Flags.UserEscaped; // the only flag that makes sense for a relative uri
+ e = null;
+ return;
+ // Otheriwse an absolute file Uri wins when it's of the form "c:\something"
+ }
+#endif // !PLATFORM_UNIX
+ }
+ }
+ else if (err > ParsingError.LastRelativeUriOkErrIndex)
+ {
+ //This is a fatal error based solely on scheme name parsing
+ m_String = null; // make it be invalid Uri
+ e = GetException(err);
+ return;
+ }
+
+ //
+ //
+ //
+ bool hasUnicode = false;
+
+ // Is there unicode ..
+ if ((!s_ConfigInitialized) && CheckForConfigLoad(m_String)){
+ InitializeUriConfig();
+ }
+
+ m_iriParsing = (s_IriParsing && ((m_Syntax == null) || m_Syntax.InFact(UriSyntaxFlags.AllowIriParsing)));
+
+ if (m_iriParsing &&
+ (CheckForUnicode(m_String) || CheckForEscapedUnreserved(m_String))) {
+ m_Flags |= Flags.HasUnicode;
+ hasUnicode = true;
+ // switch internal strings
+ m_originalUnicodeString = m_String; // original string location changed
+ }
+
+ if (m_Syntax != null)
+ {
+ if (m_Syntax.IsSimple)
+ {
+ if ((err = PrivateParseMinimal()) != ParsingError.None)
+ {
+ if (uriKind != UriKind.Absolute && err <= ParsingError.LastRelativeUriOkErrIndex)
+ {
+ // RFC 3986 Section 5.4.2 - http:(relativeUri) may be considered a valid relative Uri.
+ m_Syntax = null; // convert to relative uri
+ e = null;
+ m_Flags &= Flags.UserEscaped; // the only flag that makes sense for a relative uri
+ }
+ else
+ e = GetException(err);
+ }
+ else if (uriKind == UriKind.Relative)
+ {
+ // Here we know that we can create an absolute Uri, but the user has requested only a relative one
+ e = GetException(ParsingError.CannotCreateRelative);
+ }
+ else
+ e = null;
+ // will return from here
+
+ // Parse unicode and reserved characters only if we're sure that we have an absolute Uri, either because it was
+ // specified via uriKind, or because the parsing error does not indicate that we have a relative URI.
+ if (m_iriParsing && hasUnicode && (uriKind == UriKind.Absolute || err == ParsingError.None))
+ {
+ // In this scenario we need to parse the whole string
+ try
+ {
+ EnsureParseRemaining();
+ }
+ catch (UriFormatException ex)
+ {
+ if (ServicePointManager.AllowAllUriEncodingExpansion)
+ {
+ throw;
+ }
+ else
+ {
+ e = ex;
+ return;
+ }
+ }
+ }
+ }
+ else
+ {
+ // offer custom parser to create a parsing context
+ m_Syntax = m_Syntax.InternalOnNewUri();
+
+ // incase they won't call us
+ m_Flags |= Flags.UserDrivenParsing;
+
+ // Ask a registered type to validate this uri
+ m_Syntax.InternalValidate(this, out e);
+
+ if (e != null)
+ {
+ // Can we still take it as a relative Uri?
+ if (uriKind != UriKind.Absolute && err != ParsingError.None
+ && err <= ParsingError.LastRelativeUriOkErrIndex)
+ {
+ m_Syntax = null; // convert it to relative
+ e = null;
+ m_Flags &= Flags.UserEscaped; // the only flag that makes sense for a relative uri
+ }
+ }
+ else // e == null
+ {
+ if (err != ParsingError.None || InFact(Flags.ErrorOrParsingRecursion))
+ {
+ // User parser took over on an invalid Uri
+ SetUserDrivenParsing();
+ }
+ else if (uriKind == UriKind.Relative)
+ {
+ // Here we know that custom parser can create an absolute Uri, but the user has requested only a
+ // relative one
+ e = GetException(ParsingError.CannotCreateRelative);
+ }
+
+ if (m_iriParsing && hasUnicode){
+ // In this scenario we need to parse the whole string
+ try
+ {
+ EnsureParseRemaining();
+ }
+ catch (UriFormatException ex)
+ {
+ if (ServicePointManager.AllowAllUriEncodingExpansion)
+ {
+ throw;
+ }
+ else
+ {
+ e = ex;
+ return;
+ }
+ }
+ }
+
+ }
+ // will return from here
+ }
+ }
+ // If we encountered any parsing errors that indicate this may be a relative Uri,
+ // and we'll allow relative Uri's, then create one.
+ else if (err != ParsingError.None && uriKind != UriKind.Absolute
+ && err <= ParsingError.LastRelativeUriOkErrIndex)
+ {
+ e = null;
+ m_Flags &= (Flags.UserEscaped | Flags.HasUnicode); // the only flags that makes sense for a relative uri
+ if (m_iriParsing && hasUnicode)
+ {
+ // Iri'ze and then normalize relative uris
+ m_String = EscapeUnescapeIri(m_originalUnicodeString, 0, m_originalUnicodeString.Length,
+ (UriComponents)0);
+ try
+ {
+ if (UriParser.ShouldUseLegacyV2Quirks)
+ m_String = m_String.Normalize(NormalizationForm.FormC);
+ }
+ catch (ArgumentException)
+ {
+ e = GetException(ParsingError.BadFormat);
+ }
+ }
+ }
+ else
+ {
+ m_String = null; // make it be invalid Uri
+ e = GetException(err);
+ }
+ }
+
+ //
+ // Checks if there are any unicode or escaped chars or ace to determine whether to load
+ // config
+ //
+ private unsafe bool CheckForConfigLoad(String data)
+ {
+ bool initConfig = false;
+ int length = data.Length;
+
+ fixed (char* temp = data){
+ for (int i = 0; i < length; ++i){
+
+ if ((temp[i] > '\x7f') || (temp[i] == '%') ||
+ ((temp[i] == 'x') && ((i + 3) < length) && (temp[i + 1] == 'n') && (temp[i + 2] == '-') && (temp[i + 3] == '-')))
+ {
+
+ // Unicode or maybe ace
+ initConfig = true;
+ break;
+ }
+ }
+
+
+ }
+
+ return initConfig;
+ }
+
+ //
+ // Unescapes entire string and checks if it has unicode chars
+ //
+ private bool CheckForUnicode(String data)
+ {
+ bool hasUnicode = false;
+ char[] chars = new char[data.Length];
+ int count = 0;
+
+ chars = UriHelper.UnescapeString(data, 0, data.Length, chars, ref count, c_DummyChar, c_DummyChar,
+ c_DummyChar, UnescapeMode.Unescape | UnescapeMode.UnescapeAll, null, false);
+
+ for (int i = 0; i < count; ++i){
+ if (chars[i] > '\x7f'){
+ // Unicode
+ hasUnicode = true;
+ break;
+ }
+ }
+ return hasUnicode;
+ }
+
+ // Does this string have any %6A sequences that are 3986 Unreserved characters? These should be un-escaped.
+ private unsafe bool CheckForEscapedUnreserved(String data)
+ {
+ fixed (char* tempPtr = data)
+ {
+ for (int i = 0; i < data.Length - 2; ++i)
+ {
+ if (tempPtr[i] == '%' && IsHexDigit(tempPtr[i + 1]) && IsHexDigit(tempPtr[i + 2])
+ && tempPtr[i + 1] >= '0' && tempPtr[i + 1] <= '7') // max 0x7F
+ {
+ char ch = UriHelper.EscapedAscii(tempPtr[i + 1], tempPtr[i + 2]);
+ if (ch != c_DummyChar && UriHelper.Is3986Unreserved(ch))
+ {
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ //
+ //
+ // Returns true if the string represents a valid argument to the Uri ctor
+ // If uriKind != AbsoluteUri then certain parsing erros are ignored but Uri usage is limited
+ //
+ public static bool TryCreate(string uriString, UriKind uriKind, out Uri result)
+ {
+ if ((object)uriString == null)
+ {
+ result = null;
+ return false;
+ }
+ UriFormatException e = null;
+ result = CreateHelper(uriString, false, uriKind, ref e);
+ return (object) e == null && result != null;
+ }
+ //
+ public static bool TryCreate(Uri baseUri, string relativeUri, out Uri result)
+ {
+ Uri relativeLink;
+ if (TryCreate(relativeUri, UriKind.RelativeOrAbsolute, out relativeLink))
+ {
+ if (!relativeLink.IsAbsoluteUri)
+ return TryCreate(baseUri, relativeLink, out result);
+
+ result = relativeLink;
+ return true;
+ }
+ result = null;
+ return false;
+ }
+ //
+ public static bool TryCreate(Uri baseUri, Uri relativeUri, out Uri result)
+ {
+ result = null;
+
+ //Consider: Work out the baseUri==null case
+ if ((object)baseUri == null || (object)relativeUri == null)
+ return false;
+
+ if (baseUri.IsNotAbsoluteUri)
+ return false;
+
+ UriFormatException e;
+ string newUriString = null;
+
+ bool dontEscape;
+ if (baseUri.Syntax.IsSimple)
+ {
+ dontEscape = relativeUri.UserEscaped;
+ result = ResolveHelper(baseUri, relativeUri, ref newUriString, ref dontEscape, out e);
+ }
+ else
+ {
+ dontEscape = false;
+ newUriString = baseUri.Syntax.InternalResolve(baseUri, relativeUri, out e);
+ }
+
+ if (e != null)
+ return false;
+
+ if ((object) result == null)
+ result = CreateHelper(newUriString, dontEscape, UriKind.Absolute, ref e);
+
+ return (object) e == null && result != null && result.IsAbsoluteUri;
+ }
+ //
+ //
+ public string GetComponents(UriComponents components, UriFormat format)
+ {
+ if (((components & UriComponents.SerializationInfoString) != 0) && components != UriComponents.SerializationInfoString)
+ throw new ArgumentOutOfRangeException("components", components, SR.GetString(SR.net_uri_NotJustSerialization));
+
+ if ((format & ~UriFormat.SafeUnescaped) != 0)
+ throw new ArgumentOutOfRangeException("format");
+
+ if (IsNotAbsoluteUri)
+ {
+ if (components == UriComponents.SerializationInfoString)
+ return GetRelativeSerializationString(format);
+ else
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NotAbsolute));
+ }
+
+ if (Syntax.IsSimple)
+ return GetComponentsHelper(components, format);
+
+ return Syntax.InternalGetComponents(this, components, format);
+ }
+ //
+ //
+ // This is for languages that do not support == != operators overloading
+ //
+ // Note that Uri.Equals will get an optimized path but is limited to true/fasle result only
+ //
+ public static int Compare(Uri uri1, Uri uri2, UriComponents partsToCompare, UriFormat compareFormat,
+ StringComparison comparisonType)
+ {
+
+ if ((object) uri1 == null)
+ {
+ if (uri2 == null)
+ return 0; // Equal
+ return -1; // null < non-null
+ }
+ if ((object) uri2 == null)
+ return 1; // non-null > null
+
+ // a relative uri is always less than an absolute one
+ if (!uri1.IsAbsoluteUri || !uri2.IsAbsoluteUri)
+ return uri1.IsAbsoluteUri? 1: uri2.IsAbsoluteUri? -1: string.Compare(uri1.OriginalString,
+ uri2.OriginalString, comparisonType);
+
+ return string.Compare(
+ uri1.GetParts(partsToCompare, compareFormat),
+ uri2.GetParts(partsToCompare, compareFormat),
+ comparisonType
+ );
+ }
+
+ public bool IsWellFormedOriginalString()
+ {
+ if (IsNotAbsoluteUri || Syntax.IsSimple)
+ return InternalIsWellFormedOriginalString();
+
+ return Syntax.InternalIsWellFormedOriginalString(this);
+ }
+
+ // Consider: (perf) Making it to not create a Uri internally
+ public static bool IsWellFormedUriString(string uriString, UriKind uriKind)
+ {
+ Uri result;
+
+ if (!Uri.TryCreate(uriString, uriKind, out result))
+ return false;
+
+ return result.IsWellFormedOriginalString();
+ }
+
+ //
+ // Internal stuff
+ //
+
+ // Returns false if OriginalString value
+ // (1) is not correctly escaped as per URI spec excluding intl UNC name case
+ // (2) or is an absolute Uri that represents implicit file Uri "c:\dir\file"
+ // (3) or is an absolute Uri that misses a slash before path "file://c:/dir/file"
+ // (4) or contains unescaped backslashes even if they will be treated
+ // as forward slashes like http:\\host/path\file or file:\\\c:\path
+ //
+ internal unsafe bool InternalIsWellFormedOriginalString()
+ {
+ if (UserDrivenParsing)
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_UserDrivenParsing, this.GetType().FullName));
+
+ fixed (char* str = m_String)
+ {
+ ushort idx = 0;
+ //
+ // For a relative Uri we only care about escaping and backslashes
+ //
+ if (!IsAbsoluteUri)
+ {
+ // my:scheme/path?query is not well formed because the colon is ambiguous
+ if (!UriParser.ShouldUseLegacyV2Quirks && CheckForColonInFirstPathSegment(m_String))
+ {
+ return false;
+ }
+ return (CheckCanonical(str, ref idx, (ushort)m_String.Length, c_EOL)
+ & (Check.BackslashInPath | Check.EscapedCanonical)) == Check.EscapedCanonical;
+ }
+
+ //
+ // (2) or is an absolute Uri that represents implicit file Uri "c:\dir\file"
+ //
+ if (IsImplicitFile)
+ return false;
+
+ //This will get all the offsets, a Host name will be checked separatelly below
+ EnsureParseRemaining();
+
+ Flags nonCanonical = (m_Flags & (Flags.E_CannotDisplayCanonical | Flags.IriCanonical));
+ // User, Path, Query or Fragment may have some non escaped characters
+ if (((nonCanonical & Flags.E_CannotDisplayCanonical & (Flags.E_UserNotCanonical | Flags.E_PathNotCanonical |
+ Flags.E_QueryNotCanonical | Flags.E_FragmentNotCanonical)) != Flags.Zero) &&
+ (!m_iriParsing || (m_iriParsing &&
+ (((nonCanonical & Flags.E_UserNotCanonical) == 0) || ((nonCanonical & Flags.UserIriCanonical) == 0)) &&
+ (((nonCanonical & Flags.E_PathNotCanonical) == 0) || ((nonCanonical & Flags.PathIriCanonical) == 0)) &&
+ (((nonCanonical & Flags.E_QueryNotCanonical) == 0) || ((nonCanonical & Flags.QueryIriCanonical) == 0)) &&
+ (((nonCanonical & Flags.E_FragmentNotCanonical) == 0) || ((nonCanonical & Flags.FragmentIriCanonical) == 0)))))
+ {
+ return false;
+ }
+
+ // checking on scheme:\\ or file:////
+ if (InFact(Flags.AuthorityFound))
+ {
+ idx = (ushort)(m_Info.Offset.Scheme + m_Syntax.SchemeName.Length + 2);
+ if (idx >= m_Info.Offset.User || m_String[idx - 1] == '\\' || m_String[idx] == '\\')
+ return false;
+
+#if !PLATFORM_UNIX
+ if (InFact(Flags.UncPath | Flags.DosPath))
+ {
+ while (++idx < m_Info.Offset.User && (m_String[idx] == '/' || m_String[idx] == '\\'))
+ return false;
+ }
+#endif // !PLATFORM_UNIX
+ }
+
+
+ // (3) or is an absolute Uri that misses a slash before path "file://c:/dir/file"
+ // Note that for this check to be more general we assert that if Path is non empty and if it requires a first slash
+ // (which looks absent) then the method has to fail.
+ // Today it's only possible for a Dos like path, i.e. file://c:/bla would fail below check.
+ if (InFact(Flags.FirstSlashAbsent) && m_Info.Offset.Query > m_Info.Offset.Path)
+ return false;
+
+ // (4) or contains unescaped backslashes even if they will be treated
+ // as forward slashes like http:\\host/path\file or file:\\\c:\path
+ // Note we do not check for Flags.ShouldBeCompressed i.e. allow // /./ and alike as valid
+ if (InFact(Flags.BackslashInPath))
+ return false;
+
+ // Capturing a rare case like file:///c|/dir
+ if (IsDosPath && m_String[m_Info.Offset.Path + SecuredPathIndex - 1] == '|')
+ return false;
+
+ //
+ // May need some real CPU processing to anwser the request
+ //
+ //
+ // Check escaping for authority
+ //
+ // IPv6 hosts cannot be properly validated by CheckCannonical
+ if ((m_Flags & Flags.CanonicalDnsHost) == 0 && HostType != Flags.IPv6HostType)
+ {
+ idx = m_Info.Offset.User;
+ Check result = CheckCanonical(str, ref idx, (ushort)m_Info.Offset.Path, '/');
+ if (((result & (Check.ReservedFound | Check.BackslashInPath | Check.EscapedCanonical))
+ != Check.EscapedCanonical)
+ && (!m_iriParsing || (m_iriParsing
+ && ((result & (Check.DisplayCanonical | Check.FoundNonAscii | Check.NotIriCanonical))
+ != (Check.DisplayCanonical | Check.FoundNonAscii)))))
+ {
+ return false;
+ }
+ }
+
+ // Want to ensure there are slashes after the scheme
+ if ((m_Flags & (Flags.SchemeNotCanonical | Flags.AuthorityFound))
+ == (Flags.SchemeNotCanonical | Flags.AuthorityFound))
+ {
+ idx = (ushort)m_Syntax.SchemeName.Length;
+ while (str[idx++] != ':') ;
+ if (idx + 1 >= m_String.Length || str[idx] != '/' || str[idx + 1] != '/')
+ return false;
+ }
+ }
+ //
+ // May be scheme, host, port or path need some canonicalization but still the uri string is found to be a
+ // "well formed" one
+ //
+ return true;
+ }
+
+ //
+ //
+ //
+ public static string UnescapeDataString(string stringToUnescape)
+ {
+ if ((object) stringToUnescape == null)
+ throw new ArgumentNullException("stringToUnescape");
+
+ if (stringToUnescape.Length == 0)
+ return string.Empty;
+
+ unsafe {
+ fixed (char* pStr = stringToUnescape)
+ {
+ int position;
+ for (position = 0; position < stringToUnescape.Length; ++position)
+ if (pStr[position] == '%')
+ break;
+
+ if (position == stringToUnescape.Length)
+ return stringToUnescape;
+
+ UnescapeMode unescapeMode = UnescapeMode.Unescape | UnescapeMode.UnescapeAll;
+ position = 0;
+ char[] dest = new char[stringToUnescape.Length];
+ dest = UriHelper.UnescapeString(stringToUnescape, 0, stringToUnescape.Length, dest, ref position,
+ c_DummyChar, c_DummyChar, c_DummyChar, unescapeMode, null, false);
+ return new string(dest, 0, position);
+ }
+ }
+ }
+ //
+ // Where stringToEscape is intented to be a completely unescaped URI string.
+ // This method will escape any character that is not a reserved or unreserved character, including percent signs.
+ // Note that EscapeUriString will also do not escape a '#' sign.
+ //
+ public static string EscapeUriString(string stringToEscape)
+ {
+ if ((object)stringToEscape == null)
+ throw new ArgumentNullException("stringToEscape");
+
+ if (stringToEscape.Length == 0)
+ return string.Empty;
+
+ int position = 0;
+ char[] dest = UriHelper.EscapeString(stringToEscape, 0, stringToEscape.Length, null, ref position, true,
+ c_DummyChar, c_DummyChar, c_DummyChar);
+ if ((object) dest == null)
+ return stringToEscape;
+ return new string(dest, 0, position);
+ }
+ //
+ // Where stringToEscape is intended to be URI data, but not an entire URI.
+ // This method will escape any character that is not an unreserved character, including percent signs.
+ //
+ public static string EscapeDataString(string stringToEscape)
+ {
+ if ((object) stringToEscape == null)
+ throw new ArgumentNullException("stringToEscape");
+
+ if (stringToEscape.Length == 0)
+ return string.Empty;
+
+ int position = 0;
+ char[] dest = UriHelper.EscapeString(stringToEscape, 0, stringToEscape.Length, null, ref position, false,
+ c_DummyChar, c_DummyChar, c_DummyChar);
+ if (dest == null)
+ return stringToEscape;
+ return new string(dest, 0, position);
+ }
+
+ //
+ // Cleans up the specified component according to Iri rules
+ // a) Chars allowed by iri in a component are unescaped if found escaped
+ // b) Bidi chars are stripped
+ //
+ // should be called only if IRI parsing is switched on
+ internal unsafe string EscapeUnescapeIri(string input, int start, int end, UriComponents component)
+ {
+ fixed (char *pInput = input)
+ {
+ return IriHelper.EscapeUnescapeIri(pInput, start, end, component);
+ }
+ }
+
+ // Should never be used except by the below method
+ private Uri(Flags flags, UriParser uriParser, string uri)
+ {
+ m_Flags = flags;
+ m_Syntax = uriParser;
+ m_String = uri;
+ }
+ //
+ // a Uri.TryCreate() method goes through here.
+ //
+ internal static Uri CreateHelper(string uriString, bool dontEscape, UriKind uriKind, ref UriFormatException e)
+ {
+ // if (!Enum.IsDefined(typeof(UriKind), uriKind)) -- We currently believe that Enum.IsDefined() is too slow
+ // to be used here.
+ if ((int)uriKind < (int)UriKind.RelativeOrAbsolute || (int)uriKind > (int)UriKind.Relative){
+ throw new ArgumentException(SR.GetString(SR.net_uri_InvalidUriKind, uriKind));
+ }
+
+ UriParser syntax = null;
+ Flags flags = Flags.Zero;
+ ParsingError err = ParseScheme(uriString, ref flags, ref syntax);
+
+ if (dontEscape)
+ flags |= Flags.UserEscaped;
+
+ // We won't use User factory for these errors
+ if (err != ParsingError.None)
+ {
+ // If it looks as a relative Uri, custom factory is ignored
+ if (uriKind != UriKind.Absolute && err <= ParsingError.LastRelativeUriOkErrIndex)
+ return new Uri((flags & Flags.UserEscaped), null, uriString);
+
+ return null;
+ }
+
+ // Cannot be relative Uri if came here
+ Uri result = new Uri(flags, syntax, uriString);
+
+ // Validate instance using ether built in or a user Parser
+ try
+ {
+ result.InitializeUri(err, uriKind, out e);
+
+ if (e == null)
+ return result;
+
+ return null;
+ }
+ catch (UriFormatException ee)
+ {
+ Debug.Assert(!syntax.IsSimple, "A UriPraser threw on InitializeAndValidate.");
+ e = ee;
+ // A precaution since custom Parser should never throw in this case.
+ return null;
+ }
+ }
+ //
+ // Resolves into either baseUri or relativeUri according to conditions OR if not possible it uses newUriString
+ // to return combined URI strings from both Uris
+ // otherwise if e != null on output the operation has failed
+ //
+
+ internal static Uri ResolveHelper(Uri baseUri, Uri relativeUri, ref string newUriString, ref bool userEscaped,
+ out UriFormatException e)
+ {
+ Debug.Assert(!baseUri.IsNotAbsoluteUri && !baseUri.UserDrivenParsing, "Uri::ResolveHelper()|baseUri is not Absolute or is controlled by User Parser.");
+
+ e = null;
+ string relativeStr = string.Empty;
+
+ if ((object)relativeUri != null)
+ {
+ if (relativeUri.IsAbsoluteUri)
+ return relativeUri;
+
+ relativeStr = relativeUri.OriginalString;
+ userEscaped = relativeUri.UserEscaped;
+ }
+ else
+ relativeStr = string.Empty;
+
+ // Here we can assert that passed "relativeUri" is indeed a relative one
+
+ if (relativeStr.Length > 0 && (IsLWS(relativeStr[0]) || IsLWS(relativeStr[relativeStr.Length - 1])))
+ relativeStr = relativeStr.Trim(_WSchars);
+
+ if (relativeStr.Length == 0)
+ {
+ newUriString = baseUri.GetParts(UriComponents.AbsoluteUri,
+ baseUri.UserEscaped ? UriFormat.UriEscaped : UriFormat.SafeUnescaped);
+ return null;
+ }
+
+ // Check for a simple fragment in relative part
+ if (relativeStr[0] == '#' && !baseUri.IsImplicitFile && baseUri.Syntax.InFact(UriSyntaxFlags.MayHaveFragment))
+ {
+ newUriString = baseUri.GetParts(UriComponents.AbsoluteUri & ~UriComponents.Fragment,
+ UriFormat.UriEscaped) + relativeStr;
+ return null;
+ }
+
+ // Check for a simple query in relative part
+ if (relativeStr[0] == '?' && !baseUri.IsImplicitFile && baseUri.Syntax.InFact(UriSyntaxFlags.MayHaveQuery))
+ {
+ newUriString = baseUri.GetParts(UriComponents.AbsoluteUri & ~UriComponents.Query & ~UriComponents.Fragment,
+ UriFormat.UriEscaped) + relativeStr;
+ return null;
+ }
+
+ // Check on the DOS path in the relative Uri (a special case)
+ if (relativeStr.Length >= 3
+ && (relativeStr[1] == ':' || relativeStr[1] == '|')
+ && IsAsciiLetter(relativeStr[0])
+ && (relativeStr[2] == '\\' || relativeStr[2] == '/'))
+ {
+
+ if (baseUri.IsImplicitFile)
+ {
+ // It could have file:/// prepended to the result but we want to keep it as *Implicit* File Uri
+ newUriString = relativeStr;
+ return null;
+ }
+ else if (baseUri.Syntax.InFact(UriSyntaxFlags.AllowDOSPath))
+ {
+ // The scheme is not changed just the path gets replaced
+ string prefix;
+ if (baseUri.InFact(Flags.AuthorityFound))
+ prefix = baseUri.Syntax.InFact(UriSyntaxFlags.PathIsRooted) ? ":///" : "://";
+ else
+ prefix = baseUri.Syntax.InFact(UriSyntaxFlags.PathIsRooted) ? ":/" : ":";
+
+ newUriString = baseUri.Scheme + prefix + relativeStr;
+ return null;
+ }
+ // If we are here then input like "http://host/path/" + "C:\x" will produce the result http://host/path/c:/x
+ }
+
+
+ ParsingError err = GetCombinedString(baseUri, relativeStr, userEscaped, ref newUriString);
+
+ if (err != ParsingError.None)
+ {
+ e = GetException(err);
+ return null;
+ }
+
+ if ((object)newUriString == (object)baseUri.m_String)
+ return baseUri;
+
+ return null;
+ }
+
+ private unsafe string GetRelativeSerializationString(UriFormat format)
+ {
+ if (format == UriFormat.UriEscaped)
+ {
+ if (m_String.Length == 0)
+ return string.Empty;
+ int position = 0;
+ char[] dest = UriHelper.EscapeString(m_String, 0, m_String.Length, null, ref position, true,
+ c_DummyChar, c_DummyChar, '%');
+ if ((object)dest == null)
+ return m_String;
+ return new string(dest, 0, position);
+ }
+
+ else if (format == UriFormat.Unescaped)
+ return UnescapeDataString(m_String);
+
+ else if (format == UriFormat.SafeUnescaped)
+ {
+ if (m_String.Length == 0)
+ return string.Empty;
+
+ char[] dest = new char[m_String.Length];
+ int position = 0;
+ dest = UriHelper.UnescapeString(m_String, 0, m_String.Length, dest, ref position, c_DummyChar,
+ c_DummyChar, c_DummyChar, UnescapeMode.EscapeUnescape, null, false);
+ return new string(dest, 0, position);
+ }
+ else
+ throw new ArgumentOutOfRangeException("format");
+
+ }
+
+ //
+ // UriParser helpers methods
+ //
+ internal string GetComponentsHelper(UriComponents uriComponents, UriFormat uriFormat)
+ {
+ if (uriComponents == UriComponents.Scheme)
+ return m_Syntax.SchemeName;
+
+ // A serialzation info is "almost" the same as AbsoluteUri except for IPv6 + ScopeID hostname case
+ if ((uriComponents & UriComponents.SerializationInfoString) != 0)
+ uriComponents |= UriComponents.AbsoluteUri;
+
+ //This will get all the offsets, HostString will be created below if needed
+ EnsureParseRemaining();
+
+ if ((uriComponents & UriComponents.NormalizedHost) != 0)
+ {
+ // Down the path we rely on Host to be ON for NormalizedHost
+ uriComponents |= UriComponents.Host;
+ }
+
+ //Check to see if we need the host/authotity string
+ if ((uriComponents & UriComponents.Host) != 0)
+ EnsureHostString(true);
+
+ //This, single Port request is always processed here
+ if (uriComponents == UriComponents.Port || uriComponents == UriComponents.StrongPort)
+ {
+ if (((m_Flags & Flags.NotDefaultPort) != 0) || (uriComponents == UriComponents.StrongPort
+ && m_Syntax.DefaultPort != UriParser.NoDefaultPort))
+ {
+ // recreate string from the port value
+ return m_Info.Offset.PortValue.ToString(CultureInfo.InvariantCulture);
+ }
+ return string.Empty;
+ }
+
+ if ((uriComponents & UriComponents.StrongPort) != 0)
+ {
+ // Down the path we rely on Port to be ON for StrongPort
+ uriComponents |= UriComponents.Port;
+ }
+
+ //This request sometime is faster to process here
+ if (uriComponents == UriComponents.Host && (uriFormat == UriFormat.UriEscaped
+ || (( m_Flags & (Flags.HostNotCanonical | Flags.E_HostNotCanonical)) == 0)))
+ {
+ EnsureHostString(false);
+ return m_Info.Host;
+ }
+
+ switch (uriFormat)
+ {
+ case UriFormat.UriEscaped:
+ return GetEscapedParts(uriComponents);
+
+ case V1ToStringUnescape:
+ case UriFormat.SafeUnescaped:
+ case UriFormat.Unescaped:
+ return GetUnescapedParts(uriComponents, uriFormat);
+
+ default:
+ throw new ArgumentOutOfRangeException("uriFormat");
+ }
+ }
+ //
+ //
+ public bool IsBaseOf(Uri uri)
+ {
+ if ((object)uri == null)
+ throw new ArgumentNullException("uri");
+
+ if (!IsAbsoluteUri)
+ return false;
+
+ if (Syntax.IsSimple)
+ return IsBaseOfHelper(uri);
+
+ return Syntax.InternalIsBaseOf(this, uri);
+ }
+ //
+ //
+ //
+ internal bool IsBaseOfHelper(Uri uriLink)
+ {
+ //TO
+ if (!IsAbsoluteUri || UserDrivenParsing)
+ return false;
+
+ if (!uriLink.IsAbsoluteUri)
+ {
+ //a relative uri could have quite tricky form, it's better to fix it now.
+ string newUriString = null;
+ UriFormatException e;
+ bool dontEscape = false;
+
+ uriLink = ResolveHelper(this, uriLink, ref newUriString, ref dontEscape, out e);
+ if (e != null)
+ return false;
+
+ if ((object)uriLink == null)
+ uriLink = CreateHelper(newUriString, dontEscape, UriKind.Absolute, ref e);
+
+ if (e != null)
+ return false;
+ }
+
+ if (Syntax.SchemeName != uriLink.Syntax.SchemeName)
+ return false;
+
+ // Canonicalize and test for substring match up to the last path slash
+ string me = GetParts(UriComponents.AbsoluteUri & ~UriComponents.Fragment, UriFormat.SafeUnescaped);
+ string she = uriLink.GetParts(UriComponents.AbsoluteUri & ~UriComponents.Fragment, UriFormat.SafeUnescaped);
+
+ unsafe
+ {
+ fixed (char* pMe = me)
+ {
+ fixed (char* pShe = she)
+ {
+ return UriHelper.TestForSubPath(pMe, (ushort)me.Length, pShe, (ushort)she.Length,
+ IsUncOrDosPath || uriLink.IsUncOrDosPath);
+ }
+ }
+ }
+ }
+ //
+ // Only a ctor time call
+ //
+ private void CreateThisFromUri(Uri otherUri)
+ {
+ // Clone the other guy but develop own UriInfo member
+ m_Info = null;
+
+ m_Flags = otherUri.m_Flags;
+ if (InFact(Flags.MinimalUriInfoSet))
+ {
+ m_Flags &= ~(Flags.MinimalUriInfoSet | Flags.AllUriInfoSet | Flags.IndexMask);
+ // Port / Path offset
+ int portIndex = otherUri.m_Info.Offset.Path;
+ if (InFact(Flags.NotDefaultPort))
+ {
+ // Find the start of the port. Account for non-canonical ports like :00123
+ while (otherUri.m_String[portIndex] != ':' && portIndex > otherUri.m_Info.Offset.Host)
+ {
+ portIndex--;
+ }
+ if (otherUri.m_String[portIndex] != ':')
+ {
+ // Something wrong with the NotDefaultPort flag. Reset to path index
+ Debug.Assert(false, "Uri failed to locate custom port at index: " + portIndex);
+ portIndex = otherUri.m_Info.Offset.Path;
+ }
+ }
+ m_Flags |= (Flags)portIndex; // Port or path
+ }
+
+ m_Syntax = otherUri.m_Syntax;
+ m_String = otherUri.m_String;
+ m_iriParsing = otherUri.m_iriParsing;
+ if (otherUri.OriginalStringSwitched){
+ m_originalUnicodeString = otherUri.m_originalUnicodeString;
+ }
+ if (otherUri.AllowIdn && (otherUri.InFact(Flags.IdnHost) || otherUri.InFact(Flags.UnicodeHost))){
+ m_DnsSafeHost = otherUri.m_DnsSafeHost;
+ }
+ }
+ }
+}
diff --git a/System/net/System/UriHelper.cs b/System/net/System/UriHelper.cs
new file mode 100644
index 0000000..f81a765
--- /dev/null
+++ b/System/net/System/UriHelper.cs
@@ -0,0 +1,731 @@
+namespace System
+{
+ using System.Globalization;
+ using System.Text;
+ using System.Diagnostics;
+
+ internal static class UriHelper
+ {
+ private static readonly char[] HexUpperChars = {
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+ // http://host/Path/Path/File?Query is the base of
+ // - http://host/Path/Path/File/ ... (those "File" words may be different in semantic but anyway)
+ // - http://host/Path/Path/#Fragment
+ // - http://host/Path/Path/?Query
+ // - http://host/Path/Path/MoreDir/ ...
+ // - http://host/Path/Path/OtherFile?Query
+ // - http://host/Path/Path/Fl
+ // - http://host/Path/Path/
+ //
+ // It is not a base for
+ // - http://host/Path/Path (that last "Path" is not considered as a directory)
+ // - http://host/Path/Path?Query
+ // - http://host/Path/Path#Fragment
+ // - http://host/Path/Path2/
+ // - http://host/Path/Path2/MoreDir
+ // - http://host/Path/File
+ //
+ // ASSUMES that strings like http://host/Path/Path/MoreDir/../../ have been canonicalized before going to this method.
+ // ASSUMES that back slashes already have been converted if applicable.
+ //
+ internal static unsafe bool TestForSubPath( char* pMe, ushort meLength, char* pShe, ushort sheLength,
+ bool ignoreCase)
+ {
+ ushort i = 0;
+ char chMe;
+ char chShe;
+
+ bool AllSameBeforeSlash = true;
+
+ for( ;i < meLength && i < sheLength; ++i)
+ {
+ chMe = *(pMe+i);
+ chShe = *(pShe+i);
+
+ if (chMe == '?' || chMe == '#')
+ {
+ // survived so far and pMe does not have any more path segments
+ return true;
+ }
+
+ // If pMe terminates a path segment, so must pShe
+ if (chMe == '/')
+ {
+ if (chShe != '/')
+ {
+ // comparison has falied
+ return false;
+ }
+ // plus the segments must be the same
+ if (!AllSameBeforeSlash)
+ {
+ // comparison has falied
+ return false;
+ }
+ //so far so good
+ AllSameBeforeSlash = true;
+ continue;
+ }
+
+ // if pShe terminates then pMe must not have any more path segments
+ if (chShe == '?' || chShe == '#')
+ {
+ break;
+ }
+
+ if (!ignoreCase)
+ {
+ if (chMe != chShe)
+ {
+ AllSameBeforeSlash = false;
+ }
+ }
+ else
+ {
+ if (Char.ToLower(chMe, CultureInfo.InvariantCulture) != Char.ToLower(chShe, CultureInfo.InvariantCulture))
+ {
+ AllSameBeforeSlash = false;
+ }
+ }
+ }
+
+ // If me is longer then it must not have any more path segments
+ for (; i < meLength; ++i)
+ {
+ if ((chMe = *(pMe+i)) == '?' || chMe == '#')
+ {
+ return true;
+ }
+ if (chMe == '/')
+ {
+ return false;
+ }
+ }
+ //survived by getting to the end of pMe
+ return true;
+ }
+
+ // - forceX characters are always escaped if found
+ // - rsvd character will remain unescaped
+ //
+ // start - starting offset from input
+ // end - the exclusive ending offset in input
+ // destPos - starting offset in dest for output, on return this will be an exclusive "end" in the output.
+ //
+ // In case "dest" has lack of space it will be reallocated by preserving the _whole_ content up to current destPos
+ //
+ // Returns null if nothing has to be escaped AND passed dest was null, otherwise the resulting array with the updated destPos
+ //
+ const short c_MaxAsciiCharsReallocate = 40;
+ const short c_MaxUnicodeCharsReallocate = 40;
+ const short c_MaxUTF_8BytesPerUnicodeChar = 4;
+ const short c_EncodedCharsPerByte = 3;
+ internal unsafe static char[] EscapeString(string input, int start, int end, char[] dest, ref int destPos,
+ bool isUriString, char force1, char force2, char rsvd)
+ {
+ if (end - start >= Uri.c_MaxUriBufferSize)
+ throw new UriFormatException(SR.GetString(SR.net_uri_SizeLimit));
+
+ int i = start;
+ int prevInputPos = start;
+ byte *bytes = stackalloc byte[c_MaxUnicodeCharsReallocate*c_MaxUTF_8BytesPerUnicodeChar]; // 40*4=160
+
+ fixed (char* pStr = input)
+ {
+ for(; i < end; ++i)
+ {
+ char ch = pStr[i];
+
+ // a Unicode ?
+ if (ch > '\x7F')
+ {
+ short maxSize = (short)Math.Min(end - i, (int)c_MaxUnicodeCharsReallocate-1);
+
+ short count = 1;
+ for (; count < maxSize && pStr[i + count] > '\x7f'; ++count)
+ ;
+
+ // Is the last a high surrogate?
+ if (pStr[i + count-1] >= 0xD800 && pStr[i + count-1] <= 0xDBFF)
+ {
+ // Should be a rare case where the app tries to feed an invalid Unicode surrogates pair
+ if (count == 1 || count == end - i)
+ throw new UriFormatException(SR.GetString(SR.net_uri_BadString));
+ // need to grab one more char as a Surrogate except when it's a bogus input
+ ++count;
+ }
+
+ dest = EnsureDestinationSize(pStr, dest, i,
+ (short)(count * c_MaxUTF_8BytesPerUnicodeChar * c_EncodedCharsPerByte),
+ c_MaxUnicodeCharsReallocate * c_MaxUTF_8BytesPerUnicodeChar * c_EncodedCharsPerByte,
+ ref destPos, prevInputPos);
+
+ short numberOfBytes = (short)Encoding.UTF8.GetBytes(pStr+i, count, bytes,
+ c_MaxUnicodeCharsReallocate*c_MaxUTF_8BytesPerUnicodeChar);
+
+ // This is the only exception that built in UriParser can throw after a Uri ctor.
+ // Should not happen unless the app tries to feed an invalid Unicode String
+ if (numberOfBytes == 0)
+ throw new UriFormatException(SR.GetString(SR.net_uri_BadString));
+
+ i += (count-1);
+
+ for (count = 0 ; count < numberOfBytes; ++count)
+ EscapeAsciiChar((char)bytes[count], dest, ref destPos);
+
+ prevInputPos = i+1;
+ }
+ else if (ch == '%' && rsvd == '%')
+ {
+ // Means we don't reEncode '%' but check for the possible escaped sequence
+ dest = EnsureDestinationSize(pStr, dest, i, c_EncodedCharsPerByte,
+ c_MaxAsciiCharsReallocate * c_EncodedCharsPerByte, ref destPos, prevInputPos);
+ if(i + 2 < end && EscapedAscii(pStr[i+1], pStr[i+2]) != Uri.c_DummyChar)
+ {
+ // leave it escaped
+ dest[destPos++] = '%';
+ dest[destPos++] = pStr[i+1];
+ dest[destPos++] = pStr[i+2];
+ i += 2;
+ }
+ else
+ {
+ EscapeAsciiChar('%', dest, ref destPos);
+ }
+ prevInputPos = i+1;
+ }
+ else if (ch == force1 || ch == force2)
+ {
+ dest = EnsureDestinationSize(pStr, dest, i, c_EncodedCharsPerByte,
+ c_MaxAsciiCharsReallocate * c_EncodedCharsPerByte, ref destPos, prevInputPos);
+ EscapeAsciiChar(ch, dest, ref destPos);
+ prevInputPos = i+1;
+ }
+ else if (ch != rsvd && (isUriString ? !IsReservedUnreservedOrHash(ch) : !IsUnreserved(ch)))
+ {
+ dest = EnsureDestinationSize(pStr, dest, i, c_EncodedCharsPerByte,
+ c_MaxAsciiCharsReallocate * c_EncodedCharsPerByte, ref destPos, prevInputPos);
+ EscapeAsciiChar(ch, dest, ref destPos);
+ prevInputPos = i+1;
+ }
+ }
+
+ if (prevInputPos != i)
+ {
+ // need to fill up the dest array ?
+ if (prevInputPos != start || dest != null)
+ dest = EnsureDestinationSize(pStr, dest, i, 0, 0, ref destPos, prevInputPos);
+ }
+ }
+
+ return dest;
+ }
+
+ //
+ // ensure destination array has enough space and contains all the needed input stuff
+ //
+ private unsafe static char[] EnsureDestinationSize(char* pStr, char[] dest, int currentInputPos,
+ short charsToAdd, short minReallocateChars, ref int destPos, int prevInputPos)
+ {
+ if ((object) dest == null || dest.Length < destPos + (currentInputPos-prevInputPos) + charsToAdd)
+ {
+ // allocating or reallocating array by ensuring enough space based on maxCharsToAdd.
+ char[] newresult = new char[destPos + (currentInputPos-prevInputPos) + minReallocateChars];
+
+ if ((object) dest != null && destPos != 0)
+ Buffer.BlockCopy(dest, 0, newresult, 0, destPos<<1);
+ dest = newresult;
+ }
+
+ // ensuring we copied everything form the input string left before last escaping
+ while (prevInputPos != currentInputPos)
+ dest[destPos++] = pStr[prevInputPos++];
+ return dest;
+ }
+
+ //
+ // This method will assume that any good Escaped Sequence will be unescaped in the output
+ // - Assumes Dest.Length - detPosition >= end-start
+ // - UnescapeLevel controls various modes of opearion
+ // - Any "bad" escape sequence will remain as is or '%' will be escaped.
+ // - destPosition tells the starting index in dest for placing the result.
+ // On return destPosition tells the last character + 1 postion in the "dest" array.
+ // - The control chars and chars passed in rsdvX parameters may be re-escaped depending on UnescapeLevel
+ // - It is a RARE case when Unescape actually needs escaping some characteres mentioned above.
+ // For this reason it returns a char[] that is usually the same ref as the input "dest" value.
+ //
+ internal unsafe static char[] UnescapeString(string input, int start, int end, char[] dest,
+ ref int destPosition, char rsvd1, char rsvd2, char rsvd3, UnescapeMode unescapeMode, UriParser syntax,
+ bool isQuery)
+ {
+ fixed (char *pStr = input)
+ {
+ return UnescapeString(pStr, start, end, dest, ref destPosition, rsvd1, rsvd2, rsvd3, unescapeMode,
+ syntax, isQuery);
+ }
+ }
+ internal unsafe static char[] UnescapeString(char* pStr, int start, int end, char[] dest, ref int destPosition,
+ char rsvd1, char rsvd2, char rsvd3, UnescapeMode unescapeMode, UriParser syntax, bool isQuery)
+ {
+ byte [] bytes = null;
+ byte escapedReallocations = 0;
+ bool escapeReserved = false;
+ int next = start;
+ bool iriParsing = Uri.IriParsingStatic(syntax)
+ && ((unescapeMode & UnescapeMode.EscapeUnescape) == UnescapeMode.EscapeUnescape);
+
+ while (true)
+ {
+ // we may need to re-pin dest[]
+ fixed (char* pDest = dest)
+ {
+ if ((unescapeMode & UnescapeMode.EscapeUnescape) == UnescapeMode.CopyOnly)
+ {
+ while (start < end)
+ pDest[destPosition++] = pStr[start++];
+ return dest;
+ }
+
+ while (true)
+ {
+ char ch = (char)0;
+
+ for (;next < end; ++next)
+ {
+ if ((ch = pStr[next]) == '%')
+ {
+ if ((unescapeMode & UnescapeMode.Unescape) == 0)
+ {
+ // re-escape, don't check anything else
+ escapeReserved = true;
+ }
+ else if (next+2 < end)
+ {
+ ch = EscapedAscii(pStr[next+1], pStr[next+2]);
+ // Unescape a good sequence if full unescape is requested
+ if (unescapeMode >= UnescapeMode.UnescapeAll)
+ {
+ if (ch == Uri.c_DummyChar)
+ {
+ if (unescapeMode >= UnescapeMode.UnescapeAllOrThrow)
+ {
+ // Should be a rare case where the app tries to feed an invalid escaped sequence
+ throw new UriFormatException(SR.GetString(SR.net_uri_BadString));
+ }
+ continue;
+ }
+ }
+ // re-escape % from an invalid sequence
+ else if (ch == Uri.c_DummyChar)
+ {
+ if ((unescapeMode & UnescapeMode.Escape) != 0)
+ escapeReserved = true;
+ else
+ continue; // we should throw instead but since v1.0 would just print '%'
+ }
+ // Do not unescape '%' itself unless full unescape is requested
+ else if (ch == '%')
+ {
+ next += 2;
+ continue;
+ }
+ // Do not unescape a reserved char unless full unescape is requested
+ else if (ch == rsvd1 || ch == rsvd2 || ch == rsvd3)
+ {
+ next += 2;
+ continue;
+ }
+ // Do not unescape a dangerous char unless it's V1ToStringFlags mode
+ else if ((unescapeMode & UnescapeMode.V1ToStringFlag) == 0 && IsNotSafeForUnescape(ch))
+ {
+ next += 2;
+ continue;
+ }
+ else if (iriParsing && ((ch <='\x9F' && IsNotSafeForUnescape(ch)) ||
+ (ch >'\x9F' &&!IriHelper.CheckIriUnicodeRange(ch, isQuery))))
+ {
+ // check if unenscaping gives a char ouside iri range
+ // if it does then keep it escaped
+ next += 2;
+ continue;
+ }
+ // unescape escaped char or escape %
+ break;
+ }
+ else if (unescapeMode >= UnescapeMode.UnescapeAll)
+ {
+ if (unescapeMode >= UnescapeMode.UnescapeAllOrThrow)
+ {
+ // Should be a rare case where the app tries to feed an invalid escaped sequence
+ throw new UriFormatException(SR.GetString(SR.net_uri_BadString));
+ }
+ // keep a '%' as part of a bogus sequence
+ continue;
+ }
+ else
+ {
+ escapeReserved = true;
+ }
+ // escape (escapeReserved==ture) or otheriwse unescape the sequence
+ break;
+ }
+ else if ((unescapeMode & (UnescapeMode.Unescape | UnescapeMode.UnescapeAll))
+ == (UnescapeMode.Unescape | UnescapeMode.UnescapeAll))
+ {
+ continue;
+ }
+ else if ((unescapeMode & UnescapeMode.Escape) != 0)
+ {
+ // Could actually escape some of the characters
+ if (ch == rsvd1 || ch == rsvd2 || ch == rsvd3)
+ {
+ // found an unescaped reserved character -> escape it
+ escapeReserved = true;
+ break;
+ }
+ else if ((unescapeMode & UnescapeMode.V1ToStringFlag) == 0
+ && (ch <= '\x1F' || (ch >= '\x7F' && ch <= '\x9F')))
+ {
+ // found an unescaped reserved character -> escape it
+ escapeReserved = true;
+ break;
+ }
+ }
+ }
+
+ //copy off previous characters from input
+ while (start < next)
+ pDest[destPosition++] = pStr[start++];
+
+ if (next != end)
+ {
+ //VsWhidbey#87423
+ if (escapeReserved)
+ {
+ //escape that char
+ // Since this should be _really_ rare case, reallocate with constant size increase of 30 rsvd-type characters.
+ if (escapedReallocations == 0)
+ {
+ escapedReallocations = 30;
+ char[] newDest = new char[dest.Length + escapedReallocations*3];
+ fixed (char *pNewDest = newDest)
+ {
+ for (int i = 0; i < destPosition; ++i)
+ pNewDest[i] = pDest[i];
+ }
+ dest = newDest;
+ // re-pin new dest[] array
+ goto dest_fixed_loop_break;
+ }
+ else
+ {
+ --escapedReallocations;
+ EscapeAsciiChar(pStr[next], dest, ref destPosition);
+ escapeReserved = false;
+ start = ++next;
+ continue;
+ }
+ }
+
+ // unescaping either one Ascii or possibly multiple Unicode
+
+ if (ch <= '\x7F')
+ {
+ //ASCII
+ dest[destPosition++] = ch;
+ next+=3;
+ start = next;
+ continue;
+ }
+
+ // Unicode
+
+ int byteCount = 1;
+ // lazy initialization of max size, will reuse the array for next sequences
+ if ((object) bytes == null)
+ bytes = new byte[end - next];
+
+ bytes[0] = (byte)ch;
+ next+=3;
+ while (next < end)
+ {
+ // Check on exit criterion
+ if ((ch = pStr[next]) != '%' || next+2 >= end)
+ break;
+
+ // already made sure we have 3 characters in str
+ ch = EscapedAscii(pStr[next+1], pStr[next+2]);
+
+ //invalid hex sequence ?
+ if (ch == Uri.c_DummyChar)
+ break;
+ // character is not part of a UTF-8 sequence ?
+ else if (ch < '\x80')
+ break;
+ else
+ {
+ //a UTF-8 sequence
+ bytes[byteCount++] = (byte)ch;
+ next += 3;
+ }
+ }
+ Encoding noFallbackCharUTF8 = (Encoding)Encoding.UTF8.Clone();
+ noFallbackCharUTF8.EncoderFallback = new EncoderReplacementFallback("");
+ noFallbackCharUTF8.DecoderFallback = new DecoderReplacementFallback("");
+
+ char[] unescapedChars = new char[bytes.Length];
+ int charCount = noFallbackCharUTF8.GetChars(bytes, 0, byteCount, unescapedChars, 0);
+
+ start = next;
+
+ // match exact bytes
+ // Do not unescape chars not allowed by Iri
+ // need to check for invalid utf sequences that may not have given any chars
+
+ MatchUTF8Sequence(pDest, dest, ref destPosition, unescapedChars, charCount, bytes,
+ byteCount, isQuery, iriParsing);
+ }
+
+ if (next == end)
+ goto done;
+ }
+dest_fixed_loop_break: ;
+ }
+ }
+
+done: return dest;
+ }
+
+ //
+ // Need to check for invalid utf sequences that may not have given any chars.
+ // We got the unescaped chars, we then reencode them and match off the bytes
+ // to get the invalid sequence bytes that we just copy off
+ //
+ internal static unsafe void MatchUTF8Sequence(char* pDest, char[] dest, ref int destOffset, char[] unescapedChars,
+ int charCount, byte[] bytes, int byteCount, bool isQuery, bool iriParsing)
+ {
+ int count = 0;
+ fixed (char* unescapedCharsPtr = unescapedChars)
+ {
+ for (int j = 0; j < charCount; ++j)
+ {
+ bool isHighSurr = Char.IsHighSurrogate(unescapedCharsPtr[j]);
+
+ byte[] encodedBytes = Encoding.UTF8.GetBytes(unescapedChars, j, isHighSurr ? 2 : 1);
+ int encodedBytesLength = encodedBytes.Length;
+
+ // we have to keep unicode chars outside Iri range escaped
+ bool inIriRange = false;
+ if (iriParsing)
+ {
+ if (!isHighSurr)
+ inIriRange = IriHelper.CheckIriUnicodeRange(unescapedChars[j], isQuery);
+ else
+ {
+ bool surrPair = false;
+ inIriRange = IriHelper.CheckIriUnicodeRange(unescapedChars[j], unescapedChars[j + 1],
+ ref surrPair, isQuery);
+ }
+ }
+
+ while (true)
+ {
+ // Escape any invalid bytes that were before this character
+ while (bytes[count] != encodedBytes[0])
+ {
+ Debug.Assert(dest.Length > destOffset, "Buffer overrun detected");
+ EscapeAsciiChar((char)bytes[count++], dest, ref destOffset);
+ }
+
+ // check if all bytes match
+ bool allBytesMatch = true;
+ int k = 0;
+ for (; k < encodedBytesLength; ++k)
+ {
+ if (bytes[count + k] != encodedBytes[k])
+ {
+ allBytesMatch = false;
+ break;
+ }
+ }
+
+ if (allBytesMatch)
+ {
+ count += encodedBytesLength;
+ if (iriParsing)
+ {
+ if (!inIriRange)
+ {
+ // need to keep chars not allowed as escaped
+ for (int l = 0; l < encodedBytes.Length; ++l)
+ {
+ Debug.Assert(dest.Length > destOffset, "Buffer overrun detected");
+ EscapeAsciiChar((char)encodedBytes[l], dest, ref destOffset);
+ }
+ }
+ else if (!Uri.IsBidiControlCharacter(unescapedCharsPtr[j]) || !UriParser.DontKeepUnicodeBidiFormattingCharacters)
+ {
+ //copy chars
+ Debug.Assert(dest.Length > destOffset, "Buffer overrun detected");
+ pDest[destOffset++] = unescapedCharsPtr[j];
+ if (isHighSurr)
+ {
+ Debug.Assert(dest.Length > destOffset, "Buffer overrun detected");
+ pDest[destOffset++] = unescapedCharsPtr[j + 1];
+ }
+ }
+ }
+ else
+ {
+ //copy chars
+ Debug.Assert(dest.Length > destOffset);
+ pDest[destOffset++] = unescapedCharsPtr[j];
+
+ if (isHighSurr)
+ {
+ Debug.Assert(dest.Length > destOffset, "Buffer overrun detected");
+ pDest[destOffset++] = unescapedCharsPtr[j + 1];
+ }
+ }
+
+ break; // break out of while (true) since we've matched this char bytes
+ }
+ else
+ {
+ // copy bytes till place where bytes dont match
+ for (int l = 0; l < k; ++l)
+ {
+ Debug.Assert(dest.Length > destOffset, "Buffer overrun detected");
+ EscapeAsciiChar((char)bytes[count++], dest, ref destOffset);
+ }
+ }
+ }
+
+ if (isHighSurr) j++;
+
+ }
+ }
+
+ // Include any trailing invalid sequences
+ while (count < byteCount)
+ {
+ Debug.Assert(dest.Length > destOffset, "Buffer overrun detected");
+ EscapeAsciiChar((char)bytes[count++], dest, ref destOffset);
+ }
+ }
+
+ internal static void EscapeAsciiChar(char ch, char[] to, ref int pos)
+ {
+ to[pos++] = '%';
+ to[pos++] = HexUpperChars[(ch & 0xf0) >> 4];
+ to[pos++] = HexUpperChars[ch & 0xf];
+ }
+
+ internal static char EscapedAscii(char digit, char next)
+ {
+ if (!(((digit >= '0') && (digit <= '9'))
+ || ((digit >= 'A') && (digit <= 'F'))
+ || ((digit >= 'a') && (digit <= 'f'))))
+ {
+ return Uri.c_DummyChar;
+ }
+
+ int res = (digit <= '9')
+ ? ((int)digit - (int)'0')
+ : (((digit <= 'F')
+ ? ((int)digit - (int)'A')
+ : ((int)digit - (int)'a'))
+ + 10);
+
+ if (!(((next >= '0') && (next <= '9'))
+ || ((next >= 'A') && (next <= 'F'))
+ || ((next >= 'a') && (next <= 'f'))))
+ {
+ return Uri.c_DummyChar;
+ }
+
+ return (char)((res << 4) + ((next <= '9')
+ ? ((int)next - (int)'0')
+ : (((next <= 'F')
+ ? ((int)next - (int)'A')
+ : ((int)next - (int)'a'))
+ + 10)));
+ }
+
+ internal const string RFC3986ReservedMarks = @";/?:@&=+$,#[]!'()*";
+ private const string RFC2396ReservedMarks = @";/?:@&=+$,";
+ private const string RFC3986UnreservedMarks = @"-_.~";
+ private const string RFC2396UnreservedMarks = @"-_.~*'()!";
+ private const string AdditionalUnsafeToUnescape = @"%\#";// While not specified as reserved, these are still unsafe to unescape.
+
+ // When unescaping in safe mode, do not unescape the RFC 3986 reserved set:
+ // gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+ // sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
+ // / "*" / "+" / "," / ";" / "="
+ //
+ // In addition, do not unescape the following unsafe characters:
+ // excluded = "%" / "\"
+ //
+ // This implementation used to use the following variant of the RFC 2396 reserved set.
+ // That behavior is now off by default, but can be enabled by an App Context Switch.
+ // reserved = ";" | "/" | "?" | "@" | "&" | "=" | "+" | "$" | ","
+ // excluded = control | "#" | "%" | "\"
+ internal static bool IsNotSafeForUnescape(char ch)
+ {
+ if (ch <= '\x1F' || (ch >= '\x7F' && ch <= '\x9F'))
+ {
+ return true;
+ }
+ else if (UriParser.DontEnableStrictRFC3986ReservedCharacterSets)
+ {
+ if ((ch != ':' && (RFC2396ReservedMarks.IndexOf(ch) >= 0) || (AdditionalUnsafeToUnescape.IndexOf(ch) >= 0)))
+ {
+ return true;
+ }
+ }
+ else if ((RFC3986ReservedMarks.IndexOf(ch) >= 0) || (AdditionalUnsafeToUnescape.IndexOf(ch) >= 0))
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+ private static unsafe bool IsReservedUnreservedOrHash(char c)
+ {
+ if (IsUnreserved(c))
+ {
+ return true;
+ }
+ if (UriParser.ShouldUseLegacyV2Quirks)
+ {
+ return ((RFC2396ReservedMarks.IndexOf(c) >= 0) || c == '#');
+ }
+ return (RFC3986ReservedMarks.IndexOf(c) >= 0);
+ }
+
+ internal static unsafe bool IsUnreserved(char c)
+ {
+ if (Uri.IsAsciiLetterOrDigit(c))
+ {
+ return true;
+ }
+ if (UriParser.ShouldUseLegacyV2Quirks)
+ {
+ return (RFC2396UnreservedMarks.IndexOf(c) >= 0);
+ }
+ return (RFC3986UnreservedMarks.IndexOf(c) >= 0);
+ }
+
+ internal static bool Is3986Unreserved(char c)
+ {
+ if (Uri.IsAsciiLetterOrDigit(c))
+ {
+ return true;
+ }
+ return (RFC3986UnreservedMarks.IndexOf(c) >= 0);
+ }
+ }
+}
diff --git a/System/net/System/_UriSyntax.cs b/System/net/System/_UriSyntax.cs
new file mode 100644
index 0000000..07c34d3
--- /dev/null
+++ b/System/net/System/_UriSyntax.cs
@@ -0,0 +1,644 @@
+//------------------------------------------------------------------------------
+// <copyright file="_UriSyntax.cs" company="Microsoft">
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+ //
+ // This file utilizes partial class feature and contains
+ // only internal implementation of UriParser type
+ //
+
+namespace System {
+
+ using System.Collections.Generic;
+ using System.Diagnostics;
+ using System.Runtime.Versioning;
+
+ // This enum specifies the Uri syntax flags that is understood by builtin Uri parser.
+ [Flags]
+ internal enum UriSyntaxFlags {
+ None = 0x0,
+
+ MustHaveAuthority = 0x1, // must have "//" after scheme:
+ OptionalAuthority = 0x2, // used by generic parser due to unknown Uri syntax
+ MayHaveUserInfo = 0x4,
+ MayHavePort = 0x8,
+ MayHavePath = 0x10,
+ MayHaveQuery = 0x20,
+ MayHaveFragment = 0x40,
+
+ AllowEmptyHost = 0x80,
+ AllowUncHost = 0x100,
+ AllowDnsHost = 0x200,
+ AllowIPv4Host = 0x400,
+ AllowIPv6Host = 0x800,
+ AllowAnInternetHost = AllowDnsHost|AllowIPv4Host|AllowIPv6Host,
+ AllowAnyOtherHost = 0x1000, // Relaxed authority syntax
+
+ FileLikeUri = 0x2000, //Special case to allow file:\\balbla or file://\\balbla
+ MailToLikeUri = 0x4000, //V1 parser inheritance mailTo:AuthorityButNoSlashes
+
+ V1_UnknownUri = 0x10000, // a Compatibility with V1 parser for an unknown scheme
+ SimpleUserSyntax = 0x20000, // It is safe to not call virtual UriParser methods
+ BuiltInSyntax = 0x40000, // This is a simple Uri plus it is hardcoded in the product
+ ParserSchemeOnly = 0x80000, // This is a Parser that does only Uri scheme parsing
+
+ AllowDOSPath = 0x100000, // will check for "x:\"
+ PathIsRooted = 0x200000, // For an authority based Uri the first path char is '/'
+ ConvertPathSlashes = 0x400000, // will turn '\' into '/'
+ CompressPath = 0x800000, // For an authority based Uri remove/compress /./ /../ in the path
+ CanonicalizeAsFilePath = 0x1000000, // remove/convert sequences /.../ /x../ /x./ dangerous for a DOS path
+ UnEscapeDotsAndSlashes = 0x2000000, // additionally unescape dots and slashes before doing path compression
+ AllowIdn = 0x4000000, // IDN host conversion allowed
+ AllowIriParsing = 0x10000000, // Iri parsing. String is normalized, bidi control
+ // characters are removed, unicode char limits are checked etc.
+
+// KeepTailLWS = 0x8000000,
+ }
+
+ //
+ // Only internal members are included here
+ //
+ public abstract partial class UriParser {
+ private static readonly Dictionary<String, UriParser> m_Table;
+ private static Dictionary<String, UriParser> m_TempTable;
+
+ private UriSyntaxFlags m_Flags;
+
+ // Some flags (specified in c_UpdatableFlags) besides being set in the ctor, can also be set at a later
+ // point. Such "updatable" flags can be set using SetUpdatableFlags(); if this method is called,
+ // the value specified in the ctor is ignored (i.e. for all c_UpdatableFlags the value in m_Flags is
+ // ignored), and the new value is used (i.e. for all c_UpdatableFlags the value in m_UpdatableFlags is used).
+ private volatile UriSyntaxFlags m_UpdatableFlags;
+ private volatile bool m_UpdatableFlagsUsed;
+
+ // The following flags can be updated at any time.
+ private const UriSyntaxFlags c_UpdatableFlags = UriSyntaxFlags.UnEscapeDotsAndSlashes;
+
+ private int m_Port;
+ private string m_Scheme;
+
+ internal const int NoDefaultPort = -1;
+ private const int c_InitialTableSize = 25;
+
+ // These are always available without paying hashtable lookup cost
+ // Note: see UpdateStaticSyntaxReference()
+ internal static UriParser HttpUri;
+ internal static UriParser HttpsUri;
+ internal static UriParser WsUri;
+ internal static UriParser WssUri;
+ internal static UriParser FtpUri;
+ internal static UriParser FileUri;
+ internal static UriParser GopherUri;
+ internal static UriParser NntpUri;
+ internal static UriParser NewsUri;
+ internal static UriParser MailToUri;
+ internal static UriParser UuidUri;
+ internal static UriParser TelnetUri;
+ internal static UriParser LdapUri;
+ internal static UriParser NetTcpUri;
+ internal static UriParser NetPipeUri;
+
+ internal static UriParser VsMacrosUri; //bad guy
+
+
+ private enum UriQuirksVersion {
+ // V1 = 1, // RFC 1738 - Not supported
+ V2 = 2, // RFC 2396
+ V3 = 3, // RFC 3986, 3987
+ }
+
+ // Store in a static field to allow for test manipulation and emergency workarounds via reflection.
+ // Note this is not placed in the Uri class in order to avoid circular static dependencies.
+ private static readonly UriQuirksVersion s_QuirksVersion =
+ (BinaryCompatibility.TargetsAtLeast_Desktop_V4_5
+ // || BinaryCompatibility.TargetsAtLeast_Silverlight_V6
+ // || BinaryCompatibility.TargetsAtLeast_Phone_V8_0
+ ) ? UriQuirksVersion.V3 : UriQuirksVersion.V2;
+
+ internal static bool ShouldUseLegacyV2Quirks {
+ get {
+ return s_QuirksVersion <= UriQuirksVersion.V2;
+ }
+ }
+
+ internal static bool DontEnableStrictRFC3986ReservedCharacterSets
+ {
+ get {
+ return LocalAppContextSwitches.DontEnableStrictRFC3986ReservedCharacterSets;
+ }
+ }
+
+ internal static bool DontKeepUnicodeBidiFormattingCharacters
+ {
+ get
+ {
+ return LocalAppContextSwitches.DontKeepUnicodeBidiFormattingCharacters;
+ }
+ }
+
+ static UriParser() {
+
+ m_Table = new Dictionary<String, UriParser>(c_InitialTableSize);
+ m_TempTable = new Dictionary<String, UriParser>(c_InitialTableSize);
+
+ //Now we will call for the instance constructors that will interrupt this static one.
+
+ // Below we simulate calls into FetchSyntax() but avoid using lock() and other things redundant for a .cctor
+
+ HttpUri = new BuiltInUriParser("http", 80, HttpSyntaxFlags);
+ m_Table[HttpUri.SchemeName] = HttpUri; //HTTP
+
+ HttpsUri = new BuiltInUriParser("https", 443, HttpUri.m_Flags);
+ m_Table[HttpsUri.SchemeName] = HttpsUri; //HTTPS cloned from HTTP
+
+ WsUri = new BuiltInUriParser("ws", 80, HttpSyntaxFlags);
+ m_Table[WsUri.SchemeName] = WsUri; // WebSockets
+
+ WssUri = new BuiltInUriParser("wss", 443, HttpSyntaxFlags);
+ m_Table[WssUri.SchemeName] = WssUri; // Secure WebSockets
+
+ FtpUri = new BuiltInUriParser("ftp", 21, FtpSyntaxFlags);
+ m_Table[FtpUri.SchemeName] = FtpUri; //FTP
+
+ FileUri = new BuiltInUriParser("file", NoDefaultPort, FileSyntaxFlags);
+ m_Table[FileUri.SchemeName] = FileUri; //FILE
+
+ GopherUri = new BuiltInUriParser("gopher", 70, GopherSyntaxFlags);
+ m_Table[GopherUri.SchemeName] = GopherUri; //GOPHER
+
+ NntpUri = new BuiltInUriParser("nntp", 119, NntpSyntaxFlags);
+ m_Table[NntpUri.SchemeName] = NntpUri; //NNTP
+
+ NewsUri = new BuiltInUriParser("news", NoDefaultPort, NewsSyntaxFlags);
+ m_Table[NewsUri.SchemeName] = NewsUri; //NEWS
+
+ MailToUri = new BuiltInUriParser("mailto", 25, MailtoSyntaxFlags);
+ m_Table[MailToUri.SchemeName] = MailToUri; //MAILTO
+
+ UuidUri = new BuiltInUriParser("uuid", NoDefaultPort, NewsUri.m_Flags);
+ m_Table[UuidUri.SchemeName] = UuidUri; //UUID cloned from NEWS
+
+ TelnetUri = new BuiltInUriParser("telnet", 23, TelnetSyntaxFlags);
+ m_Table[TelnetUri.SchemeName] = TelnetUri; //TELNET
+
+ LdapUri = new BuiltInUriParser("ldap", 389, LdapSyntaxFlags);
+ m_Table[LdapUri.SchemeName] = LdapUri; //LDAP
+
+ NetTcpUri = new BuiltInUriParser("net.tcp", 808, NetTcpSyntaxFlags);
+ m_Table[NetTcpUri.SchemeName] = NetTcpUri;
+
+ NetPipeUri = new BuiltInUriParser("net.pipe", NoDefaultPort, NetPipeSyntaxFlags);
+ m_Table[NetPipeUri.SchemeName] = NetPipeUri;
+
+ VsMacrosUri = new BuiltInUriParser("vsmacros", NoDefaultPort, VsmacrosSyntaxFlags);
+ m_Table[VsMacrosUri.SchemeName] = VsMacrosUri; //VSMACROS
+
+ }
+ //
+ private class BuiltInUriParser: UriParser
+ {
+ //
+ // All BuiltIn parsers use that ctor. They are marked with "simple" and "built-in" flags
+ //
+ internal BuiltInUriParser(string lwrCaseScheme, int defaultPort, UriSyntaxFlags syntaxFlags)
+ : base ((syntaxFlags | UriSyntaxFlags.SimpleUserSyntax | UriSyntaxFlags.BuiltInSyntax))
+ {
+ m_Scheme = lwrCaseScheme;
+ m_Port = defaultPort;
+ }
+ }
+ //
+ internal UriSyntaxFlags Flags {
+ get {
+ return m_Flags;
+ }
+ }
+ //
+ internal bool NotAny(UriSyntaxFlags flags)
+ {
+ // Return true if none of the flags specified in 'flags' are set.
+ return IsFullMatch(flags, UriSyntaxFlags.None);
+ }
+ //
+ internal bool InFact(UriSyntaxFlags flags)
+ {
+ // Return true if at least one of the flags in 'flags' is set.
+ return !IsFullMatch(flags, UriSyntaxFlags.None);
+ }
+ //
+ internal bool IsAllSet(UriSyntaxFlags flags)
+ {
+ // Return true if all flags in 'flags' are set.
+ return IsFullMatch(flags, flags);
+ }
+
+ private bool IsFullMatch(UriSyntaxFlags flags, UriSyntaxFlags expected)
+ {
+ // Return true, if masking the current set of flags with 'flags' equals 'expected'.
+ // Definition 'current set of flags':
+ // a) if updatable flags were never set: m_Flags
+ // b) if updatable flags were set: set union between all flags in m_Flags which are not updatable
+ // (i.e. not part of c_UpdatableFlags) and all flags in m_UpdatableFlags
+
+ UriSyntaxFlags mergedFlags;
+
+ // if none of the flags in 'flags' is an updatable flag, we ignore m_UpdatableFlags
+ if (((flags & c_UpdatableFlags) == 0) || !m_UpdatableFlagsUsed)
+ {
+ mergedFlags = m_Flags;
+ }
+ else
+ {
+ // mask m_Flags to only use the flags not in c_UpdatableFlags
+ mergedFlags = (m_Flags & (~c_UpdatableFlags)) | m_UpdatableFlags;
+ }
+
+ return (mergedFlags & flags) == expected;
+ }
+
+ //
+ // Internal .ctor, any ctor eventually goes through this one
+ //
+ internal UriParser(UriSyntaxFlags flags)
+ {
+ m_Flags = flags;
+ m_Scheme = string.Empty;
+ }
+ //
+ private static void FetchSyntax(UriParser syntax, string lwrCaseSchemeName, int defaultPort)
+ {
+ if (syntax.SchemeName.Length != 0)
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_NeedFreshParser, syntax.SchemeName));
+
+ lock (m_Table)
+ {
+ syntax.m_Flags &= ~UriSyntaxFlags.V1_UnknownUri;
+ UriParser oldSyntax = null;
+ m_Table.TryGetValue(lwrCaseSchemeName, out oldSyntax);
+ if (oldSyntax != null)
+ throw new InvalidOperationException(SR.GetString(SR.net_uri_AlreadyRegistered, oldSyntax.SchemeName));
+
+ m_TempTable.TryGetValue(syntax.SchemeName, out oldSyntax);
+ if (oldSyntax != null)
+ {
+ // optimization on schemeName, will try to keep the first reference
+ lwrCaseSchemeName = oldSyntax.m_Scheme;
+ m_TempTable.Remove(lwrCaseSchemeName);
+ }
+
+ syntax.OnRegister(lwrCaseSchemeName, defaultPort);
+ syntax.m_Scheme = lwrCaseSchemeName;
+ syntax.CheckSetIsSimpleFlag();
+ syntax.m_Port = defaultPort;
+
+ m_Table[syntax.SchemeName] = syntax;
+ }
+ }
+ //
+ private const int c_MaxCapacity = 512;
+ //schemeStr must be in lower case!
+ internal static UriParser FindOrFetchAsUnknownV1Syntax(string lwrCaseScheme) {
+
+ // check may be other thread just added one
+ UriParser syntax = null;
+ m_Table.TryGetValue(lwrCaseScheme, out syntax);
+ if (syntax != null) {
+ return syntax;
+ }
+ m_TempTable.TryGetValue(lwrCaseScheme, out syntax);
+ if (syntax != null) {
+ return syntax;
+ }
+ lock (m_Table) {
+ // This is a bit paranoid but let's prevent static table growing infinitly
+ if (m_TempTable.Count >= c_MaxCapacity) {
+ m_TempTable = new Dictionary<String, UriParser>(c_InitialTableSize);
+ }
+ syntax = new BuiltInUriParser(lwrCaseScheme, NoDefaultPort, UnknownV1SyntaxFlags);
+ m_TempTable[lwrCaseScheme] = syntax;
+ return syntax;
+ }
+ }
+ //
+ internal static UriParser GetSyntax(string lwrCaseScheme) {
+ UriParser ret = null;
+ m_Table.TryGetValue(lwrCaseScheme, out ret);
+ if (ret == null) {
+ m_TempTable.TryGetValue(lwrCaseScheme, out ret);
+ }
+ return ret;
+ }
+ //
+ // Builtin and User Simple syntaxes do not need custom validation/parsing (i.e. virtual method calls),
+ //
+ internal bool IsSimple
+ {
+ get {
+ return InFact(UriSyntaxFlags.SimpleUserSyntax);
+ }
+ }
+ //
+ internal void CheckSetIsSimpleFlag()
+ {
+ Type type = this.GetType();
+
+ if ( type == typeof(GenericUriParser)
+ || type == typeof(HttpStyleUriParser)
+ || type == typeof(FtpStyleUriParser)
+ || type == typeof(FileStyleUriParser)
+ || type == typeof(NewsStyleUriParser)
+ || type == typeof(GopherStyleUriParser)
+ || type == typeof(NetPipeStyleUriParser)
+ || type == typeof(NetTcpStyleUriParser)
+ || type == typeof(LdapStyleUriParser)
+ )
+ {
+ m_Flags |= UriSyntaxFlags.SimpleUserSyntax;
+ }
+ }
+
+ //
+ // This method is used to update flags. The scenario where this is needed is when the user specifies
+ // flags in the config file. The config file is read after UriParser instances were created.
+ //
+ internal void SetUpdatableFlags(UriSyntaxFlags flags) {
+
+ Debug.Assert(!m_UpdatableFlagsUsed,
+ "SetUpdatableFlags() already called. It can only be called once per parser.");
+ Debug.Assert((flags & (~c_UpdatableFlags)) == 0, "Only updatable flags can be set.");
+
+ // No locks necessary. Reordering won't happen due to volatile.
+ m_UpdatableFlags = flags;
+ m_UpdatableFlagsUsed = true;
+ }
+
+ //
+ // These are simple internal wrappers that will call virtual protected methods
+ // (to avoid "protected internal" siganures in the public docs)
+ //
+ internal UriParser InternalOnNewUri()
+ {
+ UriParser effectiveParser = OnNewUri();
+ if ((object)this != (object)effectiveParser)
+ {
+ effectiveParser.m_Scheme = m_Scheme;
+ effectiveParser.m_Port = m_Port;
+ effectiveParser.m_Flags = m_Flags;
+ }
+ return effectiveParser;
+ }
+
+ //
+ internal void InternalValidate(Uri thisUri, out UriFormatException parsingError)
+ {
+ InitializeAndValidate(thisUri, out parsingError);
+ }
+
+ //
+ internal string InternalResolve(Uri thisBaseUri, Uri uriLink, out UriFormatException parsingError)
+ {
+ return Resolve(thisBaseUri, uriLink, out parsingError);
+ }
+
+ //
+ internal bool InternalIsBaseOf(Uri thisBaseUri, Uri uriLink)
+ {
+ return IsBaseOf(thisBaseUri, uriLink);
+ }
+
+ //
+ internal string InternalGetComponents(Uri thisUri, UriComponents uriComponents, UriFormat uriFormat)
+ {
+ return GetComponents(thisUri, uriComponents, uriFormat);
+ }
+
+ //
+ internal bool InternalIsWellFormedOriginalString(Uri thisUri)
+ {
+ return IsWellFormedOriginalString(thisUri);
+ }
+
+ //
+ // Various Uri scheme syntax flags
+ //
+ private const UriSyntaxFlags UnknownV1SyntaxFlags =
+ UriSyntaxFlags.V1_UnknownUri | // This flag must be always set here
+ UriSyntaxFlags.OptionalAuthority |
+ //
+ UriSyntaxFlags.MayHaveUserInfo |
+ UriSyntaxFlags.MayHavePort |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveQuery |
+ UriSyntaxFlags.MayHaveFragment |
+ //
+ UriSyntaxFlags.AllowEmptyHost |
+ UriSyntaxFlags.AllowUncHost | //
+ UriSyntaxFlags.AllowAnInternetHost |
+ // UriSyntaxFlags.AllowAnyOtherHost | // V1.1 has a bug and so does not support this case
+ //
+ UriSyntaxFlags.PathIsRooted |
+ UriSyntaxFlags.AllowDOSPath | //
+ UriSyntaxFlags.ConvertPathSlashes | // V1 compat, it will always convert backslashes
+ UriSyntaxFlags.CompressPath | // V1 compat, it will always compress path even for non hierarchical Uris
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+ private static readonly UriSyntaxFlags HttpSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ //
+ UriSyntaxFlags.MayHaveUserInfo |
+ UriSyntaxFlags.MayHavePort |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveQuery |
+ UriSyntaxFlags.MayHaveFragment |
+ //
+ UriSyntaxFlags.AllowUncHost | //
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.PathIsRooted |
+ //
+ UriSyntaxFlags.ConvertPathSlashes |
+ UriSyntaxFlags.CompressPath |
+ UriSyntaxFlags.CanonicalizeAsFilePath |
+ (UriParser.ShouldUseLegacyV2Quirks
+ ? UriSyntaxFlags.UnEscapeDotsAndSlashes : UriSyntaxFlags.None) |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+ private const UriSyntaxFlags FtpSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ //
+ UriSyntaxFlags.MayHaveUserInfo |
+ UriSyntaxFlags.MayHavePort |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveFragment |
+ //
+ UriSyntaxFlags.AllowUncHost | //
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.PathIsRooted |
+ //
+ UriSyntaxFlags.ConvertPathSlashes |
+ UriSyntaxFlags.CompressPath |
+ UriSyntaxFlags.CanonicalizeAsFilePath|
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+ private static readonly UriSyntaxFlags FileSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ //
+ UriSyntaxFlags.AllowEmptyHost |
+ UriSyntaxFlags.AllowUncHost |
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveFragment |
+ (UriParser.ShouldUseLegacyV2Quirks
+ ? UriSyntaxFlags.None : UriSyntaxFlags.MayHaveQuery) |
+ //
+ UriSyntaxFlags.FileLikeUri |
+ //
+ UriSyntaxFlags.PathIsRooted |
+ UriSyntaxFlags.AllowDOSPath |
+ //
+ UriSyntaxFlags.ConvertPathSlashes |
+ UriSyntaxFlags.CompressPath |
+ UriSyntaxFlags.CanonicalizeAsFilePath |
+ UriSyntaxFlags.UnEscapeDotsAndSlashes |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+
+ // bad guy
+ private const UriSyntaxFlags VsmacrosSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ //
+ UriSyntaxFlags.AllowEmptyHost |
+ UriSyntaxFlags.AllowUncHost |
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveFragment |
+ //
+ UriSyntaxFlags.FileLikeUri |
+ //
+ UriSyntaxFlags.AllowDOSPath |
+ UriSyntaxFlags.ConvertPathSlashes |
+ UriSyntaxFlags.CompressPath |
+ UriSyntaxFlags.CanonicalizeAsFilePath |
+ UriSyntaxFlags.UnEscapeDotsAndSlashes |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+ private const UriSyntaxFlags GopherSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ //
+ UriSyntaxFlags.MayHaveUserInfo |
+ UriSyntaxFlags.MayHavePort |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveFragment |
+ //
+ UriSyntaxFlags.AllowUncHost | //
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.PathIsRooted |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+// UriSyntaxFlags.KeepTailLWS |
+
+ //Note that NNTP and NEWS are quite different in syntax
+ private const UriSyntaxFlags NewsSyntaxFlags =
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveFragment |
+ UriSyntaxFlags.AllowIriParsing;
+
+ private const UriSyntaxFlags NntpSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ //
+ UriSyntaxFlags.MayHaveUserInfo|
+ UriSyntaxFlags.MayHavePort |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveFragment |
+ //
+ UriSyntaxFlags.AllowUncHost | //
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.PathIsRooted |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+
+ private const UriSyntaxFlags TelnetSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ //
+ UriSyntaxFlags.MayHaveUserInfo|
+ UriSyntaxFlags.MayHavePort |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveFragment |
+ //
+ UriSyntaxFlags.AllowUncHost | //
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.PathIsRooted |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+
+ private const UriSyntaxFlags LdapSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ //
+ UriSyntaxFlags.AllowEmptyHost |
+ UriSyntaxFlags.AllowUncHost | //
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.MayHaveUserInfo |
+ UriSyntaxFlags.MayHavePort |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveQuery |
+ UriSyntaxFlags.MayHaveFragment |
+ //
+ UriSyntaxFlags.PathIsRooted |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+
+ private const UriSyntaxFlags MailtoSyntaxFlags =
+ //
+ UriSyntaxFlags.AllowEmptyHost |
+ UriSyntaxFlags.AllowUncHost | //
+ UriSyntaxFlags.AllowAnInternetHost |
+ //
+ UriSyntaxFlags.MayHaveUserInfo |
+ UriSyntaxFlags.MayHavePort |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveFragment |
+ UriSyntaxFlags.MayHaveQuery | //to maintain everett compat
+ //
+ UriSyntaxFlags.MailToLikeUri |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+
+
+ private const UriSyntaxFlags NetPipeSyntaxFlags =
+ UriSyntaxFlags.MustHaveAuthority |
+ UriSyntaxFlags.MayHavePath |
+ UriSyntaxFlags.MayHaveQuery |
+ UriSyntaxFlags.MayHaveFragment |
+ UriSyntaxFlags.AllowAnInternetHost |
+ UriSyntaxFlags.PathIsRooted |
+ UriSyntaxFlags.ConvertPathSlashes |
+ UriSyntaxFlags.CompressPath |
+ UriSyntaxFlags.CanonicalizeAsFilePath |
+ UriSyntaxFlags.UnEscapeDotsAndSlashes |
+ UriSyntaxFlags.AllowIdn |
+ UriSyntaxFlags.AllowIriParsing;
+
+
+ private const UriSyntaxFlags NetTcpSyntaxFlags = NetPipeSyntaxFlags | UriSyntaxFlags.MayHavePort;
+
+ }
+}
