| | | 1 | | // Licensed to the .NET Foundation under one or more agreements. |
| | | 2 | | // The .NET Foundation licenses this file to you under the MIT license. |
| | | 3 | | |
| | | 4 | | using System.Collections; |
| | | 5 | | using System.Collections.Generic; |
| | | 6 | | using System.Diagnostics; |
| | | 7 | | using System.Text; |
| | | 8 | | |
| | | 9 | | // Relevant cookie specs: |
| | | 10 | | // |
| | | 11 | | // PERSISTENT CLIENT STATE HTTP COOKIES (1996) |
| | | 12 | | // From <http:// web.archive.org/web/20020803110822/http://wp.netscape.com/newsref/std/cookie_spec.html> |
| | | 13 | | // |
| | | 14 | | // RFC2109 HTTP State Management Mechanism (February 1997) |
| | | 15 | | // From <http:// tools.ietf.org/html/rfc2109> |
| | | 16 | | // |
| | | 17 | | // RFC2965 HTTP State Management Mechanism (October 2000) |
| | | 18 | | // From <http:// tools.ietf.org/html/rfc2965> |
| | | 19 | | // |
| | | 20 | | // RFC6265 HTTP State Management Mechanism (April 2011) |
| | | 21 | | // From <http:// tools.ietf.org/html/rfc6265> |
| | | 22 | | // |
| | | 23 | | // The Version attribute of the cookie header is defined and used only in RFC2109 and RFC2965 cookie |
| | | 24 | | // specs and specifies Version=1. The Version attribute is not used in the Netscape cookie spec |
| | | 25 | | // (considered as Version=0). Nor is it used in the most recent cookie spec, RFC6265, introduced in 2011. |
| | | 26 | | // RFC6265 deprecates all previous cookie specs including the Version attribute. |
| | | 27 | | // |
| | | 28 | | // Cookies without an explicit Domain attribute will only match a potential uri that matches the original |
| | | 29 | | // uri from where the cookie came from. |
| | | 30 | | // For explicit Domain attribute in the cookie, see the rules defined in Cookie.HostMatchesDomain(). |
| | | 31 | | |
| | | 32 | | namespace System.Net |
| | | 33 | | { |
| | | 34 | | internal readonly struct HeaderVariantInfo |
| | | 35 | | { |
| | | 36 | | private readonly string _name; |
| | | 37 | | private readonly CookieVariant _variant; |
| | | 38 | | |
| | | 39 | | internal HeaderVariantInfo(string name, CookieVariant variant) |
| | | 40 | | { |
| | | 41 | | _name = name; |
| | | 42 | | _variant = variant; |
| | | 43 | | } |
| | | 44 | | |
| | | 45 | | internal string Name |
| | | 46 | | { |
| | | 47 | | get |
| | | 48 | | { |
| | | 49 | | return _name; |
| | | 50 | | } |
| | | 51 | | } |
| | | 52 | | |
| | | 53 | | internal CookieVariant Variant |
| | | 54 | | { |
| | | 55 | | get |
| | | 56 | | { |
| | | 57 | | return _variant; |
| | | 58 | | } |
| | | 59 | | } |
| | | 60 | | } |
| | | 61 | | |
| | | 62 | | // CookieContainer |
| | | 63 | | // |
| | | 64 | | // Manage cookies for a user (implicit). Based on RFC 2965. |
| | | 65 | | [Serializable] |
| | | 66 | | [System.Runtime.CompilerServices.TypeForwardedFrom("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c5 |
| | | 67 | | public class CookieContainer |
| | | 68 | | { |
| | | 69 | | public const int DefaultCookieLimit = 300; |
| | | 70 | | public const int DefaultPerDomainCookieLimit = 20; |
| | | 71 | | public const int DefaultCookieLengthLimit = 4096; |
| | | 72 | | |
| | 0 | 73 | | private static readonly HeaderVariantInfo[] s_headerInfo = { |
| | 0 | 74 | | new HeaderVariantInfo(HttpKnownHeaderNames.SetCookie, CookieVariant.Rfc2109), |
| | 0 | 75 | | new HeaderVariantInfo(HttpKnownHeaderNames.SetCookie2, CookieVariant.Rfc2965) |
| | 0 | 76 | | }; |
| | | 77 | | |
| | 0 | 78 | | private readonly Hashtable m_domainTable = new Hashtable(); // Do not rename (binary serialization) |
| | 0 | 79 | | private int m_maxCookieSize = DefaultCookieLengthLimit; // Do not rename (binary serialization) |
| | 0 | 80 | | private int m_maxCookies = DefaultCookieLimit; // Do not rename (binary serialization) |
| | 0 | 81 | | private int m_maxCookiesPerDomain = DefaultPerDomainCookieLimit; // Do not rename (binary serialization) |
| | | 82 | | private int m_count; // Do not rename (binary serialization) |
| | | 83 | | #pragma warning disable CA1823 // Avoid unused private fields |
| | 0 | 84 | | private readonly string m_fqdnMyDomain = string.Empty; |
| | | 85 | | #pragma warning restore CA1823 // Avoid unused private fields |
| | | 86 | | |
| | 0 | 87 | | public CookieContainer() |
| | 0 | 88 | | { |
| | 0 | 89 | | } |
| | | 90 | | |
| | 0 | 91 | | public CookieContainer(int capacity) |
| | 0 | 92 | | { |
| | 0 | 93 | | ArgumentOutOfRangeException.ThrowIfNegativeOrZero(capacity); |
| | 0 | 94 | | m_maxCookies = capacity; |
| | 0 | 95 | | } |
| | | 96 | | |
| | 0 | 97 | | public CookieContainer(int capacity, int perDomainCapacity, int maxCookieSize) : this(capacity) |
| | 0 | 98 | | { |
| | 0 | 99 | | if (perDomainCapacity != int.MaxValue && (perDomainCapacity <= 0 || perDomainCapacity > capacity)) |
| | 0 | 100 | | { |
| | 0 | 101 | | throw new ArgumentOutOfRangeException(nameof(perDomainCapacity), SR.Format(SR.net_cookie_capacity_range, |
| | | 102 | | } |
| | 0 | 103 | | m_maxCookiesPerDomain = perDomainCapacity; |
| | 0 | 104 | | ArgumentOutOfRangeException.ThrowIfNegativeOrZero(maxCookieSize); |
| | 0 | 105 | | m_maxCookieSize = maxCookieSize; |
| | 0 | 106 | | } |
| | | 107 | | |
| | | 108 | | // NOTE: after shrinking the capacity, Count can become greater than Capacity. |
| | | 109 | | public int Capacity |
| | | 110 | | { |
| | | 111 | | get |
| | 0 | 112 | | { |
| | 0 | 113 | | return m_maxCookies; |
| | 0 | 114 | | } |
| | | 115 | | set |
| | 0 | 116 | | { |
| | 0 | 117 | | if (value <= 0 || (value < m_maxCookiesPerDomain && m_maxCookiesPerDomain != int.MaxValue)) |
| | 0 | 118 | | { |
| | 0 | 119 | | throw new ArgumentOutOfRangeException(nameof(value), SR.Format(SR.net_cookie_capacity_range, "Capaci |
| | | 120 | | } |
| | 0 | 121 | | if (value < m_maxCookies) |
| | 0 | 122 | | { |
| | 0 | 123 | | m_maxCookies = value; |
| | 0 | 124 | | AgeCookies(null); |
| | 0 | 125 | | } |
| | 0 | 126 | | m_maxCookies = value; |
| | 0 | 127 | | } |
| | | 128 | | } |
| | | 129 | | |
| | | 130 | | /// <devdoc> |
| | | 131 | | /// <para>Returns the total number of cookies in the container.</para> |
| | | 132 | | /// </devdoc> |
| | | 133 | | public int Count |
| | | 134 | | { |
| | | 135 | | get |
| | 0 | 136 | | { |
| | 0 | 137 | | return m_count; |
| | 0 | 138 | | } |
| | | 139 | | } |
| | | 140 | | |
| | | 141 | | public int MaxCookieSize |
| | | 142 | | { |
| | | 143 | | get |
| | 0 | 144 | | { |
| | 0 | 145 | | return m_maxCookieSize; |
| | 0 | 146 | | } |
| | | 147 | | set |
| | 0 | 148 | | { |
| | 0 | 149 | | ArgumentOutOfRangeException.ThrowIfNegativeOrZero(value); |
| | 0 | 150 | | m_maxCookieSize = value; |
| | 0 | 151 | | } |
| | | 152 | | } |
| | | 153 | | |
| | | 154 | | /// <devdoc> |
| | | 155 | | /// <para>After shrinking domain capacity, each domain will less hold than new domain capacity.</para> |
| | | 156 | | /// </devdoc> |
| | | 157 | | public int PerDomainCapacity |
| | | 158 | | { |
| | | 159 | | get |
| | 0 | 160 | | { |
| | 0 | 161 | | return m_maxCookiesPerDomain; |
| | 0 | 162 | | } |
| | | 163 | | set |
| | 0 | 164 | | { |
| | 0 | 165 | | ArgumentOutOfRangeException.ThrowIfNegativeOrZero(value); |
| | 0 | 166 | | if (value != int.MaxValue) |
| | 0 | 167 | | { |
| | 0 | 168 | | ArgumentOutOfRangeException.ThrowIfGreaterThan(value, m_maxCookies); |
| | 0 | 169 | | } |
| | | 170 | | |
| | 0 | 171 | | if (value < m_maxCookiesPerDomain) |
| | 0 | 172 | | { |
| | 0 | 173 | | m_maxCookiesPerDomain = value; |
| | 0 | 174 | | AgeCookies(null); |
| | 0 | 175 | | } |
| | 0 | 176 | | m_maxCookiesPerDomain = value; |
| | 0 | 177 | | } |
| | | 178 | | } |
| | | 179 | | |
| | | 180 | | // This method will construct a faked URI: the Domain property is required for param. |
| | | 181 | | public void Add(Cookie cookie) |
| | 0 | 182 | | { |
| | 0 | 183 | | ArgumentNullException.ThrowIfNull(cookie); |
| | | 184 | | |
| | 0 | 185 | | if (cookie.Domain.Length == 0) |
| | 0 | 186 | | { |
| | 0 | 187 | | throw new ArgumentException( |
| | 0 | 188 | | SR.Format(SR.net_emptystringcall, nameof(cookie) + "." + nameof(cookie.Domain)), |
| | 0 | 189 | | nameof(cookie)); |
| | | 190 | | } |
| | | 191 | | |
| | | 192 | | Uri? uri; |
| | 0 | 193 | | var uriSb = new StringBuilder(); |
| | | 194 | | |
| | | 195 | | // We cannot add an invalid cookie into the container. |
| | | 196 | | // Trying to prepare Uri for the cookie verification. |
| | 0 | 197 | | uriSb.Append(cookie.Secure ? UriScheme.Https : UriScheme.Http).Append(UriScheme.SchemeDelimiter); |
| | | 198 | | |
| | | 199 | | // If the original cookie has an explicitly set domain, copy it over to the new cookie. |
| | 0 | 200 | | if (!cookie.DomainImplicit) |
| | 0 | 201 | | { |
| | 0 | 202 | | if (cookie.Domain[0] == '.') |
| | 0 | 203 | | { |
| | 0 | 204 | | uriSb.Append('0'); // URI cctor should consume this faked host. |
| | 0 | 205 | | } |
| | 0 | 206 | | } |
| | 0 | 207 | | uriSb.Append(cookie.Domain); |
| | | 208 | | |
| | | 209 | | |
| | | 210 | | // Either keep Port as implicit or set it according to original cookie. |
| | 0 | 211 | | if (cookie.PortList != null) |
| | 0 | 212 | | { |
| | 0 | 213 | | uriSb.Append(':').Append(cookie.PortList[0]); |
| | 0 | 214 | | } |
| | | 215 | | |
| | | 216 | | // Path must be present, set to root by default. |
| | 0 | 217 | | uriSb.Append(cookie.Path); |
| | | 218 | | |
| | 0 | 219 | | if (!Uri.TryCreate(uriSb.ToString(), UriKind.Absolute, out uri)) |
| | 0 | 220 | | throw new CookieException(SR.Format(SR.net_cookie_attribute, "Domain", cookie.Domain)); |
| | | 221 | | |
| | | 222 | | // We don't know cookie verification status, so re-create the cookie and verify it. |
| | 0 | 223 | | Cookie new_cookie = cookie.Clone(); |
| | 0 | 224 | | new_cookie.VerifyAndSetDefaults(new_cookie.Variant, uri); |
| | | 225 | | |
| | 0 | 226 | | InternalAdd(new_cookie); |
| | 0 | 227 | | } |
| | | 228 | | |
| | | 229 | | // This method is called *only* when cookie verification is done, so unlike with public |
| | | 230 | | // Add(Cookie cookie) the cookie is in a reasonable condition. |
| | | 231 | | internal void InternalAdd(Cookie cookie) |
| | 0 | 232 | | { |
| | | 233 | | PathList? pathList; |
| | | 234 | | |
| | 0 | 235 | | if (cookie.Value.Length > m_maxCookieSize) |
| | 0 | 236 | | { |
| | 0 | 237 | | throw new CookieException(SR.Format(SR.net_cookie_size, cookie, m_maxCookieSize)); |
| | | 238 | | } |
| | | 239 | | |
| | | 240 | | try |
| | 0 | 241 | | { |
| | 0 | 242 | | lock (m_domainTable.SyncRoot) |
| | 0 | 243 | | { |
| | 0 | 244 | | pathList = (PathList?)m_domainTable[cookie.DomainKey]; |
| | 0 | 245 | | if (pathList == null) |
| | 0 | 246 | | { |
| | 0 | 247 | | m_domainTable[cookie.DomainKey] = (pathList = new PathList()); |
| | 0 | 248 | | } |
| | 0 | 249 | | } |
| | 0 | 250 | | int domain_count = pathList.GetCookiesCount(); |
| | | 251 | | |
| | | 252 | | CookieCollection? cookies; |
| | 0 | 253 | | lock (pathList.SyncRoot) |
| | 0 | 254 | | { |
| | 0 | 255 | | cookies = (CookieCollection?)pathList[cookie.Path]!; |
| | | 256 | | |
| | 0 | 257 | | if (cookies == null) |
| | 0 | 258 | | { |
| | 0 | 259 | | cookies = new CookieCollection(); |
| | 0 | 260 | | pathList[cookie.Path] = cookies; |
| | 0 | 261 | | } |
| | 0 | 262 | | } |
| | | 263 | | |
| | 0 | 264 | | if (cookie.Expired) |
| | 0 | 265 | | { |
| | | 266 | | // Explicit removal command (Max-Age == 0) |
| | 0 | 267 | | lock (cookies) |
| | 0 | 268 | | { |
| | 0 | 269 | | int idx = cookies.IndexOf(cookie); |
| | 0 | 270 | | if (idx != -1) |
| | 0 | 271 | | { |
| | 0 | 272 | | cookies.RemoveAt(idx); |
| | 0 | 273 | | --m_count; |
| | 0 | 274 | | } |
| | 0 | 275 | | } |
| | 0 | 276 | | } |
| | | 277 | | else |
| | 0 | 278 | | { |
| | | 279 | | // This is about real cookie adding, check Capacity first |
| | 0 | 280 | | if (domain_count >= m_maxCookiesPerDomain && !AgeCookies(cookie.DomainKey)) |
| | 0 | 281 | | { |
| | 0 | 282 | | return; // Cannot age: reject new cookie |
| | | 283 | | } |
| | 0 | 284 | | else if (m_count >= m_maxCookies && !AgeCookies(null)) |
| | 0 | 285 | | { |
| | 0 | 286 | | return; // Cannot age: reject new cookie |
| | | 287 | | } |
| | | 288 | | |
| | | 289 | | // About to change the collection. |
| | 0 | 290 | | lock (cookies) |
| | 0 | 291 | | { |
| | 0 | 292 | | m_count += cookies.InternalAdd(cookie, true); |
| | 0 | 293 | | } |
| | 0 | 294 | | } |
| | | 295 | | |
| | | 296 | | // We don't want to cleanup m_domaintable/m_list too often. Add check to avoid overhead. |
| | 0 | 297 | | if (m_domainTable.Count > m_count || pathList.Count > m_maxCookiesPerDomain) |
| | 0 | 298 | | { |
| | 0 | 299 | | DomainTableCleanup(); |
| | 0 | 300 | | } |
| | 0 | 301 | | } |
| | 0 | 302 | | catch (OutOfMemoryException) |
| | 0 | 303 | | { |
| | 0 | 304 | | throw; |
| | | 305 | | } |
| | 0 | 306 | | catch (Exception e) |
| | 0 | 307 | | { |
| | 0 | 308 | | throw new CookieException(SR.net_container_add_cookie, e); |
| | | 309 | | } |
| | 0 | 310 | | } |
| | | 311 | | |
| | | 312 | | // This function, when called, must delete at least one cookie. |
| | | 313 | | // If there are expired cookies in given scope they are cleaned up. |
| | | 314 | | // If nothing is found the least used Collection will be found and removed |
| | | 315 | | // from the container. |
| | | 316 | | // |
| | | 317 | | // Also note that expired cookies are also removed during request preparation |
| | | 318 | | // (this.GetCookies method). |
| | | 319 | | // |
| | | 320 | | // Param. 'domain' == null means to age in the whole container. |
| | | 321 | | private bool AgeCookies(string? domain) |
| | 0 | 322 | | { |
| | 0 | 323 | | Debug.Assert(m_maxCookies != 0); |
| | 0 | 324 | | Debug.Assert(m_maxCookiesPerDomain != 0); |
| | | 325 | | |
| | 0 | 326 | | int removed = 0; |
| | 0 | 327 | | DateTime oldUsed = DateTime.MaxValue; |
| | | 328 | | DateTime tempUsed; |
| | | 329 | | |
| | 0 | 330 | | CookieCollection? lruCc = null; |
| | | 331 | | string? lruDomain; |
| | | 332 | | string tempDomain; |
| | | 333 | | |
| | | 334 | | PathList pathList; |
| | | 335 | | int domain_count; |
| | 0 | 336 | | int itemp = 0; |
| | 0 | 337 | | float remainingFraction = 1.0F; |
| | | 338 | | |
| | | 339 | | // The container was shrunk, might need additional cleanup for each domain |
| | 0 | 340 | | if (m_count > m_maxCookies) |
| | 0 | 341 | | { |
| | | 342 | | // Means the fraction of the container to be left. |
| | | 343 | | // Each domain will be cut accordingly. |
| | 0 | 344 | | remainingFraction = (float)m_maxCookies / (float)m_count; |
| | 0 | 345 | | } |
| | 0 | 346 | | lock (m_domainTable.SyncRoot) |
| | 0 | 347 | | { |
| | 0 | 348 | | foreach (object item in m_domainTable) |
| | 0 | 349 | | { |
| | 0 | 350 | | DictionaryEntry entry = (DictionaryEntry)item; |
| | 0 | 351 | | if (domain == null) |
| | 0 | 352 | | { |
| | 0 | 353 | | tempDomain = (string)entry.Key; |
| | 0 | 354 | | pathList = (PathList)entry.Value!; // Aliasing to trick foreach |
| | 0 | 355 | | } |
| | | 356 | | else |
| | 0 | 357 | | { |
| | 0 | 358 | | tempDomain = domain; |
| | 0 | 359 | | pathList = (PathList)m_domainTable[domain]!; |
| | 0 | 360 | | } |
| | | 361 | | |
| | 0 | 362 | | domain_count = 0; // Cookies in the domain |
| | 0 | 363 | | lock (pathList.SyncRoot) |
| | 0 | 364 | | { |
| | 0 | 365 | | foreach (CookieCollection? cc in pathList.Values) |
| | 0 | 366 | | { |
| | 0 | 367 | | Debug.Assert(cc != null); |
| | 0 | 368 | | itemp = ExpireCollection(cc); |
| | 0 | 369 | | removed += itemp; |
| | 0 | 370 | | m_count -= itemp; // Update this container's count |
| | 0 | 371 | | domain_count += cc.Count; |
| | | 372 | | |
| | | 373 | | // We also find the least used cookie collection in ENTIRE container. |
| | | 374 | | // We count the collection as LRU only if it holds 1+ elements. |
| | 0 | 375 | | if (cc.Count > 0 && (tempUsed = cc.TimeStamp(CookieCollection.Stamp.Check)) < oldUsed) |
| | 0 | 376 | | { |
| | 0 | 377 | | lruDomain = tempDomain; |
| | 0 | 378 | | lruCc = cc; |
| | 0 | 379 | | oldUsed = tempUsed; |
| | 0 | 380 | | } |
| | 0 | 381 | | } |
| | 0 | 382 | | } |
| | | 383 | | |
| | | 384 | | // Check if we have reduced to the limit of the domain by expiration only. |
| | 0 | 385 | | int min_count = Math.Min((int)(domain_count * remainingFraction), Math.Min(m_maxCookiesPerDomain, m_ |
| | 0 | 386 | | if (domain_count > min_count) |
| | 0 | 387 | | { |
| | | 388 | | // This case requires sorting all domain collections by timestamp. |
| | | 389 | | CookieCollection[] cookies; |
| | | 390 | | DateTime[] stamps; |
| | 0 | 391 | | lock (pathList.SyncRoot) |
| | 0 | 392 | | { |
| | 0 | 393 | | cookies = new CookieCollection[pathList.Count]; |
| | 0 | 394 | | stamps = new DateTime[pathList.Count]; |
| | 0 | 395 | | foreach (CookieCollection? cc in pathList.Values) |
| | 0 | 396 | | { |
| | 0 | 397 | | stamps[itemp] = cc!.TimeStamp(CookieCollection.Stamp.Check); |
| | 0 | 398 | | cookies[itemp] = cc; |
| | 0 | 399 | | ++itemp; |
| | 0 | 400 | | } |
| | 0 | 401 | | } |
| | 0 | 402 | | Array.Sort(stamps, cookies); |
| | | 403 | | |
| | 0 | 404 | | itemp = 0; |
| | 0 | 405 | | for (int i = 0; i < cookies.Length; ++i) |
| | 0 | 406 | | { |
| | 0 | 407 | | CookieCollection cc = cookies[i]; |
| | | 408 | | |
| | 0 | 409 | | lock (cc) |
| | 0 | 410 | | { |
| | 0 | 411 | | while (domain_count > min_count && cc.Count > 0) |
| | 0 | 412 | | { |
| | 0 | 413 | | cc.RemoveAt(0); |
| | 0 | 414 | | --domain_count; |
| | 0 | 415 | | --m_count; |
| | 0 | 416 | | ++removed; |
| | 0 | 417 | | } |
| | 0 | 418 | | } |
| | 0 | 419 | | if (domain_count <= min_count) |
| | 0 | 420 | | { |
| | 0 | 421 | | break; |
| | | 422 | | } |
| | 0 | 423 | | } |
| | | 424 | | |
| | 0 | 425 | | if (domain_count > min_count && domain != null) |
| | 0 | 426 | | { |
| | | 427 | | // Cannot complete aging of explicit domain (no cookie adding allowed). |
| | 0 | 428 | | return false; |
| | | 429 | | } |
| | 0 | 430 | | } |
| | 0 | 431 | | } |
| | 0 | 432 | | } |
| | | 433 | | |
| | | 434 | | // We have completed aging of the specified domain. |
| | 0 | 435 | | if (domain != null) |
| | 0 | 436 | | { |
| | 0 | 437 | | return true; |
| | | 438 | | } |
| | | 439 | | |
| | | 440 | | // The rest is for entire container aging. |
| | | 441 | | // We must get at least one free slot. |
| | | 442 | | |
| | | 443 | | // Don't need to apply LRU if we already cleaned something. |
| | 0 | 444 | | if (removed != 0) |
| | 0 | 445 | | { |
| | 0 | 446 | | return true; |
| | | 447 | | } |
| | | 448 | | |
| | 0 | 449 | | if (oldUsed == DateTime.MaxValue) |
| | 0 | 450 | | { |
| | | 451 | | // Something strange. Either capacity is 0 or all collections are locked with cc.Used. |
| | 0 | 452 | | return false; |
| | | 453 | | } |
| | | 454 | | |
| | | 455 | | // Remove oldest cookies from the least used collection. |
| | 0 | 456 | | lock (lruCc!) |
| | 0 | 457 | | { |
| | 0 | 458 | | while (m_count >= m_maxCookies && lruCc.Count > 0) |
| | 0 | 459 | | { |
| | 0 | 460 | | lruCc.RemoveAt(0); |
| | 0 | 461 | | --m_count; |
| | 0 | 462 | | } |
| | 0 | 463 | | } |
| | 0 | 464 | | return true; |
| | 0 | 465 | | } |
| | | 466 | | |
| | | 467 | | private void DomainTableCleanup() |
| | 0 | 468 | | { |
| | 0 | 469 | | var removePathList = new List<object>(); |
| | 0 | 470 | | var removeDomainList = new List<string>(); |
| | | 471 | | |
| | | 472 | | string currentDomain; |
| | | 473 | | PathList pathList; |
| | | 474 | | |
| | 0 | 475 | | lock (m_domainTable.SyncRoot) |
| | 0 | 476 | | { |
| | | 477 | | // Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations. |
| | 0 | 478 | | IDictionaryEnumerator enumerator = m_domainTable.GetEnumerator(); |
| | 0 | 479 | | while (enumerator.MoveNext()) |
| | 0 | 480 | | { |
| | 0 | 481 | | currentDomain = (string)enumerator.Key; |
| | 0 | 482 | | pathList = (PathList)enumerator.Value!; |
| | | 483 | | |
| | 0 | 484 | | lock (pathList.SyncRoot) |
| | 0 | 485 | | { |
| | 0 | 486 | | IDictionaryEnumerator e = pathList.GetEnumerator(); |
| | 0 | 487 | | while (e.MoveNext()) |
| | 0 | 488 | | { |
| | 0 | 489 | | CookieCollection cc = (CookieCollection)e.Value!; |
| | 0 | 490 | | if (cc.Count == 0) |
| | 0 | 491 | | { |
| | 0 | 492 | | removePathList.Add(e.Key); |
| | 0 | 493 | | } |
| | 0 | 494 | | } |
| | | 495 | | |
| | 0 | 496 | | foreach (var key in removePathList) |
| | 0 | 497 | | { |
| | 0 | 498 | | pathList.Remove(key); |
| | 0 | 499 | | } |
| | | 500 | | |
| | 0 | 501 | | removePathList.Clear(); |
| | 0 | 502 | | if (pathList.Count == 0) removeDomainList.Add(currentDomain); |
| | 0 | 503 | | } |
| | 0 | 504 | | } |
| | | 505 | | |
| | 0 | 506 | | foreach (var key in removeDomainList) |
| | 0 | 507 | | { |
| | 0 | 508 | | m_domainTable.Remove(key); |
| | 0 | 509 | | } |
| | 0 | 510 | | } |
| | 0 | 511 | | } |
| | | 512 | | |
| | | 513 | | // Return number of cookies removed from the collection. |
| | | 514 | | private static int ExpireCollection(CookieCollection cc) |
| | 0 | 515 | | { |
| | 0 | 516 | | lock (cc) |
| | 0 | 517 | | { |
| | 0 | 518 | | int oldCount = cc.Count; |
| | 0 | 519 | | int idx = oldCount - 1; |
| | | 520 | | |
| | | 521 | | // Cannot use enumerator as we are going to alter collection. |
| | 0 | 522 | | while (idx >= 0) |
| | 0 | 523 | | { |
| | 0 | 524 | | Cookie cookie = cc[idx]; |
| | 0 | 525 | | if (cookie.Expired) |
| | 0 | 526 | | { |
| | 0 | 527 | | cc.RemoveAt(idx); |
| | 0 | 528 | | } |
| | 0 | 529 | | --idx; |
| | 0 | 530 | | } |
| | 0 | 531 | | return oldCount - cc.Count; |
| | | 532 | | } |
| | 0 | 533 | | } |
| | | 534 | | |
| | | 535 | | public void Add(CookieCollection cookies) |
| | 0 | 536 | | { |
| | 0 | 537 | | ArgumentNullException.ThrowIfNull(cookies); |
| | | 538 | | |
| | 0 | 539 | | foreach (Cookie c in (ICollection<Cookie>)cookies) |
| | 0 | 540 | | { |
| | 0 | 541 | | Add(c); |
| | 0 | 542 | | } |
| | 0 | 543 | | } |
| | | 544 | | |
| | | 545 | | public void Add(Uri uri, Cookie cookie) |
| | 0 | 546 | | { |
| | 0 | 547 | | ArgumentNullException.ThrowIfNull(uri); |
| | 0 | 548 | | ArgumentNullException.ThrowIfNull(cookie); |
| | | 549 | | |
| | 0 | 550 | | Cookie new_cookie = cookie.Clone(); |
| | 0 | 551 | | new_cookie.VerifyAndSetDefaults(new_cookie.Variant, uri); |
| | | 552 | | |
| | 0 | 553 | | InternalAdd(new_cookie); |
| | 0 | 554 | | } |
| | | 555 | | |
| | | 556 | | public void Add(Uri uri, CookieCollection cookies) |
| | 0 | 557 | | { |
| | 0 | 558 | | ArgumentNullException.ThrowIfNull(uri); |
| | 0 | 559 | | ArgumentNullException.ThrowIfNull(cookies); |
| | | 560 | | |
| | 0 | 561 | | foreach (Cookie c in cookies) |
| | 0 | 562 | | { |
| | 0 | 563 | | Cookie new_cookie = c.Clone(); |
| | 0 | 564 | | new_cookie.VerifyAndSetDefaults(new_cookie.Variant, uri); |
| | 0 | 565 | | InternalAdd(new_cookie); |
| | 0 | 566 | | } |
| | 0 | 567 | | } |
| | | 568 | | |
| | | 569 | | internal CookieCollection CookieCutter(Uri uri, string? headerName, string setCookieHeader) |
| | 0 | 570 | | { |
| | 0 | 571 | | if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"uri:{uri} headerName:{headerName} setCookieH |
| | | 572 | | |
| | 0 | 573 | | CookieCollection cookies = new CookieCollection(); |
| | 0 | 574 | | CookieVariant variant = CookieVariant.Unknown; |
| | 0 | 575 | | if (headerName == null) |
| | 0 | 576 | | { |
| | 0 | 577 | | variant = CookieVariant.Default; |
| | 0 | 578 | | } |
| | | 579 | | else |
| | 0 | 580 | | { |
| | 0 | 581 | | for (int i = 0; i < s_headerInfo.Length; ++i) |
| | 0 | 582 | | { |
| | 0 | 583 | | if ((string.Equals(headerName, s_headerInfo[i].Name, StringComparison.OrdinalIgnoreCase))) |
| | 0 | 584 | | { |
| | 0 | 585 | | variant = s_headerInfo[i].Variant; |
| | 0 | 586 | | } |
| | 0 | 587 | | } |
| | 0 | 588 | | } |
| | | 589 | | |
| | | 590 | | try |
| | 0 | 591 | | { |
| | 0 | 592 | | CookieParser parser = new CookieParser(setCookieHeader); |
| | | 593 | | do |
| | 0 | 594 | | { |
| | 0 | 595 | | Cookie? cookie = parser.Get(); |
| | 0 | 596 | | if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"CookieParser returned cookie:{cookie |
| | | 597 | | |
| | 0 | 598 | | if (cookie == null) |
| | 0 | 599 | | { |
| | 0 | 600 | | if (parser.EndofHeader()) |
| | 0 | 601 | | { |
| | 0 | 602 | | break; |
| | | 603 | | } |
| | 0 | 604 | | continue; |
| | | 605 | | } |
| | | 606 | | |
| | | 607 | | // Parser marks invalid cookies this way |
| | 0 | 608 | | if (string.IsNullOrEmpty(cookie.Name)) |
| | 0 | 609 | | { |
| | 0 | 610 | | throw new CookieException(SR.net_cookie_format); |
| | | 611 | | } |
| | | 612 | | |
| | | 613 | | // This will set the default values from the response URI |
| | | 614 | | // AND will check for cookie validity |
| | 0 | 615 | | cookie.VerifyAndSetDefaults(variant, uri); |
| | | 616 | | // If many same cookies arrive we collapse them into just one, hence setting |
| | | 617 | | // parameter isStrict = true below |
| | 0 | 618 | | cookies.InternalAdd(cookie, true); |
| | 0 | 619 | | } while (true); |
| | 0 | 620 | | } |
| | 0 | 621 | | catch (OutOfMemoryException) |
| | 0 | 622 | | { |
| | 0 | 623 | | throw; |
| | | 624 | | } |
| | 0 | 625 | | catch (Exception e) |
| | 0 | 626 | | { |
| | 0 | 627 | | throw new CookieException(SR.Format(SR.net_cookie_parse_header, uri.AbsoluteUri), e); |
| | | 628 | | } |
| | | 629 | | |
| | 0 | 630 | | int cookiesCount = cookies.Count; |
| | 0 | 631 | | for (int i = 0; i < cookiesCount; i++) |
| | 0 | 632 | | { |
| | 0 | 633 | | InternalAdd((Cookie)cookies[i]); |
| | 0 | 634 | | } |
| | | 635 | | |
| | 0 | 636 | | return cookies; |
| | 0 | 637 | | } |
| | | 638 | | |
| | | 639 | | public CookieCollection GetCookies(Uri uri) |
| | 0 | 640 | | { |
| | 0 | 641 | | ArgumentNullException.ThrowIfNull(uri); |
| | | 642 | | |
| | 0 | 643 | | return InternalGetCookies(uri) ?? new CookieCollection(); |
| | 0 | 644 | | } |
| | | 645 | | |
| | | 646 | | /// <summary>Gets a <see cref="CookieCollection"/> that contains all of the <see cref="Cookie"/> instances in th |
| | | 647 | | /// <returns>A <see cref="CookieCollection"/> that contains all of the <see cref="Cookie"/> instances in the con |
| | | 648 | | public CookieCollection GetAllCookies() |
| | 0 | 649 | | { |
| | 0 | 650 | | var result = new CookieCollection(); |
| | | 651 | | |
| | 0 | 652 | | lock (m_domainTable.SyncRoot) |
| | 0 | 653 | | { |
| | 0 | 654 | | IDictionaryEnumerator lists = m_domainTable.GetEnumerator(); |
| | 0 | 655 | | while (lists.MoveNext()) |
| | 0 | 656 | | { |
| | 0 | 657 | | PathList list = (PathList)lists.Value!; |
| | 0 | 658 | | lock (list.SyncRoot) |
| | 0 | 659 | | { |
| | 0 | 660 | | IDictionaryEnumerator collections = list.List.GetEnumerator(); |
| | 0 | 661 | | while (collections.MoveNext()) |
| | 0 | 662 | | { |
| | 0 | 663 | | result.Add((CookieCollection)collections.Value!); |
| | 0 | 664 | | } |
| | 0 | 665 | | } |
| | 0 | 666 | | } |
| | 0 | 667 | | } |
| | | 668 | | |
| | 0 | 669 | | return result; |
| | 0 | 670 | | } |
| | | 671 | | |
| | | 672 | | internal CookieCollection? InternalGetCookies(Uri uri) |
| | 0 | 673 | | { |
| | 0 | 674 | | if (m_count == 0) |
| | 0 | 675 | | { |
| | 0 | 676 | | return null; |
| | | 677 | | } |
| | | 678 | | |
| | 0 | 679 | | bool isSecure = (uri.Scheme == UriScheme.Https || uri.Scheme == UriScheme.Wss); |
| | 0 | 680 | | int port = uri.Port; |
| | 0 | 681 | | CookieCollection? cookies = null; |
| | | 682 | | |
| | 0 | 683 | | List<string> matchingDomainKeys = [uri.Host]; |
| | 0 | 684 | | ReadOnlySpan<char> host = uri.Host; |
| | 0 | 685 | | int lastDot = host.LastIndexOf('.'); |
| | 0 | 686 | | while (lastDot > 0) |
| | 0 | 687 | | { |
| | 0 | 688 | | int dot = host[..lastDot].LastIndexOf('.'); |
| | 0 | 689 | | if (dot > 0) |
| | 0 | 690 | | { |
| | 0 | 691 | | string match = host[(dot + 1)..].ToString(); |
| | 0 | 692 | | matchingDomainKeys.Add(match); |
| | 0 | 693 | | } |
| | | 694 | | |
| | 0 | 695 | | lastDot = dot; |
| | 0 | 696 | | } |
| | | 697 | | |
| | 0 | 698 | | BuildCookieCollectionFromDomainMatches(uri, isSecure, port, ref cookies, matchingDomainKeys); |
| | 0 | 699 | | return cookies; |
| | 0 | 700 | | } |
| | | 701 | | |
| | | 702 | | private void BuildCookieCollectionFromDomainMatches(Uri uri, bool isSecure, int port, ref CookieCollection? cook |
| | 0 | 703 | | { |
| | 0 | 704 | | for (int i = 0; i < matchingDomainKeys.Count; i++) |
| | 0 | 705 | | { |
| | | 706 | | PathList pathList; |
| | 0 | 707 | | lock (m_domainTable.SyncRoot) |
| | 0 | 708 | | { |
| | 0 | 709 | | pathList = (PathList)m_domainTable[matchingDomainKeys[i]]!; |
| | 0 | 710 | | if (pathList == null) |
| | 0 | 711 | | { |
| | 0 | 712 | | continue; |
| | | 713 | | } |
| | 0 | 714 | | } |
| | | 715 | | |
| | 0 | 716 | | lock (pathList.SyncRoot) |
| | 0 | 717 | | { |
| | 0 | 718 | | SortedList list = pathList.List; |
| | 0 | 719 | | int listCount = list.Count; |
| | 0 | 720 | | for (int e = 0; e < listCount; e++) |
| | 0 | 721 | | { |
| | 0 | 722 | | string path = (string)list.GetKey(e); |
| | 0 | 723 | | if (PathMatch(uri.AbsolutePath, path)) |
| | 0 | 724 | | { |
| | 0 | 725 | | CookieCollection cc = (CookieCollection)list.GetByIndex(e)!; |
| | 0 | 726 | | cc.TimeStamp(CookieCollection.Stamp.Set); |
| | 0 | 727 | | MergeUpdateCollections(ref cookies, uri.Host, cc, port, isSecure); |
| | 0 | 728 | | } |
| | 0 | 729 | | } |
| | 0 | 730 | | } |
| | | 731 | | |
| | | 732 | | // Remove unused domain. |
| | 0 | 733 | | if (pathList.Count == 0) |
| | 0 | 734 | | { |
| | 0 | 735 | | lock (m_domainTable.SyncRoot) |
| | 0 | 736 | | { |
| | 0 | 737 | | m_domainTable.Remove(matchingDomainKeys[i]); |
| | 0 | 738 | | } |
| | 0 | 739 | | } |
| | 0 | 740 | | } |
| | 0 | 741 | | } |
| | | 742 | | |
| | | 743 | | // Implement path-matching according to https://tools.ietf.org/html/rfc6265#section-5.1.4: |
| | | 744 | | // | A request-path path-matches a given cookie-path if at least one of the following conditions holds: |
| | | 745 | | // | - The cookie-path and the request-path are identical. |
| | | 746 | | // | - The cookie-path is a prefix of the request-path, and the last character of the cookie-path is %x2F ("/"). |
| | | 747 | | // | - The cookie-path is a prefix of the request-path, and the first character of the request-path that is not |
| | | 748 | | // The latter conditions are needed to make sure that |
| | | 749 | | // PathMatch("/fooBar, "/foo") == false |
| | | 750 | | // but: |
| | | 751 | | // PathMatch("/foo/bar", "/foo") == true, PathMatch("/foo/bar", "/foo/") == true |
| | | 752 | | private static bool PathMatch(string requestPath, string cookiePath) |
| | 0 | 753 | | { |
| | 0 | 754 | | cookiePath = CookieParser.CheckQuoted(cookiePath); |
| | | 755 | | |
| | 0 | 756 | | if (!requestPath.StartsWith(cookiePath, StringComparison.Ordinal)) |
| | 0 | 757 | | return false; |
| | 0 | 758 | | return requestPath.Length == cookiePath.Length || |
| | 0 | 759 | | cookiePath.EndsWith('/') || |
| | 0 | 760 | | requestPath[cookiePath.Length] == '/'; |
| | 0 | 761 | | } |
| | | 762 | | |
| | | 763 | | private void MergeUpdateCollections(ref CookieCollection? destination, string host, CookieCollection source, int |
| | 0 | 764 | | { |
| | 0 | 765 | | lock (source) |
| | 0 | 766 | | { |
| | | 767 | | // Cannot use foreach as we are going to update 'source' |
| | 0 | 768 | | for (int idx = 0; idx < source.Count; ++idx) |
| | 0 | 769 | | { |
| | 0 | 770 | | bool to_add = false; |
| | | 771 | | |
| | 0 | 772 | | Cookie cookie = source[idx]; |
| | | 773 | | |
| | 0 | 774 | | if (cookie.Expired) |
| | 0 | 775 | | { |
| | | 776 | | // If expired, remove from container and don't add to the destination |
| | 0 | 777 | | source.RemoveAt(idx); |
| | 0 | 778 | | --m_count; |
| | 0 | 779 | | --idx; |
| | 0 | 780 | | } |
| | | 781 | | else |
| | 0 | 782 | | { |
| | 0 | 783 | | if (cookie.PortList != null) |
| | 0 | 784 | | { |
| | 0 | 785 | | foreach (int p in cookie.PortList) |
| | 0 | 786 | | { |
| | 0 | 787 | | if (p == port) |
| | 0 | 788 | | { |
| | 0 | 789 | | to_add = true; |
| | 0 | 790 | | break; |
| | | 791 | | } |
| | 0 | 792 | | } |
| | 0 | 793 | | } |
| | | 794 | | else |
| | 0 | 795 | | { |
| | | 796 | | // It was implicit Port, always OK to add. |
| | 0 | 797 | | to_add = true; |
| | 0 | 798 | | } |
| | | 799 | | |
| | | 800 | | // Refuse to add a secure cookie into an 'unsecure' destination |
| | 0 | 801 | | if (cookie.Secure && !isSecure) |
| | 0 | 802 | | { |
| | 0 | 803 | | to_add = false; |
| | 0 | 804 | | } |
| | | 805 | | |
| | | 806 | | // For implicit domains exact match is needed |
| | 0 | 807 | | if (cookie.DomainImplicit && !string.Equals(host, cookie.Domain, StringComparison.OrdinalIgnoreC |
| | 0 | 808 | | { |
| | 0 | 809 | | to_add = false; |
| | 0 | 810 | | } |
| | | 811 | | |
| | 0 | 812 | | if (to_add) |
| | 0 | 813 | | { |
| | | 814 | | // In 'source' are already ordered. |
| | | 815 | | // If two same cookies come from different 'source' then they |
| | | 816 | | // will follow (not replace) each other. |
| | 0 | 817 | | destination ??= new CookieCollection(); |
| | 0 | 818 | | destination.InternalAdd(cookie, false); |
| | 0 | 819 | | } |
| | 0 | 820 | | } |
| | 0 | 821 | | } |
| | 0 | 822 | | } |
| | 0 | 823 | | } |
| | | 824 | | |
| | | 825 | | public string GetCookieHeader(Uri uri) |
| | 0 | 826 | | { |
| | 0 | 827 | | ArgumentNullException.ThrowIfNull(uri); |
| | | 828 | | |
| | 0 | 829 | | return GetCookieHeader(uri, out _); |
| | 0 | 830 | | } |
| | | 831 | | |
| | | 832 | | internal string GetCookieHeader(Uri uri, out string optCookie2) |
| | 0 | 833 | | { |
| | 0 | 834 | | CookieCollection? cookies = InternalGetCookies(uri); |
| | 0 | 835 | | if (cookies == null) |
| | 0 | 836 | | { |
| | 0 | 837 | | optCookie2 = string.Empty; |
| | 0 | 838 | | return string.Empty; |
| | | 839 | | } |
| | | 840 | | |
| | 0 | 841 | | string delimiter = string.Empty; |
| | | 842 | | |
| | 0 | 843 | | StringBuilder builder = StringBuilderCache.Acquire(); |
| | 0 | 844 | | for (int i = 0; i < cookies.Count; i++) |
| | 0 | 845 | | { |
| | 0 | 846 | | builder.Append(delimiter); |
| | 0 | 847 | | cookies[i].ToString(builder); |
| | | 848 | | |
| | 0 | 849 | | delimiter = "; "; |
| | 0 | 850 | | } |
| | | 851 | | |
| | 0 | 852 | | optCookie2 = cookies.IsOtherVersionSeen ? |
| | 0 | 853 | | (Cookie.SpecialAttributeLiteral + |
| | 0 | 854 | | CookieFields.VersionAttributeName + |
| | 0 | 855 | | Cookie.EqualsLiteral + |
| | 0 | 856 | | Cookie.MaxSupportedVersionString) : string.Empty; |
| | | 857 | | |
| | 0 | 858 | | return StringBuilderCache.GetStringAndRelease(builder); |
| | 0 | 859 | | } |
| | | 860 | | |
| | | 861 | | public void SetCookies(Uri uri, string cookieHeader) |
| | 0 | 862 | | { |
| | 0 | 863 | | ArgumentNullException.ThrowIfNull(uri); |
| | 0 | 864 | | ArgumentNullException.ThrowIfNull(cookieHeader); |
| | | 865 | | |
| | 0 | 866 | | CookieCutter(uri, null, cookieHeader); // Will throw on error |
| | 0 | 867 | | } |
| | | 868 | | } |
| | | 869 | | |
| | | 870 | | // PathList needs to be public in order to maintain binary serialization compatibility as the System shim |
| | | 871 | | // needs to have access to type-forward it. |
| | | 872 | | [Serializable] |
| | | 873 | | [System.Runtime.CompilerServices.TypeForwardedFrom("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c5 |
| | | 874 | | public sealed class PathList |
| | | 875 | | { |
| | | 876 | | // Usage of PathList depends on it being shallowly immutable; |
| | | 877 | | // adding any mutable fields to it would result in breaks. |
| | | 878 | | private readonly SortedList m_list = SortedList.Synchronized(new SortedList(PathListComparer.StaticInstance)); / |
| | | 879 | | |
| | | 880 | | internal int Count => m_list.Count; |
| | | 881 | | |
| | | 882 | | internal int GetCookiesCount() |
| | | 883 | | { |
| | | 884 | | int count = 0; |
| | | 885 | | lock (SyncRoot) |
| | | 886 | | { |
| | | 887 | | IList list = m_list.GetValueList(); |
| | | 888 | | int listCount = list.Count; |
| | | 889 | | for (int i = 0; i < listCount; i++) |
| | | 890 | | { |
| | | 891 | | count += ((CookieCollection)list[i]!).Count; |
| | | 892 | | } |
| | | 893 | | } |
| | | 894 | | return count; |
| | | 895 | | } |
| | | 896 | | |
| | | 897 | | internal ICollection Values |
| | | 898 | | { |
| | | 899 | | get |
| | | 900 | | { |
| | | 901 | | return m_list.Values; |
| | | 902 | | } |
| | | 903 | | } |
| | | 904 | | |
| | | 905 | | internal object? this[string s] |
| | | 906 | | { |
| | | 907 | | get |
| | | 908 | | { |
| | | 909 | | lock (SyncRoot) |
| | | 910 | | { |
| | | 911 | | return m_list[s]; |
| | | 912 | | } |
| | | 913 | | } |
| | | 914 | | set |
| | | 915 | | { |
| | | 916 | | lock (SyncRoot) |
| | | 917 | | { |
| | | 918 | | Debug.Assert(value != null); |
| | | 919 | | m_list[s] = value; |
| | | 920 | | } |
| | | 921 | | } |
| | | 922 | | } |
| | | 923 | | |
| | | 924 | | internal IDictionaryEnumerator GetEnumerator() |
| | | 925 | | { |
| | | 926 | | lock (SyncRoot) |
| | | 927 | | { |
| | | 928 | | return m_list.GetEnumerator(); |
| | | 929 | | } |
| | | 930 | | } |
| | | 931 | | |
| | | 932 | | internal void Remove(object key) |
| | | 933 | | { |
| | | 934 | | lock (SyncRoot) |
| | | 935 | | { |
| | | 936 | | m_list.Remove(key); |
| | | 937 | | } |
| | | 938 | | } |
| | | 939 | | |
| | | 940 | | internal SortedList List => m_list; |
| | | 941 | | |
| | | 942 | | internal object SyncRoot => m_list.SyncRoot; |
| | | 943 | | |
| | | 944 | | [Serializable] |
| | | 945 | | [System.Runtime.CompilerServices.TypeForwardedFrom("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77 |
| | | 946 | | private sealed class PathListComparer : IComparer |
| | | 947 | | { |
| | | 948 | | internal static readonly PathListComparer StaticInstance = new PathListComparer(); |
| | | 949 | | |
| | | 950 | | int IComparer.Compare(object? ol, object? or) |
| | | 951 | | { |
| | | 952 | | string pathLeft = CookieParser.CheckQuoted((string)ol!); |
| | | 953 | | string pathRight = CookieParser.CheckQuoted((string)or!); |
| | | 954 | | int ll = pathLeft.Length; |
| | | 955 | | int lr = pathRight.Length; |
| | | 956 | | int length = Math.Min(ll, lr); |
| | | 957 | | |
| | | 958 | | for (int i = 0; i < length; ++i) |
| | | 959 | | { |
| | | 960 | | if (pathLeft[i] != pathRight[i]) |
| | | 961 | | { |
| | | 962 | | return pathLeft[i] - pathRight[i]; |
| | | 963 | | } |
| | | 964 | | } |
| | | 965 | | return lr - ll; |
| | | 966 | | } |
| | | 967 | | } |
| | | 968 | | } |
| | | 969 | | } |
| | | 970 | | |