mcs/class/referencesource/mscorlib/system/security/util/urlstring.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 //  URLString
   7 //
   8 // <OWNER>Microsoft</OWNER>
   9 //
  10 //  Implementation of membership condition for zones
  11 //
  12
  13 namespace System.Security.Util {
  14
  15     using System;
  16     using System.Collections;
  17     using System.Collections.Generic;
  18     using System.Runtime.CompilerServices;
  19     using System.Runtime.InteropServices;
  20     using System.Runtime.Versioning;
  21     using System.Runtime.Serialization;
  22     using System.Globalization;
  23     using System.Text;
  24     using System.IO;
  25     using System.Diagnostics.Contracts;
  26
  27     [Serializable]
  28     internal sealed class URLString : SiteString
  29     {
  30         private String m_protocol;
  31         [OptionalField(VersionAdded = 2)]
  32         private String m_userpass;
  33         private SiteString m_siteString;
  34         private int m_port;
  35         private LocalSiteString m_localSite;
  36         private DirectoryString m_directory;
  37
  38         private const String m_defaultProtocol = "file";
  39
  40         [OptionalField(VersionAdded = 2)]
  41         private bool m_parseDeferred;
  42         [OptionalField(VersionAdded = 2)]
  43         private String m_urlOriginal;
  44         [OptionalField(VersionAdded = 2)]
  45         private bool m_parsedOriginal;
  46
  47         [OptionalField(VersionAdded = 3)]
  48         private bool m_isUncShare;
  49
  50         // legacy field from v1.x, not used in v2 and beyond. Retained purely for serialization compatability.
  51         private String m_fullurl;
  52
  53
  54         [OnDeserialized]
  55         public void OnDeserialized(StreamingContext ctx)
  56         {
  57
  58             if (m_urlOriginal == null)
  59             {
  60                 // pre-v2 deserialization. Need to fix-up fields here
  61                 m_parseDeferred = false;
  62                 m_parsedOriginal = false; // Dont care what this value is - never used
  63                 m_userpass = "";
  64                 m_urlOriginal = m_fullurl;
  65                 m_fullurl = null;
  66             }
  67         }
  68         [OnSerializing]
  69         private void OnSerializing(StreamingContext ctx)
  70         {
  71
  72             if ((ctx.State & ~(StreamingContextStates.Clone|StreamingContextStates.CrossAppDomain)) != 0)
  73             {
  74                 DoDeferredParse();
  75                 m_fullurl = m_urlOriginal;
  76             }
  77         }
  78         [OnSerialized]
  79         private void OnSerialized(StreamingContext ctx)
  80         {
  81             if ((ctx.State & ~(StreamingContextStates.Clone|StreamingContextStates.CrossAppDomain)) != 0)
  82             {
  83                 m_fullurl = null;
  84             }
  85         }
  86
  87         public URLString()
  88         {
  89             m_protocol = "";
  90             m_userpass = "";
  91             m_siteString = new SiteString();
  92             m_port = -1;
  93             m_localSite = null;
  94             m_directory = new DirectoryString();
  95             m_parseDeferred = false;
  96         }
  97
  98         private void DoDeferredParse()
  99         {
 100             if (m_parseDeferred)
 101             {
 102                 ParseString(m_urlOriginal, m_parsedOriginal);
 103                 m_parseDeferred = false;
 104             }
 105         }
 106
 107         public URLString(string url) : this(url, false, false) {}
 108         public URLString(string url, bool parsed) : this(url, parsed, false) {}
 109
 110         internal URLString(string url, bool parsed, bool doDeferredParsing)
 111         {
 112             m_port = -1;
 113             m_userpass = "";
 114             DoFastChecks(url);
 115             m_urlOriginal = url;
 116             m_parsedOriginal = parsed;
 117             m_parseDeferred = true;
 118             if (doDeferredParsing)
 119                 DoDeferredParse();
 120         }
 121
 122         // Converts %XX and %uYYYY to the actual characters (I.e. Unesacpes any escape characters present in the URL)
 123         private String UnescapeURL(String url)
 124         {
 125             StringBuilder intermediate = StringBuilderCache.Acquire(url.Length);
 126             int Rindex = 0; // index into temp that gives the rest of the string to be processed
 127             int index;
 128             int braIndex = -1;
 129             int ketIndex = -1;
 130             braIndex = url.IndexOf('[',Rindex);
 131             if (braIndex != -1)
 132                 ketIndex = url.IndexOf(']', braIndex);
 133
 134             do
 135                 {
 136                     index = url.IndexOf( '%', Rindex);
 137
 138                     if (index == -1)
 139                     {
 140                         intermediate = intermediate.Append(url, Rindex, (url.Length - Rindex));
 141                         break;
 142                     }
 143                     // if we hit a '%' in the middle of an IPv6 address, dont process that
 144                     if (index > braIndex && index < ketIndex)
 145                     {
 146                         intermediate = intermediate.Append(url, Rindex, (ketIndex - Rindex+1));
 147                         Rindex = ketIndex+1;
 148                         continue;
 149                     }
 150
 151                     if (url.Length - index < 2) // Check that there is at least 1 char after the '%'
 152                         throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 153
 154                     if (url[index+1] == 'u' || url[index+1] == 'U')
 155                     {
 156                         if (url.Length - index < 6) // example: "%u004d" is 6 chars long
 157                             throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 158
 159                         // We have a unicode character specified in hex
 160
 161                         try
 162                         {
 163                             char c = (char)(Hex.ConvertHexDigit( url[index+2] ) << 12 |
 164                                             Hex.ConvertHexDigit( url[index+3] ) << 8  |
 165                                             Hex.ConvertHexDigit( url[index+4] ) << 4  |
 166                                             Hex.ConvertHexDigit( url[index+5] ));
 167                             intermediate = intermediate.Append(url, Rindex, index - Rindex);
 168                             intermediate = intermediate.Append(c);
 169                         }
 170                         catch(ArgumentException) // Hex.ConvertHexDigit can throw an "out of range" ArgumentException
 171                         {
 172                             throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 173                         }
 174
 175                         Rindex = index + 6 ; //update the 'seen' length
 176                     }
 177                     else
 178                     {
 179                         // we have a hex character.
 180
 181                         if (url.Length - index < 3) // example: "%4d" is 3 chars long
 182                              throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 183
 184                         try
 185                         {
 186                             char c = (char)(Hex.ConvertHexDigit( url[index+1] ) << 4 | Hex.ConvertHexDigit( url[index+2] ));
 187
 188                             intermediate = intermediate.Append(url, Rindex, index - Rindex);
 189                             intermediate = intermediate.Append(c);
 190                         }
 191                         catch(ArgumentException) // Hex.ConvertHexDigit can throw an "out of range" ArgumentException
 192                         {
 193                             throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 194                         }
 195
 196                         Rindex = index + 3; // update the 'seen' length
 197                     }
 198
 199                 }
 200             while (true);
 201             return StringBuilderCache.GetStringAndRelease(intermediate);
 202         }
 203
 204         // Helper Function for ParseString:
 205         // Search for the end of the protocol info and grab the actual protocol string
 206         // ex. http://www.microsoft.com/complus would have a protocol string of http
 207         private String ParseProtocol(String url)
 208         {
 209             String temp;
 210             int index = url.IndexOf( ':' );
 211
 212             if (index == 0)
 213             {
 214                 throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 215             }
 216             else if (index == -1)
 217             {
 218                 m_protocol = m_defaultProtocol;
 219                 temp = url;
 220             }
 221             else if (url.Length > index + 1)
 222             {
 223                 if (index == m_defaultProtocol.Length &&
 224                     String.Compare(url, 0, m_defaultProtocol, 0, index, StringComparison.OrdinalIgnoreCase) == 0)
 225                 {
 226                     m_protocol = m_defaultProtocol;
 227                     temp = url.Substring( index + 1 );
 228
 229                     // Since an explicit file:// URL could be immediately followed by a host name, we will be
 230                     // conservative and assume that it is on a share rather than a potentally relative local
 231                     // URL.
 232                     m_isUncShare = true;
 233                 }
 234                 else if (url[index+1] != '\\')
 235                 {
 236                     if (url.Length > index + 2 &&
 237                         url[index+1] == '/' &&
 238                         url[index+2] == '/')
 239                     {
 240                         m_protocol = url.Substring( 0, index );
 241
 242                         for (int i = 0; i < m_protocol.Length; ++i)
 243                         {
 244                             char c = m_protocol[i];
 245
 246                             if ((c >= 'a' && c <= 'z') ||
 247                                 (c >= 'A' && c <= 'Z') ||
 248                                 (c >= '0' && c <= '9') ||
 249                                 (c == '+') ||
 250                                 (c == '.') ||
 251                                 (c == '-'))
 252                             {
 253                                 continue;
 254                             }
 255                             else
 256                             {
 257                                 throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 258                             }
 259                         }
 260                         temp = url.Substring( index + 3 );
 261                      }
 262                     else
 263                     {
 264                         throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 265                     }
 266                 }
 267                 else
 268                 {
 269                     m_protocol = m_defaultProtocol;
 270                     temp = url;
 271                 }
 272             }
 273             else
 274             {
 275                 throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 276             }
 277
 278             return temp;
 279         }
 280
 281         private String ParsePort(String url)
 282         {
 283             String temp = url;
 284             char[] separators = new char[] { ':', '/' };
 285             int Rindex = 0;
 286             int userpassIndex = temp.IndexOf('@');
 287             if (userpassIndex != -1) {
 288                 if (temp.IndexOf('/',0,userpassIndex) == -1) {
 289                     // this is a user:pass type of string
 290                     m_userpass = temp.Substring(0,userpassIndex);
 291                     Rindex = userpassIndex + 1;
 292                 }
 293             }
 294
 295             int braIndex = -1;
 296             int ketIndex = -1;
 297             int portIndex = -1;
 298             braIndex = url.IndexOf('[',Rindex);
 299             if (braIndex != -1)
 300                 ketIndex = url.IndexOf(']', braIndex);
 301             if (ketIndex != -1)
 302             {
 303                 // IPv6 address...ignore the IPv6 block when searching for the port
 304                 portIndex = temp.IndexOfAny(separators,ketIndex);
 305             }
 306             else
 307             {
 308                 portIndex = temp.IndexOfAny(separators,Rindex);
 309             }
 310
 311
 312
 313             if (portIndex != -1 && temp[portIndex] == ':')
 314             {
 315                 // make sure it really is a port, and has a number after the :
 316                 if ( temp[portIndex+1] >= '0' && temp[portIndex+1] <= '9' )
 317                 {
 318                     int tempIndex = temp.IndexOf( '/', Rindex);
 319
 320                     if (tempIndex == -1)
 321                     {
 322                         m_port = Int32.Parse( temp.Substring(portIndex + 1), CultureInfo.InvariantCulture );
 323
 324                         if (m_port < 0)
 325                             throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 326
 327                         temp = temp.Substring( Rindex, portIndex - Rindex );
 328                     }
 329                     else if (tempIndex > portIndex)
 330                     {
 331                         m_port = Int32.Parse( temp.Substring(portIndex + 1, tempIndex - portIndex - 1), CultureInfo.InvariantCulture );
 332                         temp = temp.Substring( Rindex, portIndex - Rindex ) + temp.Substring( tempIndex );
 333                     }
 334                     else
 335                         throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 336                 }
 337                 else
 338                     throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 339             }
 340             else {
 341                 // Chop of the user/pass portion if any
 342                 temp = temp.Substring(Rindex);
 343             }
 344
 345             return temp;
 346         }
 347
 348         // This does three things:
 349         // 1. It makes the following modifications to the start of the string:
 350         //      a. \\?\ and \\?/ => <empty>
 351         //      b. \\.\ and \\./ => <empty>
 352         // 2. If isFileUrl is true, converts all slashes to front slashes and strips leading
 353         //    front slashes. See comment by code.
 354         // 3. Throws a PathTooLongException if the length of the resulting URL is >= MAX_PATH.
 355         //    This is done to prevent security issues due to canonicalization truncations.
 356         // Remove this method when the Path class supports "\\?\"
 357         internal static string PreProcessForExtendedPathRemoval(string url, bool isFileUrl)
 358         {
 359             return PreProcessForExtendedPathRemoval(checkPathLength: true, url: url, isFileUrl: isFileUrl);
 360         }
 361
 362         internal static string PreProcessForExtendedPathRemoval(bool checkPathLength, string url, bool isFileUrl)
 363         {
 364             bool isUncShare = false;
 365             return PreProcessForExtendedPathRemoval(checkPathLength: checkPathLength, url: url, isFileUrl: isFileUrl, isUncShare: ref isUncShare);
 366         }
 367
 368         // Keeping this signature to avoid reflection breaks
 369         private static string PreProcessForExtendedPathRemoval(string url, bool isFileUrl, ref bool isUncShare)
 370         {
 371             return PreProcessForExtendedPathRemoval(checkPathLength: true, url: url, isFileUrl: isFileUrl, isUncShare: ref isUncShare);
 372         }
 373
 374         private static string PreProcessForExtendedPathRemoval(bool checkPathLength, string url, bool isFileUrl, ref bool isUncShare)
 375         {
 376             // This is the modified URL that we will return
 377             StringBuilder modifiedUrl = new StringBuilder(url);
 378
 379             // ITEM 1 - remove extended path characters.
 380             {
 381                 // Keep track of where we are in both the comparison and altered strings.
 382                 int curCmpIdx = 0;
 383                 int curModIdx = 0;
 384
 385                 // If all the '\' have already been converted to '/', just check for //?/ or //./
 386                 if ((url.Length - curCmpIdx) >= 4 &&
 387                     (String.Compare(url, curCmpIdx, "//?/", 0, 4, StringComparison.OrdinalIgnoreCase) == 0 ||
 388                      String.Compare(url, curCmpIdx, "//./", 0, 4, StringComparison.OrdinalIgnoreCase) == 0))
 389                 {
 390                     modifiedUrl.Remove(curModIdx, 4);
 391                     curCmpIdx += 4;
 392                 }
 393                 else
 394                 {
 395                     if (isFileUrl) {
 396                         // We need to handle an indefinite number of leading front slashes for file URLs since we could
 397                         // get something like:
 398                         //      file://\\?\
 399                         //      file:/\\?\
 400                         //      file:\\?\
 401                         //      etc...
 402                         while (url[curCmpIdx] == '/')
 403                         {
 404                             curCmpIdx++;
 405                             curModIdx++;
 406                         }
 407                     }
 408
 409                     // Remove the extended path characters
 410                     if ((url.Length - curCmpIdx) >= 4 &&
 411                         (String.Compare(url, curCmpIdx, "\\\\?\\", 0, 4, StringComparison.OrdinalIgnoreCase) == 0 ||
 412                          String.Compare(url, curCmpIdx, "\\\\?/", 0, 4, StringComparison.OrdinalIgnoreCase) == 0 ||
 413                          String.Compare(url, curCmpIdx, "\\\\.\\", 0, 4, StringComparison.OrdinalIgnoreCase) == 0 ||
 414                          String.Compare(url, curCmpIdx, "\\\\./", 0, 4, StringComparison.OrdinalIgnoreCase) == 0))
 415                     {
 416                         modifiedUrl.Remove(curModIdx, 4);
 417                         curCmpIdx += 4;
 418                     }
 419                 }
 420             }
 421
 422             // ITEM 2 - convert all slashes to forward slashes, and strip leading slashes.
 423             if (isFileUrl)
 424             {
 425                 int slashCount = 0;
 426                 bool seenFirstBackslash = false;
 427
 428                 while (slashCount < modifiedUrl.Length && (modifiedUrl[slashCount] == '/' || modifiedUrl[slashCount] == '\\'))
 429                 {
 430                     // Look for sets of consecutive backslashes. We can't just look for these at the start
 431                     // of the string, since file:// might come first.  Instead, once we see the first \, look
 432                     // for a second one following it.
 433                     if (!seenFirstBackslash && modifiedUrl[slashCount] == '\\')
 434                 {
 435                         seenFirstBackslash = true;
 436                         if (slashCount + 1 < modifiedUrl.Length && modifiedUrl[slashCount + 1] == '\\')
 437                             isUncShare = true;
 438                     }
 439
 440                     slashCount++;
 441                 }
 442
 443                 modifiedUrl.Remove(0, slashCount);
 444                 modifiedUrl.Replace('\\', '/');
 445             }
 446
 447             // ITEM 3 - If the path is greater than or equal (due to terminating NULL in windows) MAX_PATH, we throw.
 448             if (checkPathLength)
 449             {
 450                 // This needs to be a separate method to avoid hitting the static constructor on AppContextSwitches
 451                 CheckPathTooLong(modifiedUrl);
 452             }
 453
 454             // Create the result string from the StringBuilder
 455             return modifiedUrl.ToString();
 456         }
 457
 458         [MethodImpl(MethodImplOptions.NoInlining)]
 459         private static void CheckPathTooLong(StringBuilder path)
 460         {
 461             if (path.Length >= (AppContextSwitches.BlockLongPaths ? PathInternal.MaxShortPath : PathInternal.MaxLongPath))
 462             {
 463                 throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong"));
 464             }
 465         }
 466
 467         // Do any misc massaging of data in the URL
 468         private String PreProcessURL(String url, bool isFileURL)
 469         {
 470            if (isFileURL) {
 471                 // Remove when the Path class supports "\\?\"
 472                 url = PreProcessForExtendedPathRemoval(url, true, ref m_isUncShare);
 473             }
 474             else {
 475                 url = url.Replace('\\', '/');
 476             }
 477             return url;
 478         }
 479
 480         private void ParseFileURL(String url)
 481         {
 482             String temp = url;
 483
 484             int index = temp.IndexOf( '/');
 485
 486             if (index != -1 &&
 487                 ((index == 2 &&
 488                   temp[index-1] != ':' &&
 489                   temp[index-1] != '|') ||
 490                  index != 2) &&
 491                 index != temp.Length - 1)
 492             {
 493                 // Also, if it is a UNC share, we want m_localSite to
 494                 // be of the form "computername/share", so if the first
 495                 // fileEnd character found is a slash, do some more parsing
 496                 // to find the proper end character.
 497
 498                 int tempIndex = temp.IndexOf( '/', index+1);
 499
 500                 if (tempIndex != -1)
 501                     index = tempIndex;
 502                 else
 503                     index = -1;
 504             }
 505
 506             String localSite;
 507             if (index == -1)
 508                 localSite = temp;
 509             else
 510                 localSite = temp.Substring(0,index);
 511
 512             if (localSite.Length == 0)
 513                 throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
 514
 515             int i;
 516             bool spacesAllowed;
 517
 518             if (localSite[0] == '\\' && localSite[1] == '\\')
 519             {
 520                 spacesAllowed = true;
 521                 i = 2;
 522             }
 523             else
 524             {
 525                 i = 0;
 526                 spacesAllowed = false;
 527             }
 528
 529             bool useSmallCharToUpper = true;
 530
 531             for (; i < localSite.Length; ++i)
 532             {
 533                 char c = localSite[i];
 534
 535                 if ((c >= 'A' && c <= 'Z') ||
 536                     (c >= 'a' && c <= 'z') ||
 537                     (c >= '0' && c <= '9') ||
 538                     (c == '-') || (c == '/') ||
 539                     (c == ':') || (c == '|') ||
 540                     (c == '.') || (c == '*') ||
 541                     (c == '$') || (spacesAllowed && c == ' '))
 542                 {
 543                     continue;
 544                 }
 545                 else
 546                 {
 547                     useSmallCharToUpper = false;
 548                     break;
 549                 }
 550             }
 551
 552             if (useSmallCharToUpper)
 553                 localSite = String.SmallCharToUpper( localSite );
 554             else
 555                 localSite = localSite.ToUpper(CultureInfo.InvariantCulture);
 556
 557             m_localSite = new LocalSiteString( localSite );
 558
 559             if (index == -1)
 560             {
 561                 if (localSite[localSite.Length-1] == '*')
 562                     m_directory = new DirectoryString( "*", false );
 563                 else
 564                     m_directory = new DirectoryString();
 565             }
 566             else
 567             {
 568                 String directoryString = temp.Substring( index + 1 );
 569                 if (directoryString.Length == 0)
 570                 {
 571                     m_directory = new DirectoryString();
 572                 }
 573                 else
 574                 {
 575                     m_directory = new DirectoryString( directoryString, true);
 576                 }
 577             }
 578
 579             m_siteString = null;
 580             return;
 581         }
 582
 583         private void ParseNonFileURL(String url)
 584         {
 585             String temp = url;
 586             int index = temp.IndexOf('/');
 587
 588             if (index == -1)
 589             {
 590                 m_localSite = null;    // for drive letter
 591                 m_siteString = new SiteString( temp );
 592                 m_directory = new DirectoryString();
 593             }
 594             else
 595             {
 596                 String site = temp.Substring( 0, index );
 597                 m_localSite = null;
 598                 m_siteString = new SiteString( site );
 599
 600                 String directoryString = temp.Substring( index + 1 );
 601
 602                 if (directoryString.Length == 0)
 603                 {
 604                     m_directory = new DirectoryString();
 605                 }
 606                 else
 607                 {
 608                     m_directory = new DirectoryString( directoryString, false );
 609                 }
 610             }
 611             return;
 612         }
 613
 614         void DoFastChecks( String url )
 615         {
 616             if (url == null)
 617             {
 618                 throw new ArgumentNullException( "url" );
 619             }
 620             Contract.EndContractBlock();
 621
 622             if (url.Length == 0)
 623             {
 624                 throw new FormatException(Environment.GetResourceString("Format_StringZeroLength"));
 625             }
 626         }
 627
 628         // NOTE:
 629         // 1. We support URLs that follow the common Internet scheme syntax
 630         //     (<scheme>://user:pass@<host>:<port>/<url-path>) and all windows file URLs.
 631         // 2.  In the general case we parse of the site and create a SiteString out of it
 632         //      (which supports our wildcarding scheme).  In the case of files we don't support
 633         //      wildcarding and furthermore SiteString doesn't like ':' and '|' which can appear
 634         //      in file urls so we just keep that info in a separate string and set the
 635         //      SiteString to null.
 636         //
 637         // ex. http://www.microsoft.com/complus  -> m_siteString = "www.microsoft.com" m_localSite = null
 638         // ex. file:///c:/complus/mscorlib.dll  -> m_siteString = null m_localSite = "c:"
 639         // ex. file:///c|/complus/mscorlib.dll  -> m_siteString = null m_localSite = "c:"
 640         void ParseString( String url, bool parsed )
 641         {
 642             // If there are any escaped hex or unicode characters in the url, translate those
 643             // into the proper character.
 644
 645             if (!parsed)
 646             {
 647                 url = UnescapeURL(url);
 648             }
 649
 650             // Identify the protocol and strip the protocol info from the string, if present.
 651             String temp = ParseProtocol(url);
 652
 653             bool fileProtocol = (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) == 0);
 654
 655             // handle any special  preocessing...removing extra characters, etc.
 656             temp = PreProcessURL(temp, fileProtocol);
 657
 658             if (fileProtocol)
 659             {
 660                 ParseFileURL(temp);
 661             }
 662             else
 663             {
 664                 // Check if there is a port number and parse that out.
 665                 temp = ParsePort(temp);
 666                 ParseNonFileURL(temp);
 667                 // Note: that we allow DNS and Netbios names for non-file protocols (since sitestring will check
 668                 // that the hostname satisfies these two protocols. DNS-only checking can theoretically be added
 669                 // here but that would break all the programs that use '_' (which is fairly common, yet illegal).
 670                 // If this needs to be done at any point, add a call to m_siteString.IsLegalDNSName().
 671             }
 672
 673
 674         }
 675
 676         public String Scheme
 677         {
 678             get
 679             {
 680                 DoDeferredParse();
 681
 682                 return m_protocol;
 683             }
 684         }
 685
 686         public String Host
 687         {
 688             get
 689             {
 690                 DoDeferredParse();
 691
 692                 if (m_siteString != null)
 693                 {
 694                     return m_siteString.ToString();
 695                 }
 696                 else
 697                 {
 698                     return m_localSite.ToString();
 699                 }
 700             }
 701         }
 702
 703         public String Port
 704         {
 705             get
 706             {
 707                 DoDeferredParse();
 708
 709                 if (m_port == -1)
 710                     return null;
 711                 else
 712                     return m_port.ToString(CultureInfo.InvariantCulture);
 713             }
 714         }
 715
 716         public String Directory
 717         {
 718             get
 719             {
 720                 DoDeferredParse();
 721
 722                 return m_directory.ToString();
 723             }
 724         }
 725
 726         /// <summary>
 727         ///     Make a best guess at determining if this is URL refers to a file with a relative path. Since
 728         ///     this is a guess to help out users of UrlMembershipCondition who may accidentally supply a
 729         ///     relative URL, we'd rather err on the side of absolute than relative. (We'd rather accept some
 730         ///     meaningless membership conditions rather than reject meaningful ones).
 731         ///
 732         ///     In order to be a relative file URL, the URL needs to have a protocol of file, and not be on a
 733         ///     UNC share.
 734         ///
 735         ///     If both of the above are true, then the heuristics we'll use to detect an absolute URL are:
 736         ///         1. A host name which is:
 737         ///              a. greater than one character and ends in a colon (representing the drive letter) OR
 738         ///              b. ends with a * (so we match any file with the given prefix if any)
 739         ///         2. Has a directory name (cannot be simply file://c:)
 740         /// </summary>
 741         public bool IsRelativeFileUrl
 742         {
 743             get
 744             {
 745                 DoDeferredParse();
 746
 747                 if (String.Equals(m_protocol, "file", StringComparison.OrdinalIgnoreCase) && !m_isUncShare)
 748                 {
 749                     string host = m_localSite != null ? m_localSite.ToString() : null;
 750                     // If the host name ends with the * character, treat this as an absolute URL since the *
 751                     // could represent the rest of the full path.
 752                     if (host.EndsWith('*'))
 753                         return false;
 754                     string directory = m_directory != null ? m_directory.ToString() : null;
 755
 756                     return host == null || host.Length < 2 || !host.EndsWith(':') ||
 757                            String.IsNullOrEmpty(directory);
 758                 }
 759
 760                 // Since this is not a local URL, it cannot be relative
 761                 return false;
 762             }
 763         }
 764
 765         public String GetFileName()
 766         {
 767             DoDeferredParse();
 768
 769             if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) != 0)
 770                 return null;
 771
 772             String intermediateDirectory = this.Directory.Replace( '/', '\\' );
 773
 774             String directory = this.Host.Replace( '/', '\\' );
 775
 776             int directorySlashIndex = directory.IndexOf( '\\' );
 777             if (directorySlashIndex == -1)
 778             {
 779                 if (directory.Length != 2 ||
 780                     !(directory[1] == ':' || directory[1] == '|'))
 781                 {
 782                     directory = "\\\\" + directory;
 783                 }
 784             }
 785             else if (directorySlashIndex != 2 ||
 786                      (directorySlashIndex == 2 && directory[1] != ':' && directory[1] != '|'))
 787             {
 788                 directory = "\\\\" + directory;
 789             }
 790
 791             directory += "\\" + intermediateDirectory;
 792
 793             return directory;
 794     }
 795
 796
 797         public String GetDirectoryName()
 798         {
 799             DoDeferredParse();
 800
 801             if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase ) != 0)
 802                 return null;
 803
 804             String intermediateDirectory = this.Directory.Replace( '/', '\\' );
 805
 806             int slashIndex = 0;
 807             for (int i = intermediateDirectory.Length; i > 0; i--)
 808             {
 809                if (intermediateDirectory[i-1] == '\\')
 810                {
 811                    slashIndex = i;
 812                    break;
 813                }
 814             }
 815
 816             String directory = this.Host.Replace( '/', '\\' );
 817
 818             int directorySlashIndex = directory.IndexOf( '\\' );
 819             if (directorySlashIndex == -1)
 820             {
 821                 if (directory.Length != 2 ||
 822                     !(directory[1] == ':' || directory[1] == '|'))
 823                 {
 824                     directory = "\\\\" + directory;
 825                 }
 826             }
 827             else if (directorySlashIndex > 2 ||
 828                     (directorySlashIndex == 2 && directory[1] != ':' && directory[1] != '|'))
 829             {
 830                 directory = "\\\\" + directory;
 831             }
 832
 833             directory += "\\";
 834
 835             if (slashIndex > 0)
 836             {
 837                 directory += intermediateDirectory.Substring( 0, slashIndex );
 838             }
 839
 840             return directory;
 841         }
 842
 843         public override SiteString Copy()
 844         {
 845             return new URLString( m_urlOriginal, m_parsedOriginal );
 846         }
 847
 848         [ResourceExposure(ResourceScope.None)]
 849         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
 850         public override bool IsSubsetOf( SiteString site )
 851         {
 852             if (site == null)
 853             {
 854                 return false;
 855             }
 856
 857             URLString url = site as URLString;
 858
 859             if (url == null)
 860             {
 861                 return false;
 862             }
 863
 864             DoDeferredParse();
 865             url.DoDeferredParse();
 866
 867             URLString normalUrl1 = this.SpecialNormalizeUrl();
 868             URLString normalUrl2 = url.SpecialNormalizeUrl();
 869
 870             if (String.Compare( normalUrl1.m_protocol, normalUrl2.m_protocol, StringComparison.OrdinalIgnoreCase) == 0 &&
 871                 normalUrl1.m_directory.IsSubsetOf( normalUrl2.m_directory ))
 872             {
 873                 if (normalUrl1.m_localSite != null)
 874                 {
 875                     // We do a little extra processing in here for local files since we allow
 876                     // both <drive_letter>: and <drive_letter>| forms of urls.
 877
 878                     return normalUrl1.m_localSite.IsSubsetOf( normalUrl2.m_localSite );
 879                 }
 880                 else
 881                 {
 882                     if (normalUrl1.m_port != normalUrl2.m_port)
 883                         return false;
 884
 885                     return normalUrl2.m_siteString != null && normalUrl1.m_siteString.IsSubsetOf( normalUrl2.m_siteString );
 886                 }
 887             }
 888             else
 889             {
 890                 return false;
 891             }
 892         }
 893
 894         public override String ToString()
 895         {
 896             return m_urlOriginal;
 897         }
 898
 899         public override bool Equals(Object o)
 900         {
 901             DoDeferredParse();
 902
 903             if (o == null || !(o is URLString))
 904                 return false;
 905             else
 906                 return this.Equals( (URLString)o );
 907         }
 908
 909         public override int GetHashCode()
 910         {
 911             DoDeferredParse();
 912
 913             TextInfo info = CultureInfo.InvariantCulture.TextInfo;
 914             int accumulator = 0;
 915
 916             if (this.m_protocol != null)
 917                 accumulator = info.GetCaseInsensitiveHashCode( this.m_protocol );
 918
 919             if (this.m_localSite != null)
 920             {
 921                 accumulator = accumulator ^ this.m_localSite.GetHashCode();
 922             }
 923             else
 924             {
 925                 accumulator = accumulator ^ this.m_siteString.GetHashCode();
 926             }
 927             accumulator = accumulator ^ this.m_directory.GetHashCode();
 928
 929             return accumulator;
 930         }
 931
 932         public bool Equals( URLString url )
 933         {
 934             return CompareUrls( this, url );
 935         }
 936
 937         [ResourceExposure(ResourceScope.None)]
 938         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
 939         public static bool CompareUrls( URLString url1, URLString url2 )
 940         {
 941             if (url1 == null && url2 == null)
 942                 return true;
 943
 944             if (url1 == null || url2 == null)
 945                 return false;
 946
 947             url1.DoDeferredParse();
 948             url2.DoDeferredParse();
 949
 950             URLString normalUrl1 = url1.SpecialNormalizeUrl();
 951             URLString normalUrl2 = url2.SpecialNormalizeUrl();
 952
 953             // Compare protocol (case insensitive)
 954
 955             if (String.Compare( normalUrl1.m_protocol, normalUrl2.m_protocol, StringComparison.OrdinalIgnoreCase) != 0)
 956                 return false;
 957
 958             // Do special processing for file urls
 959
 960             if (String.Compare( normalUrl1.m_protocol, "file", StringComparison.OrdinalIgnoreCase) == 0)
 961             {
 962                 if (!normalUrl1.m_localSite.IsSubsetOf( normalUrl2.m_localSite ) ||
 963                     !normalUrl2.m_localSite.IsSubsetOf( normalUrl1.m_localSite ))
 964                      return false;
 965             }
 966             else
 967             {
 968                 if (String.Compare( normalUrl1.m_userpass, normalUrl2.m_userpass, StringComparison.Ordinal) != 0)
 969                     return false;
 970
 971                 if (!normalUrl1.m_siteString.IsSubsetOf( normalUrl2.m_siteString ) ||
 972                     !normalUrl2.m_siteString.IsSubsetOf( normalUrl1.m_siteString ))
 973                     return false;
 974
 975                 if (url1.m_port != url2.m_port)
 976                     return false;
 977             }
 978
 979             if (!normalUrl1.m_directory.IsSubsetOf( normalUrl2.m_directory ) ||
 980                 !normalUrl2.m_directory.IsSubsetOf( normalUrl1.m_directory ))
 981                 return false;
 982
 983             return true;
 984         }
 985
 986         internal String NormalizeUrl()
 987         {
 988             DoDeferredParse();
 989             StringBuilder builtUrl = StringBuilderCache.Acquire();
 990
 991             if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) == 0)
 992             {
 993                 builtUrl = builtUrl.AppendFormat("FILE:///{0}/{1}", m_localSite.ToString(), m_directory.ToString());
 994             }
 995             else
 996             {
 997                 builtUrl = builtUrl.AppendFormat("{0}://{1}{2}", m_protocol, m_userpass, m_siteString.ToString());
 998
 999                 if (m_port != -1)
1000                     builtUrl = builtUrl.AppendFormat("{0}",m_port);
1001
1002                 builtUrl = builtUrl.AppendFormat("/{0}", m_directory.ToString());
1003             }
1004
1005             return StringBuilderCache.GetStringAndRelease(builtUrl).ToUpper(CultureInfo.InvariantCulture);
1006         }
1007
1008         [System.Security.SecuritySafeCritical]  // auto-generated
1009         [ResourceExposure(ResourceScope.Machine)]
1010         [ResourceConsumption(ResourceScope.Machine)]
1011         internal URLString SpecialNormalizeUrl()
1012         {
1013             // Under WinXP, file protocol urls can be mapped to
1014             // drives that aren't actually file protocol underneath
1015             // due to drive mounting.  This code attempts to figure
1016             // out what a drive is mounted to and create the
1017             // url is maps to.
1018
1019             DoDeferredParse();
1020             if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) != 0)
1021             {
1022                 return this;
1023             }
1024             else
1025             {
1026                 String localSite = m_localSite.ToString();
1027
1028                 if (localSite.Length == 2 &&
1029                     (localSite[1] == '|' ||
1030                      localSite[1] == ':'))
1031                 {
1032                     String deviceName = null;
1033                     GetDeviceName(localSite, JitHelpers.GetStringHandleOnStack(ref deviceName));
1034
1035                     if (deviceName != null)
1036                     {
1037                         if (deviceName.IndexOf( "://", StringComparison.Ordinal ) != -1)
1038                         {
1039                             URLString u = new URLString( deviceName + "/" + this.m_directory.ToString() );
1040                             u.DoDeferredParse(); // Presumably the caller of SpecialNormalizeUrl wants a fully parsed URL
1041                             return u;
1042                         }
1043                         else
1044                         {
1045                             URLString u = new URLString( "file://" + deviceName + "/" + this.m_directory.ToString() );
1046                             u.DoDeferredParse();// Presumably the caller of SpecialNormalizeUrl wants a fully parsed URL
1047                             return u;
1048                         }
1049                     }
1050                     else
1051                         return this;
1052                 }
1053                 else
1054                 {
1055                     return this;
1056                 }
1057             }
1058         }
1059
1060         [System.Security.SecurityCritical]  // auto-generated
1061         [ResourceExposure(ResourceScope.Machine)]
1062         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
1063         [SuppressUnmanagedCodeSecurity]
1064         private static extern void GetDeviceName( String driveLetter, StringHandleOnStack retDeviceName );
1065     }
1066
1067
1068     [Serializable]
1069     internal class DirectoryString : SiteString
1070     {
1071         private bool m_checkForIllegalChars;
1072
1073         private new static char[] m_separators = { '/' };
1074
1075         // From KB #Q177506, file/folder illegal characters are \ / : * ? " < > |
1076         protected static char[] m_illegalDirectoryCharacters = { '\\', ':', '*', '?', '"', '<', '>', '|' };
1077
1078         public DirectoryString()
1079         {
1080             m_site = "";
1081             m_separatedSite = new ArrayList();
1082         }
1083
1084         public DirectoryString( String directory, bool checkForIllegalChars )
1085         {
1086             m_site = directory;
1087             m_checkForIllegalChars = checkForIllegalChars;
1088             m_separatedSite = CreateSeparatedString(directory);
1089         }
1090
1091         private ArrayList CreateSeparatedString(String directory)
1092         {
1093             if (directory == null || directory.Length == 0)
1094             {
1095                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
1096             }
1097             Contract.EndContractBlock();
1098
1099             ArrayList list = new ArrayList();
1100             String[] separatedArray = directory.Split(m_separators);
1101
1102             for (int index = 0; index < separatedArray.Length; ++index)
1103             {
1104                 if (separatedArray[index] == null || separatedArray[index].Equals( "" ))
1105                 {
1106                     // this case is fine, we just ignore it the extra separators.
1107                 }
1108                 else if (separatedArray[index].Equals( "*" ))
1109                 {
1110                     if (index != separatedArray.Length-1)
1111                     {
1112                         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
1113                     }
1114                     list.Add( separatedArray[index] );
1115                 }
1116                 else if (m_checkForIllegalChars && separatedArray[index].IndexOfAny( m_illegalDirectoryCharacters ) != -1)
1117                 {
1118                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
1119                 }
1120                 else
1121                 {
1122                     list.Add( separatedArray[index] );
1123                 }
1124             }
1125
1126             return list;
1127         }
1128
1129         public virtual bool IsSubsetOf( DirectoryString operand )
1130         {
1131             return this.IsSubsetOf( operand, true );
1132         }
1133
1134         public virtual bool IsSubsetOf( DirectoryString operand, bool ignoreCase )
1135         {
1136             if (operand == null)
1137             {
1138                 return false;
1139             }
1140             else if (operand.m_separatedSite.Count == 0)
1141             {
1142                 return this.m_separatedSite.Count == 0 || this.m_separatedSite.Count > 0 && String.Compare((String)this.m_separatedSite[0], "*", StringComparison.Ordinal) == 0;
1143             }
1144             else if (this.m_separatedSite.Count == 0)
1145             {
1146                 return String.Compare((String)operand.m_separatedSite[0], "*", StringComparison.Ordinal) == 0;
1147             }
1148             else
1149             {
1150                 return base.IsSubsetOf( operand, ignoreCase );
1151             }
1152         }
1153     }
1154
1155     [Serializable]
1156     internal class LocalSiteString : SiteString
1157     {
1158         private new static char[] m_separators = { '/' };
1159
1160         public LocalSiteString( String site )
1161         {
1162             m_site = site.Replace( '|', ':');
1163
1164             if (m_site.Length > 2 && m_site.IndexOf( ':' ) != -1)
1165                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
1166
1167             m_separatedSite = CreateSeparatedString(m_site);
1168         }
1169
1170         private ArrayList CreateSeparatedString(String directory)
1171         {
1172             if (directory == null || directory.Length == 0)
1173             {
1174                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
1175             }
1176             Contract.EndContractBlock();
1177
1178             ArrayList list = new ArrayList();
1179             String[] separatedArray = directory.Split(m_separators);
1180
1181             for (int index = 0; index < separatedArray.Length; ++index)
1182             {
1183                 if (separatedArray[index] == null || separatedArray[index].Equals( "" ))
1184                 {
1185                     if (index < 2 &&
1186                         directory[index] == '/')
1187                     {
1188                         list.Add( "//" );
1189                     }
1190                     else if (index != separatedArray.Length-1)
1191                     {
1192                         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
1193                     }
1194                 }
1195                 else if (separatedArray[index].Equals( "*" ))
1196                 {
1197                     if (index != separatedArray.Length-1)
1198                     {
1199                         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
1200                     }
1201                     list.Add( separatedArray[index] );
1202                 }
1203                 else
1204                 {
1205                     list.Add( separatedArray[index] );
1206                 }
1207             }
1208
1209             return list;
1210         }
1211
1212         public virtual bool IsSubsetOf( LocalSiteString operand )
1213         {
1214             return this.IsSubsetOf( operand, true );
1215         }
1216
1217         public virtual bool IsSubsetOf( LocalSiteString operand, bool ignoreCase )
1218         {
1219             if (operand == null)
1220             {
1221                 return false;
1222             }
1223             else if (operand.m_separatedSite.Count == 0)
1224             {
1225                 return this.m_separatedSite.Count == 0 || this.m_separatedSite.Count > 0 && String.Compare((String)this.m_separatedSite[0], "*", StringComparison.Ordinal) == 0;
1226             }
1227             else if (this.m_separatedSite.Count == 0)
1228             {
1229                 return String.Compare((String)operand.m_separatedSite[0], "*", StringComparison.Ordinal) == 0;
1230             }
1231             else
1232             {
1233                 return base.IsSubsetOf( operand, ignoreCase );
1234             }
1235         }
1236     }
1237 }