add all

Packages/com.tivadar.best.http/Runtime/HTTP/Cookies/Cookie.cs

@@ -0,0 +1,417 @@
+using Best.HTTP.Shared;
+using Best.HTTP.Shared.Extensions;
+using Best.HTTP.Shared.Logger;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Best.HTTP.Cookies
+{
+    /// <summary>
+    /// The Cookie implementation based on <see href="http://tools.ietf.org/html/rfc6265">RFC-6265</see>.
+    /// </summary>
+    public sealed class Cookie : IComparable<Cookie>, IEquatable<Cookie>
+    {
+        private const int Version = 1;
+
+        #region Public Properties
+
+        /// <summary>
+        /// The name of the cookie.
+        /// </summary>
+        public string Name { get; private set; }
+
+        /// <summary>
+        /// The value of the cookie.
+        /// </summary>
+        public string Value { get; private set; }
+
+        /// <summary>
+        /// The Date when the Cookie is registered.
+        /// </summary>
+        public DateTime Date { get; internal set; }
+
+        /// <summary>
+        /// When this Cookie last used in a request.
+        /// </summary>
+        public DateTime LastAccess { get; set; }
+
+        /// <summary>
+        /// The Expires attribute indicates the maximum lifetime of the cookie, represented as the date and time at which the cookie expires.
+        /// The user agent is not required to retain the cookie until the specified date has passed.
+        /// In fact, user agents often evict cookies due to memory pressure or privacy concerns.
+        /// </summary>
+        public DateTime Expires { get; private set; }
+
+        /// <summary>
+        /// The Max-Age attribute indicates the maximum lifetime of the cookie, represented as the number of seconds until the cookie expires.
+        /// The user agent is not required to retain the cookie for the specified duration.
+        /// In fact, user agents often evict cookies due to memory pressure or privacy concerns.
+        /// </summary>
+        public long MaxAge { get; private set; }
+
+        /// <summary>
+        /// If a cookie has neither the Max-Age nor the Expires attribute, the user agent will retain the cookie until "the current session is over".
+        /// </summary>
+        public bool IsSession { get; private set; }
+
+        /// <summary>
+        /// The Domain attribute specifies those hosts to which the cookie will be sent.
+        /// For example, if the value of the Domain attribute is "example.com", the user agent will include the cookie
+        /// in the Cookie header when making HTTP requests to example.com, www.example.com, and www.corp.example.com.
+        /// If the server omits the Domain attribute, the user agent will return the cookie only to the origin server.
+        /// </summary>
+        public string Domain { get; internal set; }
+
+        /// <summary>
+        /// The scope of each cookie is limited to a set of paths, controlled by the Path attribute.
+        /// If the server omits the Path attribute, the user agent will use the "directory" of the request-uri's path component as the default value.
+        /// </summary>
+        public string Path { get; internal set; }
+
+        /// <summary>
+        /// The Secure attribute limits the scope of the cookie to "secure" channels (where "secure" is defined by the user agent).
+        /// When a cookie has the Secure attribute, the user agent will include the cookie in an HTTP request only if the request is
+        /// transmitted over a secure channel (typically HTTP over Transport Layer Security (TLS)).
+        /// </summary>
+        public bool IsSecure { get; private set; }
+
+        /// <summary>
+        /// The HttpOnly attribute limits the scope of the cookie to HTTP requests.
+        /// In particular, the attribute instructs the user agent to omit the cookie when providing access to
+        /// cookies via "non-HTTP" APIs (such as a web browser API that exposes cookies to scripts).
+        /// </summary>
+        public bool IsHttpOnly { get; private set; }
+
+        /// <summary>
+        /// SameSite prevents the browser from sending this cookie along with cross-site requests.
+        /// The main goal is mitigate the risk of cross-origin information leakage.
+        /// It also provides some protection against cross-site request forgery attacks.
+        /// Possible values for the flag are lax or strict.
+        /// </summary>
+        /// <remarks>
+        /// More details can be found here:
+        /// <list type="bullet">
+        ///     <item><description><see href="https://web.dev/samesite-cookies-explained/">SameSite cookies explained</see></description></item>
+        /// </list>
+        /// </remarks>
+        public string SameSite { get; private set; }
+
+        #endregion
+
+        #region Public Constructors
+
+        public Cookie(string name, string value)
+            : this(name, value, "/", string.Empty)
+        { }
+
+        public Cookie(string name, string value, string path)
+            : this(name, value, path, string.Empty)
+        { }
+
+        public Cookie(string name, string value, string path, string domain)
+            : this() // call the parameter-less constructor to set default values
+        {
+            this.Name = name;
+            this.Value = value;
+            this.Path = path;
+            this.Domain = domain;
+        }
+
+        public Cookie(Uri uri, string name, string value, DateTime expires, bool isSession = true)
+            : this(name, value, uri.AbsolutePath, uri.Host)
+        {
+            this.Expires = expires;
+            this.IsSession = isSession;
+            this.Date = DateTime.UtcNow;
+        }
+
+        public Cookie(Uri uri, string name, string value, long maxAge = -1, bool isSession = true)
+            : this(name, value, uri.AbsolutePath, uri.Host)
+        {
+            this.MaxAge = maxAge;
+            this.IsSession = isSession;
+            this.Date = DateTime.UtcNow;
+            this.SameSite = "none";
+        }
+
+        #endregion
+
+        internal Cookie()
+        {
+            // If a cookie has neither the Max-Age nor the Expires attribute, the user agent will retain the cookie
+            //  until "the current session is over" (as defined by the user agent).
+            IsSession = true;
+            MaxAge = -1;
+            LastAccess = DateTime.UtcNow;
+        }
+
+        public string ToHeaderValue() => string.Concat(this.Name, "=", this.Value);
+
+        public bool WillExpireInTheFuture()
+        {
+            // No Expires or Max-Age value sent from the server, we will fake the return value so we will not delete a freshly received cookie
+            if (IsSession)
+                return true;
+
+            // If a cookie has both the Max-Age and the Expires attribute, the Max-Age attribute has precedence and controls the expiration date of the cookie.
+            return MaxAge != -1 ?
+                    Math.Max(0, (long)(DateTime.UtcNow - Date).TotalSeconds) < MaxAge :
+                    Expires > DateTime.UtcNow;
+        }
+
+        /// <summary>
+        /// Guess the storage size of the cookie.
+        /// </summary>
+        /// <returns></returns>
+        public uint GuessSize()
+        {
+            return (uint)((this.Name != null ? this.Name.Length * sizeof(char) : 0) +
+                          (this.Value != null ? this.Value.Length * sizeof(char) : 0) +
+                          (this.Domain != null ? this.Domain.Length * sizeof(char) : 0) +
+                          (this.Path != null ? this.Path.Length * sizeof(char) : 0) +
+                          (this.SameSite != null ? this.SameSite.Length * sizeof(char) : 0) +
+                          (sizeof(long) * 4) +
+                          (sizeof(bool) * 3));
+        }
+
+        public static Cookie Parse(string header, Uri defaultDomain, LoggingContext context)
+        {
+            Cookie cookie = new Cookie();
+            try
+            {
+                var kvps = ParseCookieHeader(header);
+
+                foreach (var kvp in kvps)
+                {
+                    switch (kvp.Key.ToLowerInvariant())
+                    {
+                        case "path":
+                            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
+                            // If the attribute-value is empty or if the first character of the attribute-value is not %x2F ("/"):
+                            //  Let cookie-path be the default-path.
+                            cookie.Path = string.IsNullOrEmpty(kvp.Value) || !kvp.Value.StartsWith("/") ? "/" : cookie.Path = kvp.Value;
+                            break;
+
+                        case "domain":
+                            // If the attribute-value is empty, the behavior is undefined. However, the user agent SHOULD ignore the cookie-av entirely.
+                            if (string.IsNullOrEmpty(kvp.Value))
+                                return null;
+
+                            // If the first character of the attribute-value string is %x2E ("."):
+                            //  Let cookie-domain be the attribute-value without the leading %x2E (".") character.
+                            cookie.Domain = kvp.Value.StartsWith(".") ? kvp.Value.Substring(1) : kvp.Value;
+                            break;
+
+                        case "expires":
+                            cookie.Expires = kvp.Value.ToDateTime(DateTime.FromBinary(0));
+                            cookie.IsSession = false;
+                            break;
+
+                        case "max-age":
+                            cookie.MaxAge = kvp.Value.ToInt64(-1);
+                            cookie.IsSession = false;
+                            break;
+
+                        case "secure":
+                            cookie.IsSecure = true;
+                            break;
+
+                        case "httponly":
+                            cookie.IsHttpOnly = true;
+                            break;
+
+                        case "samesite":
+                            cookie.SameSite = kvp.Value;
+                            break;
+
+                        default:
+                            // check whether name is already set to avoid overwriting it with a non-listed setting
+                            if (string.IsNullOrEmpty(cookie.Name))
+                            {
+                                cookie.Name = kvp.Key;
+                                cookie.Value = kvp.Value;
+                            }
+                            break;
+                    }
+                }
+
+                // Some user agents provide users the option of preventing persistent storage of cookies across sessions.
+                // When configured thusly, user agents MUST treat all received cookies as if the persistent-flag were set to false.
+                if (CookieJar.IsSessionOverride)
+                    cookie.IsSession = true;
+
+                // http://tools.ietf.org/html/rfc6265#section-4.1.2.3
+                // WARNING: Some existing user agents treat an absent Domain attribute as if the Domain attribute were present and contained the current host name.
+                // For example, if example.com returns a Set-Cookie header without a Domain attribute, these user agents will erroneously send the cookie to www.example.com as well.
+                if (string.IsNullOrEmpty(cookie.Domain))
+                    cookie.Domain = defaultDomain.Host;
+
+                // http://tools.ietf.org/html/rfc6265#section-5.3 section 7:
+                // If the cookie-attribute-list contains an attribute with an attribute-name of "Path",
+                // set the cookie's path to attribute-value of the last attribute in the cookie-attribute-list with an attribute-name of "Path".
+                // __Otherwise, set the cookie's path to the default-path of the request-uri.__
+                if (string.IsNullOrEmpty(cookie.Path))
+                {
+                    // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
+                    // 1. Let uri-path be the path portion of the request-uri if such a portion exists
+                    cookie.Path = defaultDomain.AbsolutePath;
+
+                    // 2. If the uri-path is empty or if the first character of the uri-path is not a % x2F("/") character,
+                    // output % x2F("/") and skip the remaining steps.
+                    // Uri's AbsolutePath always emits at least a '/' character.
+
+                    // 3. If the uri-path contains no more than one %x2F ("/") character,
+                    // output % x2F("/") and skip the remaining step.
+
+                    int slashCount = 1;
+                    int lastSlashIdx = 0;
+                    for (int i = 1; i < cookie.Path.Length; i++)
+                    {
+                        if (cookie.Path[i] == '/')
+                        {
+                            slashCount++;
+                            lastSlashIdx = i;
+                        }
+                    }
+
+                    if (slashCount == 1)
+                    {
+                        cookie.Path = "/";
+                    }
+                    else
+                    {
+                        // 4. Output the characters of the uri-path from the first character up to,
+                        // but not including, the right-most % x2F("/").
+
+                        cookie.Path = cookie.Path.Substring(0, lastSlashIdx);
+                    }
+                }
+
+                cookie.Date = cookie.LastAccess = DateTime.UtcNow;
+            }
+            catch (Exception ex)
+            {
+                HTTPManager.Logger.Warning("Cookie", "Parse - Couldn't parse header: " + header + " exception: " + ex.ToString() + " " + ex.StackTrace, context);
+            }
+            return cookie;
+        }
+
+        #region Save & Load
+
+        internal void SaveTo(BinaryWriter stream)
+        {
+            stream.Write(Version);
+            stream.Write(Name ?? string.Empty);
+            stream.Write(Value ?? string.Empty);
+            stream.Write(Date.ToBinary());
+            stream.Write(LastAccess.ToBinary());
+            stream.Write(Expires.ToBinary());
+            stream.Write(MaxAge);
+            stream.Write(IsSession);
+            stream.Write(Domain ?? string.Empty);
+            stream.Write(Path ?? string.Empty);
+            stream.Write(IsSecure);
+            stream.Write(IsHttpOnly);
+        }
+
+        internal void LoadFrom(BinaryReader stream)
+        {
+            /*int version = */stream.ReadInt32();
+            this.Name = stream.ReadString();
+            this.Value = stream.ReadString();
+            this.Date = DateTime.FromBinary(stream.ReadInt64());
+            this.LastAccess = DateTime.FromBinary(stream.ReadInt64());
+            this.Expires = DateTime.FromBinary(stream.ReadInt64());
+            this.MaxAge = stream.ReadInt64();
+            this.IsSession = stream.ReadBoolean();
+            this.Domain = stream.ReadString();
+            this.Path = stream.ReadString();
+            this.IsSecure = stream.ReadBoolean();
+            this.IsHttpOnly = stream.ReadBoolean();
+        }
+
+        #endregion
+
+        #region Overrides and new Equals function
+
+        public override string ToString()
+            => $"[Cookie '{this.Name}' = '{this.Value}', {this.IsSession}, '{this.Path}']";
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+                return false;
+
+            return this.Equals(obj as Cookie);
+        }
+
+        public bool Equals(Cookie cookie)
+        {
+            if (cookie == null)
+                return false;
+
+            if (Object.ReferenceEquals(this, cookie))
+                return true;
+
+            return this.Name.Equals(cookie.Name, StringComparison.Ordinal) &&
+                ((this.Domain == null && cookie.Domain == null) || this.Domain.Equals(cookie.Domain, StringComparison.Ordinal)) &&
+                ((this.Path == null && cookie.Path == null) || this.Path.Equals(cookie.Path, StringComparison.Ordinal));
+        }
+
+        public override int GetHashCode()
+        {
+            return this.ToString().GetHashCode();
+        }
+
+        #endregion
+
+        #region Private Helper Functions
+
+        private static string ReadValue(string str, ref int pos)
+        {
+            string result = string.Empty;
+            if (str == null)
+                return result;
+
+            return str.Read(ref pos, ';');
+        }
+
+        private static List<HeaderValue> ParseCookieHeader(string str)
+        {
+            List<HeaderValue> result = new List<HeaderValue>();
+
+            if (str == null)
+                return result;
+
+            int idx = 0;
+
+            // process the rest of the text
+            while (idx < str.Length)
+            {
+                // Read key
+                string key = str.Read(ref idx, (ch) => ch != '=' && ch != ';').Trim();
+                HeaderValue qp = new HeaderValue(key);
+
+                if (idx < str.Length && str[idx - 1] == '=')
+                    qp.Value = ReadValue(str, ref idx);
+
+                result.Add(qp);
+            }
+
+            return result;
+        }
+
+        #endregion
+
+        #region IComparable<Cookie> implementation
+
+        public int CompareTo(Cookie other)
+        {
+            return this.LastAccess.CompareTo(other.LastAccess);
+        }
+
+        #endregion
+    }
+}

