Example #1
0
        void ThreadFunc(object param)
        {
            bool alreadyReconnected = false;
            bool redirected         = false;

            RetryCauses cause = RetryCauses.None;

#if LOCK_ON_FILE
            object uriLock = null;
#endif

#if UNITY_WEBPLAYER
            // Right now, no caching supported in the webplayer
            if (!CurrentRequest.DisableCache)
            {
                CurrentRequest.DisableCache = true;
            }
#endif

            try
            {
                if (!HasProxy && CurrentRequest.HasProxy)
                {
                    Proxy = CurrentRequest.Proxy;
                }

                // Lock only if we will use the cached entity.
#if LOCK_ON_FILE
                if (!CurrentRequest.DisableCache)
                {
                    Monitor.Enter(uriLock = HTTPCacheFileLock.Acquire(CurrentRequest.CurrentUri));
                }
#endif

                // Try load the full response from an already saved cache entity. If the response
                if (TryLoadAllFromCache())
                {
                    return;
                }

                if (Client != null && !Client.IsConnected())
                {
                    Close();
                }

                do // of while (reconnect)
                {
                    if (cause == RetryCauses.Reconnect)
                    {
                        Close();
#if NETFX_CORE
                        await Task.Delay(100);
#else
                        Thread.Sleep(100);
#endif
                    }

                    LastProcessedUri = CurrentRequest.CurrentUri;

                    cause = RetryCauses.None;

                    // Connect to the server
                    Connect();

                    if (State == HTTPConnectionStates.AbortRequested)
                    {
                        throw new Exception("AbortRequested");
                    }

                    // Setup cache control headers before we send out the request
                    if (!CurrentRequest.DisableCache)
                    {
                        HTTPCacheService.SetHeaders(CurrentRequest);
                    }

                    // Write the request to the stream
                    // sentRequest will be true if the request sent out successfully(no SocketException), so we can try read the response
                    bool sentRequest = CurrentRequest.SendOutTo(Stream);

                    // sentRequest only true if there are no exceptions during CurrentRequest.SendOutTo.
                    if (!sentRequest)
                    {
                        Close();

                        if (State == HTTPConnectionStates.TimedOut)
                        {
                            throw new Exception("AbortRequested");
                        }

                        // We will try again only once
                        if (!alreadyReconnected)
                        {
                            alreadyReconnected = true;
                            cause = RetryCauses.Reconnect;
                        }
                    }

                    // If sending out the request succeded, we will try read the response.
                    if (sentRequest)
                    {
                        bool received = Receive();

                        if (State == HTTPConnectionStates.TimedOut)
                        {
                            throw new Exception("AbortRequested");
                        }

                        if (!received && !alreadyReconnected)
                        {
                            alreadyReconnected = true;
                            cause = RetryCauses.Reconnect;
                        }

                        if (CurrentRequest.Response != null)
                        {
                            switch (CurrentRequest.Response.StatusCode)
                            {
                            // Not authorized
                            // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2
                            case 401:
                            {
                                string authHeader = CurrentRequest.Response.GetFirstHeaderValue("www-authenticate");
                                if (!string.IsNullOrEmpty(authHeader))
                                {
                                    var digest = DigestStore.GetOrCreate(CurrentRequest.CurrentUri);
                                    digest.ParseChallange(authHeader);

                                    if (CurrentRequest.Credentials != null && digest.IsUriProtected(CurrentRequest.CurrentUri) && (!CurrentRequest.HasHeader("Authorization") || digest.Stale))
                                    {
                                        cause = RetryCauses.Authenticate;
                                    }
                                }

                                goto default;
                            }

                            // Proxy authentication required
                            // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.8
                            case 407:
                            {
                                if (CurrentRequest.HasProxy)
                                {
                                    string authHeader = CurrentRequest.Response.GetFirstHeaderValue("proxy-authenticate");
                                    if (!string.IsNullOrEmpty(authHeader))
                                    {
                                        var digest = DigestStore.GetOrCreate(CurrentRequest.Proxy.Address);
                                        digest.ParseChallange(authHeader);

                                        if (CurrentRequest.Proxy.Credentials != null && digest.IsUriProtected(CurrentRequest.Proxy.Address) && (!CurrentRequest.HasHeader("Proxy-Authorization") || digest.Stale))
                                        {
                                            cause = RetryCauses.ProxyAuthenticate;
                                        }
                                    }
                                }

                                goto default;
                            }

                            // Redirected
                            case 301:     // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.2
                            case 302:     // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.3
                            case 307:     // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.8
                            case 308:     // http://tools.ietf.org/html/rfc7238
                            {
                                if (CurrentRequest.RedirectCount >= CurrentRequest.MaxRedirects)
                                {
                                    goto default;
                                }
                                CurrentRequest.RedirectCount++;

                                string location = CurrentRequest.Response.GetFirstHeaderValue("location");
                                if (!string.IsNullOrEmpty(location))
                                {
                                    Uri redirectUri = GetRedirectUri(location);

                                    // Let the user to take some control over the redirection
                                    if (!CurrentRequest.CallOnBeforeRedirection(redirectUri))
                                    {
                                        HTTPManager.Logger.Information("HTTPConnection", "OnBeforeRedirection returned False");
                                        goto default;
                                    }

                                    // Remove the previously set Host header.
                                    CurrentRequest.RemoveHeader("Host");

                                    // Set the Referer header to the last Uri.
                                    CurrentRequest.SetHeader("Referer", CurrentRequest.CurrentUri.ToString());

                                    // Set the new Uri, the CurrentUri will return this while the IsRedirected property is true
                                    CurrentRequest.RedirectUri = redirectUri;

                                    // Discard the redirect response, we don't need it any more
                                    CurrentRequest.Response = null;

                                    redirected = CurrentRequest.IsRedirected = true;
                                }
                                else
                                            #if !NETFX_CORE
                                { throw new MissingFieldException(string.Format("Got redirect status({0}) without 'location' header!", CurrentRequest.Response.StatusCode.ToString())); }
                                            #else
                                { throw new Exception(string.Format("Got redirect status({0}) without 'location' header!", CurrentRequest.Response.StatusCode.ToString())); }
                                            #endif

                                goto default;
                            }

                            default:
                                if (CurrentRequest.IsCookiesEnabled)
                                {
                                    CookieJar.Set(CurrentRequest.Response);
                                }

                                TryStoreInCache();
                                break;
                            }

                            // If we have a response and the server telling us that it closed the connection after the message sent to us, then
                            //  we will colse the connection too.
                            if (CurrentRequest.Response == null ||
                                CurrentRequest.Response.HasHeaderWithValue("connection", "close") ||
                                CurrentRequest.UseAlternateSSL)
                            {
                                Close();
                            }
                        }
                    }
                } while (cause != RetryCauses.None);
            }
            catch (TimeoutException e)
            {
                CurrentRequest.Response  = null;
                CurrentRequest.Exception = e;
                CurrentRequest.State     = HTTPRequestStates.ConnectionTimedOut;

                Close();
            }
            catch (Exception e)
            {
                if (CurrentRequest.UseStreaming)
                {
                    HTTPCacheService.DeleteEntity(CurrentRequest.CurrentUri);
                }

                // Something gone bad, Response must be null!
                CurrentRequest.Response = null;

                switch (State)
                {
                case HTTPConnectionStates.AbortRequested:
                    CurrentRequest.State = HTTPRequestStates.Aborted;
                    break;

                case HTTPConnectionStates.TimedOut:
                    CurrentRequest.State = HTTPRequestStates.TimedOut;
                    break;

                default:
                    CurrentRequest.Exception = e;
                    CurrentRequest.State     = HTTPRequestStates.Error;
                    break;
                }

                Close();
            }
            finally
            {
#if LOCK_ON_FILE
                if (!CurrentRequest.DisableCache && uriLock != null)
                {
                    Monitor.Exit(uriLock);
                }
#endif

                // Avoid state changes. While we are in this block changing the connection's State, on Unity's main thread
                //  the HTTPManager's OnUpdate will check the connections's State and call functions that can change the inner state of
                //  the object. (Like setting the CurrentRequest to null in function Recycle() causing a NullRef exception)
                lock (HTTPManager.Locker)
                {
                    if (CurrentRequest != null && CurrentRequest.Response != null && CurrentRequest.Response.IsUpgraded)
                    {
                        State = HTTPConnectionStates.Upgraded;
                    }
                    else
                    {
                        State = redirected ? HTTPConnectionStates.Redirected : (Client == null ? HTTPConnectionStates.Closed : HTTPConnectionStates.WaitForRecycle);
                    }

                    // Change the request's state only when the whole processing finished
                    if (CurrentRequest.State == HTTPRequestStates.Processing && (State == HTTPConnectionStates.Closed || State == HTTPConnectionStates.WaitForRecycle))
                    {
                        CurrentRequest.State = HTTPRequestStates.Finished;
                    }

                    if (CurrentRequest.State == HTTPRequestStates.ConnectionTimedOut)
                    {
                        State = HTTPConnectionStates.Closed;
                    }

                    LastProcessTime = DateTime.UtcNow;
                }

                HTTPCacheService.SaveLibrary();
                CookieJar.Persist();
            }
        }
        private void ThreadFunc(object param)
        {
            bool        flag        = false;
            bool        flag2       = false;
            RetryCauses retryCauses = RetryCauses.None;
            object      obj         = null;

            try
            {
                if (!CurrentRequest.DisableCache)
                {
                    Monitor.Enter(obj = HTTPCacheFileLock.Acquire(CurrentRequest.CurrentUri));
                }
                CurrentRequest.Processing = true;
                if (!TryLoadAllFromCache())
                {
                    if (Client != null && !Client.IsConnected())
                    {
                        Close();
                    }
                    do
                    {
                        if (retryCauses == RetryCauses.Reconnect)
                        {
                            Close();
                            Thread.Sleep(100);
                        }
                        retryCauses = RetryCauses.None;
                        Connect();
                        if (!CurrentRequest.DisableCache)
                        {
                            HTTPCacheService.SetHeaders(CurrentRequest);
                        }
                        bool flag3 = CurrentRequest.SendOutTo(Stream);
                        if (!flag3)
                        {
                            Close();
                            if (!flag)
                            {
                                flag        = true;
                                retryCauses = RetryCauses.Reconnect;
                            }
                        }
                        if (flag3)
                        {
                            if (!Receive() && !flag)
                            {
                                flag        = true;
                                retryCauses = RetryCauses.Reconnect;
                            }
                            if (CurrentRequest.Response != null)
                            {
                                switch (CurrentRequest.Response.StatusCode)
                                {
                                case 401:
                                {
                                    string firstHeaderValue2 = CurrentRequest.Response.GetFirstHeaderValue("www-authenticate");
                                    if (!string.IsNullOrEmpty(firstHeaderValue2))
                                    {
                                        Digest orCreate = DigestStore.GetOrCreate(CurrentRequest.CurrentUri);
                                        orCreate.ParseChallange(firstHeaderValue2);
                                        if (CurrentRequest.Credentials != null && orCreate.IsUriProtected(CurrentRequest.CurrentUri) && (!CurrentRequest.HasHeader("Authorization") || orCreate.Stale))
                                        {
                                            retryCauses = RetryCauses.Authenticate;
                                        }
                                    }
                                    break;
                                }

                                case 301:
                                case 302:
                                case 307:
                                    if (CurrentRequest.RedirectCount < CurrentRequest.MaxRedirects)
                                    {
                                        CurrentRequest.RedirectCount++;
                                        string firstHeaderValue = CurrentRequest.Response.GetFirstHeaderValue("location");
                                        if (string.IsNullOrEmpty(firstHeaderValue))
                                        {
                                            throw new MissingFieldException($"Got redirect status({CurrentRequest.Response.StatusCode.ToString()}) without 'location' header!");
                                        }
                                        CurrentRequest.RedirectUri = GetRedirectUri(firstHeaderValue);
                                        CurrentRequest.Response    = null;
                                        bool flag4 = true;
                                        CurrentRequest.IsRedirected = flag4;
                                        flag2 = flag4;
                                    }
                                    break;
                                }
                                TryStoreInCache();
                                if (CurrentRequest.Response.HasHeaderWithValue("connection", "close") || CurrentRequest.UseAlternateSSL)
                                {
                                    Close();
                                }
                            }
                        }
                    }while (retryCauses != 0);
                }
            }
            catch (Exception exception)
            {
                if (CurrentRequest.UseStreaming)
                {
                    HTTPCacheService.DeleteEntity(CurrentRequest.CurrentUri);
                }
                CurrentRequest.Response  = null;
                CurrentRequest.Exception = exception;
                Close();
            }
            finally
            {
                if (!CurrentRequest.DisableCache && obj != null)
                {
                    Monitor.Exit(obj);
                }
                HTTPCacheService.SaveLibrary();
                CurrentRequest.Processing = false;
                if (CurrentRequest != null && CurrentRequest.Response != null && CurrentRequest.Response.IsUpgraded)
                {
                    State = HTTPConnectionStates.Upgraded;
                }
                else
                {
                    State = (flag2 ? HTTPConnectionStates.Redirected : ((Client != null) ? HTTPConnectionStates.WaitForRecycle : HTTPConnectionStates.Closed));
                }
                LastProcessTime = DateTime.UtcNow;
            }
        }