public static void TryRethrow(OAuthParameters parameters)
        {
            if (!parameters.HasProblem) {
                OAuthRequestException ex = new OAuthRequestException(parameters.ProblemAdvice, parameters.ProblemType);

                // Load additional parameter for specific types
                switch (parameters.ProblemType) {
                    case OAuthProblemTypes.VersionRejected:
                        if (!String.IsNullOrEmpty(parameters.AcceptableVersions))
                            ex.AddParameter(OAuthErrorParameterKeys.AcceptableVersions, parameters.AcceptableVersions);
                        break;
                    case OAuthProblemTypes.ParameterAbsent:
                        if (!String.IsNullOrEmpty(parameters.ParametersAbsent))
                            ex.AddParameter(OAuthErrorParameterKeys.ParametersAbsent, parameters.ParametersAbsent);
                        break;
                    case OAuthProblemTypes.ParameterRejected:
                        if (!String.IsNullOrEmpty(parameters.ParametersRejected))
                            ex.AddParameter(OAuthErrorParameterKeys.ParametersRejected, parameters.ParametersRejected);
                        break;
                    case OAuthProblemTypes.TimestampRefused:
                        if (!String.IsNullOrEmpty(parameters.AcceptableTimestamps))
                            ex.AddParameter(OAuthErrorParameterKeys.AcceptableTimestamps, parameters.AcceptableTimestamps);
                        break;
                }

                // Throw the OAuthRequestException
                throw ex;
            }
        }
Beispiel #2
0
        private void DoGetRequestToken()
        {
            // Fire the OnBeforeGetRequestToken event
            PreRequestEventArgs args = new PreRequestEventArgs(Service.RequestTokenUrl, Service.RequestTokenEndPoint.HttpMethod, CallbackUrl);

            if (BeforeGetRequestToken != null)
            {
                BeforeGetRequestToken(this, args);
            }

            OAuthParameters authParams = CreateOAuthParameters(args.AdditionalParameters);

            authParams.Callback = args.CallbackUrl == null ? OAuthOutOfBandCallback : args.CallbackUrl.AbsoluteUri;

            SignParameters(args.RequestUri, args.HttpMethod, authParams, null);

            // Create and sign the request
            HttpWebRequest request = CreateRequest(
                args.RequestUri,
                authParams,
                args.HttpMethod,
                args.HttpMethod == "POST" ? HttpPostUrlEncodedContentType : String.Empty,
                null);

            OAuthParameters responseParameters;

            // Get the service provider response
            try {
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();

                // Parse the parameters and re-throw any OAuthRequestException from the service provider
                responseParameters = OAuthParameters.Parse(response);
                OAuthRequestException.TryRethrow(responseParameters);
            } catch (WebException e) {
                // Parse the parameters and re-throw any OAuthRequestException from the service provider
                responseParameters = OAuthParameters.Parse(e.Response as HttpWebResponse);
                OAuthRequestException.TryRethrow(responseParameters);

                // If no OAuthRequestException, rethrow the WebException
                throw;
            }

            // Store the request token
            RequestToken = new OAuthToken(TokenType.Request, responseParameters.Token, responseParameters.TokenSecret, Service.Consumer);

            // Fire the OnReceiveRequestToken event
            RequestTokenReceivedEventArgs responseArgs = new RequestTokenReceivedEventArgs(RequestToken);

            responseArgs.Parameters.Add(responseParameters.AdditionalParameters);

            if (ReceiveRequestToken != null)
            {
                ReceiveRequestToken(this, responseArgs);
            }
        }
        public static void TryRethrow(OAuthParameters parameters)
        {
            if (!parameters.HasProblem)
            {
                OAuthRequestException ex = new OAuthRequestException(parameters.ProblemAdvice, parameters.ProblemType);

                // Load additional parameter for specific types
                switch (parameters.ProblemType)
                {
                case OAuthProblemTypes.VersionRejected:
                    if (!String.IsNullOrEmpty(parameters.AcceptableVersions))
                    {
                        ex.AddParameter(OAuthErrorParameterKeys.AcceptableVersions, parameters.AcceptableVersions);
                    }
                    break;

                case OAuthProblemTypes.ParameterAbsent:
                    if (!String.IsNullOrEmpty(parameters.ParametersAbsent))
                    {
                        ex.AddParameter(OAuthErrorParameterKeys.ParametersAbsent, parameters.ParametersAbsent);
                    }
                    break;

                case OAuthProblemTypes.ParameterRejected:
                    if (!String.IsNullOrEmpty(parameters.ParametersRejected))
                    {
                        ex.AddParameter(OAuthErrorParameterKeys.ParametersRejected, parameters.ParametersRejected);
                    }
                    break;

                case OAuthProblemTypes.TimestampRefused:
                    if (!String.IsNullOrEmpty(parameters.AcceptableTimestamps))
                    {
                        ex.AddParameter(OAuthErrorParameterKeys.AcceptableTimestamps, parameters.AcceptableTimestamps);
                    }
                    break;
                }

                // Throw the OAuthRequestException
                throw ex;
            }
        }
Beispiel #4
0
        private OAuthResponse GetResource(NameValueCollection parameters, string contentType, Stream bodyStream)
        {
            OAuthResponse response;

            HttpWebRequest request = PrepareProtectedResourceRequest(parameters, contentType, bodyStream);

            // A null value for the HttpWebRequest is returned when a ResponseToken is returned
            // and no one has returned in the AuthorizationHandler continue with getting an AccessToken
            // or an RequestToken exists but the AccessToken request was refused.
            if (request == null)
            {
                response = new OAuthResponse(RequestToken);
            }
            else
            {
                OAuthParameters responseParameters;

                try {
                    OAuthResource resource = new OAuthResource((HttpWebResponse)request.GetResponse());

                    // Parse the parameters and re-throw any OAuthRequestException from the service provider
                    responseParameters = OAuthParameters.Parse(resource);
                    OAuthRequestException.TryRethrow(responseParameters);

                    // If nothing is thrown then we should have a valid resource.
                    response = new OAuthResponse(AccessToken ?? RequestToken, resource);
                } catch (WebException e) {
                    // Parse the parameters and re-throw any OAuthRequestException from the service provider
                    responseParameters = OAuthParameters.Parse(e.Response as HttpWebResponse);
                    OAuthRequestException.TryRethrow(responseParameters);

                    // If no OAuthRequestException, rethrow the WebException
#warning TODO: We have consumer the WebException's body so rethrowing it is pretty pointless; wrap the WebException in an OAuthProtocolException and store the body (create an OAuthResource before parsing parameters)
                    throw;
                }
            }

            return(response);
        }
 public void RemoveError(OAuthRequestException error)
 {
     errors.Remove(error);
 }
 public void AddError(OAuthRequestException error)
 {
     errors.Add(error);
 }
 public void RemoveError(OAuthRequestException error)
 {
     errors.Remove(error);
 }
 public void AddError(OAuthRequestException error)
 {
     errors.Add(error);
 }
Beispiel #9
0
        private bool DoGetAccessToken()
        {
            // Fire the OnBeforeGetAccessToken event
            PreAccessTokenRequestEventArgs preArgs = new PreAccessTokenRequestEventArgs(Service.AccessTokenUrl,
                                                                                        Service.AccessTokenEndPoint.HttpMethod,
                                                                                        RequestToken, RequestTokenVerifier);

            if (BeforeGetAccessToken != null)
            {
                BeforeGetAccessToken(this, preArgs);
            }

            // Create and sign the request
            OAuthParameters authParams = CreateOAuthParameters(null);

            authParams.Verifier = preArgs.Verifier;

            // We don't have a verifier so something has gone wrong in the process.
            if (string.IsNullOrEmpty(authParams.Verifier))
            {
                return(false);
            }

            SignParameters(preArgs.RequestUri, preArgs.HttpMethod, authParams, RequestToken);

            HttpWebRequest request = CreateRequest(preArgs.RequestUri, authParams, preArgs.HttpMethod,
                                                   preArgs.HttpMethod == "POST" ? HttpPostUrlEncodedContentType : String.Empty,
                                                   null);

            OAuthParameters responseParameters;

            // Get the service provider response
            try {
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();

                // Parse the parameters and re-throw any OAuthRequestException from the service provider
                responseParameters = OAuthParameters.Parse(response);
                OAuthRequestException.TryRethrow(responseParameters);
            } catch (WebException e) {
                // Parse the parameters and re-throw any OAuthRequestException from the service provider
                responseParameters = OAuthParameters.Parse(e.Response as HttpWebResponse);
                OAuthRequestException.TryRethrow(responseParameters);

                // If no OAuthRequestException, rethrow the WebException
                throw;
            }

            // Store the access token
            AccessToken = new OAuthToken(TokenType.Access, responseParameters.Token, responseParameters.TokenSecret, Service.Consumer);

            // Fire the OnReceiveAccessToken event
            AccessTokenReceivedEventArgs responseArgs = new AccessTokenReceivedEventArgs(RequestToken, AccessToken);

            responseArgs.AdditionalParameters.Add(responseParameters.AdditionalParameters);

            if (ReceiveAccessToken != null)
            {
                ReceiveAccessToken(this, responseArgs);
            }

            return(true);
        }