Packages/com.tivadar.best.http/Runtime/HTTP/Cookies/Cookie.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e66d7566eee7c6245bb8a838fe4b3286
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.tivadar.best.http/Runtime/HTTP/Cookies/CookieJar.cs

@@ -0,0 +1,677 @@
+using Best.HTTP.Hosts.Connections;
+using Best.HTTP.Shared;
+using Best.HTTP.Shared.Extensions;
+using Best.HTTP.Shared.PlatformSupport.FileSystem;
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Best.HTTP.Cookies
+{
+    /// <summary>
+    /// The Cookie Jar implementation based on <see href="http://tools.ietf.org/html/rfc6265">RFC 6265</see>.
+    /// </summary>
+    public static class CookieJar
+    {
+        /// <summary>
+        /// Maximum size of the Cookie Jar in bytes. It's default value is 10485760 (10 MB).
+        /// </summary>
+        public static uint MaximumSize { get; set; } = 10 * 1024 * 1024;
+
+        // Version of the cookie store. It may be used in a future version for maintaining compatibility.
+        private const int Version = 1;
+
+        /// <summary>
+        /// Returns true if File apis are supported.
+        /// </summary>
+        public static bool IsSavingSupported
+        {
+            get
+            {
+                if (IsSupportCheckDone)
+                    return _isSavingSupported;
+
+                try
+                {
+#if UNITY_WEBGL && !UNITY_EDITOR
+                    _isSavingSupported = false;
+#else
+                    HTTPManager.IOService.DirectoryExists(HTTPManager.GetRootSaveFolder());
+                    _isSavingSupported = true;
+#endif
+                }
+                catch
+                {
+                    _isSavingSupported = false;
+
+                    HTTPManager.Logger.Warning(nameof(CookieJar), "Cookie saving and loading disabled!");
+                }
+                finally
+                {
+                    IsSupportCheckDone = true;
+                }
+
+                return _isSavingSupported;
+            }
+        }
+
+        /// <summary>
+        /// The plugin will delete cookies that are accessed this threshold ago. Its default value is 7 days.
+        /// </summary>
+        public static TimeSpan AccessThreshold = TimeSpan.FromDays(7);
+
+        /// <summary>
+        /// If this property is set to <c>true</c>, then new cookies treated as session cookies and these cookies are not saved to disk. Its default value is <c>false</c>.
+        /// </summary>
+        public static bool IsSessionOverride = false;
+
+        /// <summary>
+        /// Enabled or disables storing and handling of cookies. If set to false, <see cref="HTTPRequest">HTTPRequests</see> aren't searched for cookies and no cookies will be set for <see cref="HTTPResponse"/>s.
+        /// </summary>
+        public static bool IsEnabled = true;
+
+        #region Privates
+
+        /// <summary>
+        /// List of the Cookies
+        /// </summary>
+        private static List<Cookie> Cookies = new List<Cookie>();
+        private static string CookieFolder { get; set; }
+        private static string LibraryPath { get; set; }
+
+        /// <summary>
+        /// Synchronization object for thread safety.
+        /// </summary>
+        private static ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
+
+        private static bool _isSavingSupported;
+        private static bool IsSupportCheckDone;
+
+        private static bool Loaded;
+        private static RunOnceOnMainThread _saveLibraryRunner = new RunOnceOnMainThread(Persist, null);
+
+        #endregion
+
+        #region Internal Functions
+
+        internal static void SetupFolder()
+        {
+            if (!CookieJar.IsSavingSupported)
+                return;
+
+            try
+            {
+                if (string.IsNullOrEmpty(CookieFolder) || string.IsNullOrEmpty(LibraryPath))
+                {
+                    CookieFolder = System.IO.Path.Combine(HTTPManager.GetRootSaveFolder(), "Cookies");
+                    LibraryPath = System.IO.Path.Combine(CookieFolder, "Library");
+
+                    if (HTTPManager.Logger.IsDiagnostic)
+                        HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(SetupFolder)}() - {nameof(LibraryPath)}: '{LibraryPath}'");
+                }
+            }
+            catch
+            { }
+        }
+
+        /// <summary>
+        /// Will set or update all cookies from the response object.
+        /// </summary>
+        internal static bool SetFromRequest(HTTPResponse response)
+        {
+            if (response == null || !IsEnabled)
+                return false;
+
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(SetFromRequest)}({response})", response.Context);
+
+            List<Cookie> newCookies = new List<Cookie>();
+            var setCookieHeaders = response.GetHeaderValues("set-cookie");
+
+            // No cookies. :'(
+            if (setCookieHeaders == null)
+                return false;
+
+            foreach (var cookieHeader in setCookieHeaders)
+            {
+                Cookie cookie = Cookie.Parse(cookieHeader, response.Request.CurrentUri, response.Request.Context);
+                if (cookie != null)
+                {
+                    rwLock.EnterWriteLock();
+                    try
+                    {
+                        int idx;
+                        var old = Find(cookie, out idx);
+
+                        // if no value for the cookie or already expired then the server asked us to delete the cookie
+                        bool expired = string.IsNullOrEmpty(cookie.Value) || !cookie.WillExpireInTheFuture();
+
+                        if (!expired)
+                        {
+                            // no old cookie, add it straight to the list
+                            if (old == null)
+                            {
+                                Cookies.Add(cookie);
+
+                                newCookies.Add(cookie);
+
+                                if (HTTPManager.Logger.IsDiagnostic)
+                                    HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(SetFromRequest)}({response}) - new cookie: {cookie}", response.Context);
+                            }
+                            else
+                            {
+                                // Update the creation-time of the newly created cookie to match the creation-time of the old-cookie.
+                                cookie.Date = old.Date;
+                                Cookies[idx] = cookie;
+
+                                newCookies.Add(cookie);
+
+                                if (HTTPManager.Logger.IsDiagnostic)
+                                    HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(SetFromRequest)}({response}) - refresh cookie: {cookie}", response.Context);
+                            }
+                        }
+                        else if (idx != -1) // delete the cookie
+                        {
+                            if (HTTPManager.Logger.IsDiagnostic)
+                                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(SetFromRequest)}({response}) - deleting cookie: {Cookies[idx]}", response.Context);
+
+                            Cookies.RemoveAt(idx);
+                        }
+                    }
+                    catch (Exception ex) when (HTTPManager.Logger.IsDiagnostic)
+                    {
+                        HTTPManager.Logger.Exception(nameof(CookieJar), $"{nameof(SetFromRequest)}({response})", ex, response.Context);
+                    }
+                    finally
+                    {
+                        rwLock.ExitWriteLock();
+                    }
+                }
+            }
+
+            _saveLibraryRunner.Subscribe();
+
+            return true;
+        }
+
+        internal static void SetupRequest(HTTPRequest request)
+        {
+            if (!IsEnabled)
+                return;
+
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(SetFromRequest)}({request})", request.Context);
+
+            // Cookies
+            // User added cookies are sent even when IsCookiesEnabled is set to false
+            List<Cookie> cookies = CookieJar.Get(request.CurrentUri);
+
+            // http://tools.ietf.org/html/rfc6265#section-5.4
+            //  -When the user agent generates an HTTP request, the user agent MUST NOT attach more than one Cookie header field.
+            if (cookies != null && cookies.Count > 0)
+            {
+                // Room for improvement:
+                //   2. The user agent SHOULD sort the cookie-list in the following order:
+                //      *  Cookies with longer paths are listed before cookies with shorter paths.
+                //      *  Among cookies that have equal-length path fields, cookies with earlier creation-times are listed before cookies with later creation-times.
+
+                bool first = true;
+                string cookieStr = string.Empty;
+
+                bool isSecureProtocolInUse = HTTPProtocolFactory.IsSecureProtocol(request.CurrentUri);
+
+                foreach (var cookie in cookies)
+                    if (!cookie.IsSecure || (cookie.IsSecure && isSecureProtocolInUse))
+                    {
+                        if (!first)
+                            cookieStr += "; ";
+                        else
+                            first = false;
+
+                        cookieStr += cookie.ToHeaderValue();
+
+                        // 3. Update the last-access-time of each cookie in the cookie-list to the current date and time.
+                        cookie.LastAccess = DateTime.UtcNow;
+                    }
+
+                if (!string.IsNullOrEmpty(cookieStr))
+                    request.SetHeader("Cookie", cookieStr);
+            }
+        }
+
+        /// <summary>
+        /// Deletes all expired or 'old' cookies, and will keep the sum size of cookies under the given size.
+        /// </summary>
+        internal static void Maintain(bool sendEvent)
+        {
+            // It's not the same as in the rfc:
+            //  http://tools.ietf.org/html/rfc6265#section-5.3
+
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Maintain)}({sendEvent})");
+
+            rwLock.EnterWriteLock();
+            try
+            {
+                uint size = 0;
+
+                for (int i = 0; i < Cookies.Count;)
+                {
+                    var cookie = Cookies[i];
+
+                    // Remove expired or not used cookies
+                    if (!cookie.WillExpireInTheFuture() || (cookie.LastAccess + AccessThreshold) < DateTime.UtcNow)
+                    {
+                        if (HTTPManager.Logger.IsDiagnostic)
+                            HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Maintain)}({sendEvent}) - removing expired cookie: {cookie}");
+
+                        Cookies.RemoveAt(i);
+                    }
+                    else
+                    {
+                        if (!cookie.IsSession)
+                            size += cookie.GuessSize();
+                        i++;
+                    }
+                }
+
+                if (size > MaximumSize)
+                {
+                    Cookies.Sort();
+
+                    while (size > MaximumSize && Cookies.Count > 0)
+                    {
+                        var cookie = Cookies[0];
+
+                        if (HTTPManager.Logger.IsDiagnostic)
+                            HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Maintain)}({sendEvent}) - removing cookie: {cookie}");
+
+                        Cookies.RemoveAt(0);
+
+                        size -= cookie.GuessSize();
+                    }
+                }
+            }
+            catch
+            { }
+            finally
+            {
+                rwLock.ExitWriteLock();
+            }
+
+            if (sendEvent)
+                _saveLibraryRunner.Subscribe();
+        }
+
+        /// <summary>
+        /// Saves the Cookie Jar to a file.
+        /// </summary>
+        /// <remarks>Not implemented under Unity WebPlayer</remarks>
+        internal static void Persist()
+        {
+            if (!IsSavingSupported)
+                return;
+
+            if (!Loaded)
+                return;
+
+            if (!IsEnabled)
+                return;
+
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Persist)}()");
+
+            // Delete any expired cookie
+            Maintain(false);
+
+            rwLock.EnterWriteLock();
+            try
+            {
+                if (!HTTPManager.IOService.DirectoryExists(CookieFolder))
+                    HTTPManager.IOService.DirectoryCreate(CookieFolder);
+
+                using (var fs = HTTPManager.IOService.CreateFileStream(LibraryPath, FileStreamModes.Create))
+                using (var bw = new System.IO.BinaryWriter(fs))
+                {
+                    bw.Write(Version);
+
+                    // Count how many non-session cookies we have
+                    int count = 0;
+                    foreach (var cookie in Cookies)
+                        if (!cookie.IsSession)
+                            count++;
+
+                    bw.Write(count);
+
+                    // Save only the persistable cookies
+                    foreach (var cookie in Cookies)
+                        if (!cookie.IsSession)
+                            cookie.SaveTo(bw);
+                }
+            }
+            catch
+            { }
+            finally
+            {
+                rwLock.ExitWriteLock();
+            }
+        }
+
+        /// <summary>
+        /// Load previously persisted cookie library from the file.
+        /// </summary>
+        internal static void Load()
+        {
+            if (!IsSavingSupported)
+                return;
+
+            if (Loaded)
+                return;
+
+            if (!IsEnabled)
+                return;
+
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Load)}()");
+
+            SetupFolder();
+
+            rwLock.EnterWriteLock();
+            try
+            {
+                Cookies.Clear();
+
+                if (!HTTPManager.IOService.DirectoryExists(CookieFolder))
+                    HTTPManager.IOService.DirectoryCreate(CookieFolder);
+
+                if (!HTTPManager.IOService.FileExists(LibraryPath))
+                    return;
+
+                using (var fs = HTTPManager.IOService.CreateFileStream(LibraryPath, FileStreamModes.OpenRead))
+                using (var br = new System.IO.BinaryReader(fs))
+                {
+                    /*int version = */br.ReadInt32();
+                    int cookieCount = br.ReadInt32();
+
+                    for (int i = 0; i < cookieCount; ++i)
+                    {
+                        Cookie cookie = new Cookie();
+                        cookie.LoadFrom(br);
+
+                        if (cookie.WillExpireInTheFuture())
+                            Cookies.Add(cookie);
+                    }
+                }
+            }
+            catch
+            {
+                Cookies.Clear();
+            }
+            finally
+            {
+                Loaded = true;
+                rwLock.ExitWriteLock();
+            }
+        }
+
+        #endregion
+
+        #region Public Functions
+
+        /// <summary>
+        /// Returns all Cookies that corresponds to the given Uri.
+        /// </summary>
+        public static List<Cookie> Get(Uri uri)
+        {
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Get)}({uri})");
+
+            Load();
+
+            rwLock.EnterReadLock();
+            try
+            {
+                List<Cookie> result = null;
+
+                for (int i = 0; i < Cookies.Count; ++i)
+                {
+                    Cookie cookie = Cookies[i];
+
+                    if (cookie == null)
+                        continue;
+
+                    bool willExpireInTheFuture = cookie.WillExpireInTheFuture();
+                    bool domainMatch = uri.Host.IndexOf(cookie.Domain) != -1 || string.Format("{0}:{1}", uri.Host, uri.Port).IndexOf(cookie.Domain) != -1;
+
+                    if (willExpireInTheFuture && domainMatch)
+                    {
+                        string requestPath = uri.AbsolutePath;
+
+                        // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
+                        // A request-path path-matches a given cookie-path if at least one of
+                        //    the following conditions holds:
+                        //    o  The cookie-path and the request-path are identical.
+                        bool exactMatch = cookie.Path.Equals(requestPath, StringComparison.Ordinal);
+
+                        //    o  The cookie-path is a prefix of the request-path, and the last
+                        //       character of the cookie-path is %x2F ("/").
+                        bool prefixMatch = cookie.Path[cookie.Path.Length - 1] == '/' && requestPath.StartsWith(cookie.Path, StringComparison.Ordinal);
+
+                        //    o  The cookie-path is a prefix of the request-path, and the first
+                        //       character of the request-path that is not included in the cookie-
+                        //       path is a %x2F ("/") character.
+                        bool prefixMatch2 = requestPath.Length > cookie.Path.Length &&
+                                            requestPath.StartsWith(cookie.Path, StringComparison.Ordinal) &&
+                                            requestPath[cookie.Path.Length] == '/';
+
+                        if (exactMatch || prefixMatch || prefixMatch2)
+                        {
+                            if (result == null)
+                                result = new List<Cookie>();
+
+                            result.Add(cookie);
+                        }
+                    }
+                }
+
+                return result;
+            }
+            finally
+            {
+                rwLock.ExitReadLock();
+            }
+        }
+
+        /// <summary>
+        /// Will add a new, or overwrite an old cookie if already exists.
+        /// </summary>
+        public static void Set(Uri uri, Cookie cookie)
+        {
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Set)}({uri}, {cookie})");
+
+            cookie.Domain = uri.Host;
+            cookie.Path = uri.AbsolutePath;
+
+            Set(cookie);
+        }
+
+        /// <summary>
+        /// Will add a new, or overwrite an old cookie if already exists.
+        /// </summary>
+        public static void Set(Cookie cookie)
+        {
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Set)}({cookie})");
+
+            Load();
+
+            rwLock.EnterWriteLock();
+            try
+            {
+                int idx;
+                Find(cookie, out idx);
+
+                if (idx >= 0)
+                    Cookies[idx] = cookie;
+                else
+                    Cookies.Add(cookie);
+            }
+            finally
+            {
+                rwLock.ExitWriteLock();
+            }
+
+            _saveLibraryRunner.Subscribe();
+        }
+
+        public static List<Cookie> GetAll()
+        {
+            Load();
+
+            return Cookies;
+        }
+
+        /// <summary>
+        /// Deletes all cookies from the Jar.
+        /// </summary>
+        public static void Clear()
+        {
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Clear)}()");
+
+            Load();
+
+            rwLock.EnterWriteLock();
+            try
+            {
+                Cookies.Clear();
+            }
+            finally
+            {
+                rwLock.ExitWriteLock();
+            }
+
+            Persist();
+        }
+
+        /// <summary>
+        /// Removes cookies that older than the given parameter.
+        /// </summary>
+        public static void Clear(TimeSpan olderThan)
+        {
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Clear)}({olderThan})");
+
+            Load();
+
+            rwLock.EnterWriteLock();
+            try
+            {
+                for (int i = 0; i < Cookies.Count;)
+                {
+                    var cookie = Cookies[i];
+
+                    // Remove expired or not used cookies
+                    if (!cookie.WillExpireInTheFuture() || (cookie.Date + olderThan) < DateTime.UtcNow)
+                        Cookies.RemoveAt(i);
+                    else
+                        i++;
+                }
+            }
+            finally
+            {
+                rwLock.ExitWriteLock();
+            }
+
+            Persist();
+        }
+
+        /// <summary>
+        /// Removes cookies that matches to the given domain.
+        /// </summary>
+        public static void Clear(string domain)
+        {
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Clear)}({domain})");
+
+            Load();
+
+            rwLock.EnterWriteLock();
+            try
+            {
+                for (int i = 0; i < Cookies.Count;)
+                {
+                    var cookie = Cookies[i];
+
+                    // Remove expired or not used cookies
+                    if (!cookie.WillExpireInTheFuture() || cookie.Domain.IndexOf(domain) != -1)
+                        Cookies.RemoveAt(i);
+                    else
+                        i++;
+                }
+            }
+            finally
+            {
+                rwLock.ExitWriteLock();
+            }
+
+            Persist();
+        }
+
+        public static void Remove(Uri uri, string name)
+        {
+            if (HTTPManager.Logger.IsDiagnostic)
+                HTTPManager.Logger.Verbose(nameof(CookieJar), $"{nameof(Remove)}({uri}, {name})");
+
+            Load();
+
+            rwLock.EnterWriteLock();
+            try
+            {
+                for (int i = 0; i < Cookies.Count;)
+                {
+                    var cookie = Cookies[i];
+
+                    if (cookie.Name.Equals(name, StringComparison.OrdinalIgnoreCase) && uri.Host.IndexOf(cookie.Domain) != -1)
+                        Cookies.RemoveAt(i);
+                    else
+                        i++;
+                }
+            }
+            finally
+            {
+                rwLock.ExitWriteLock();
+            }
+
+            _saveLibraryRunner.Subscribe();
+        }
+
+        #endregion
+
+        #region Private Helper Functions
+
+        /// <summary>
+        /// Find and return a Cookie and his index in the list.
+        /// </summary>
+        private static Cookie Find(Cookie cookie, out int idx)
+        {
+            for (int i = 0; i < Cookies.Count; ++i)
+            {
+                Cookie c = Cookies[i];
+
+                if (c.Equals(cookie))
+                {
+                    idx = i;
+                    return c;
+                }
+            }
+
+            idx = -1;
+            return null;
+        }
+
+        #endregion
+    }
+}

Packages/com.tivadar.best.http/Runtime/HTTP/Cookies/CookieJar.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0788a5d8bbeea264a815fa46ec0012cc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: