public HttpMessageEncodingRequestContext(RequestContext innerContext)
 {
     Debug.Assert(innerContext != null, "The 'innerContext' parameter should not be null.");
     this.innerContext = innerContext;
     this.isRequestConfigured = false;
     this.requestConfigurationLock = new object();
 }

 public override void ProcessRequest(ref RequestContext requestContext)
 {
     if (!manager.AuthenticateRequest(requestContext.RequestMessage)) {
         requestContext.Reply(manager.CreateInvalidAuthenticationRequest());
         requestContext = null;
     }
 }

		public SecurityRequestContext (SecurityReplyChannel channel, RequestContext source)
		{
			this.source = source;
			this.channel = channel;

			security = channel.Source.SecuritySupport;
		}

		public bool IsValidUserKey(RequestContext requestContext)
		{
			if (requestContext != null && requestContext.RequestMessage != null)
			{
				var prop = (HttpRequestMessageProperty)requestContext.RequestMessage.Properties[HttpRequestMessageProperty.Name];
				var cookie = prop.Headers[HttpRequestHeader.Cookie];
				if (string.IsNullOrEmpty(cookie)) return false;

				var coockieName = CookiesManager.GetCookiesName();
				foreach (string s in cookie.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
				{
					if (s.IndexOf('=') == -1) continue;

					var key = s.Substring(0, s.IndexOf('=')).Trim();
					if (key.Equals(coockieName, StringComparison.Ordinal))
					{
						try
						{
							var value = s.Substring(s.IndexOf('=') + 1).Trim();
							if (SecurityContext.IsAuthenticated || SecurityContext.AuthenticateMe(value))
							{
								return true;
							}
						}
						catch { }
						break;
					}
				}
			}
			return false;
		}

		public override void ProcessRequest(ref RequestContext requestContext)
		{
			if (!IsValidUserKey(requestContext))
			{
				GenerateErrorResponse(ref requestContext, HttpStatusCode.Unauthorized, "Unauthorized");
			}
		}

		public MessageProcessingContext (OperationContext opCtx)
		{
			operation_context = opCtx;
			request_context = opCtx.RequestContext;
			incoming_message = opCtx.IncomingMessage;
			user_events_handler = new UserEventsHandler (this);
		}

    public override void ProcessRequest(ref RequestContext requestContext)
    {
      if (requestContext == null || requestContext.RequestMessage == null)
      {
        return;
      }

      Message request = requestContext.RequestMessage;

      var requestProperty = (HttpRequestMessageProperty) request.Properties[HttpRequestMessageProperty.Name];

      IOAuthContext context = new OAuthContextBuilder().FromUri(requestProperty.Method, request.Headers.To);

      try
      {
        _provider.AccessProtectedResourceRequest(context);

        AccessToken accessToken = _repository.GetToken(context.Token);

        TokenPrincipal principal = CreatePrincipalFromToken(accessToken);

        InitializeSecurityContext(request, principal);
      }
      catch (OAuthException authEx)
      {
        XElement response = GetHtmlFormattedErrorReport(authEx);
        Message reply = Message.CreateMessage(MessageVersion.None, null, response);
        var responseProperty = new HttpResponseMessageProperty {StatusCode = HttpStatusCode.Forbidden, StatusDescription = authEx.Report.ToString()};
        responseProperty.Headers[HttpResponseHeader.ContentType] = "text/html";
        reply.Properties[HttpResponseMessageProperty.Name] = responseProperty;
        requestContext.Reply(reply);

        requestContext = null;
      }
    }

 public override void ProcessRequest(ref RequestContext requestContext)
 {
     if (requestContext == null || !authenticationManager.AuthenticateRequest(requestContext.RequestMessage))
      {
     requestContext = CreateAndSendInvalidAuthenticationRequest(requestContext);
      }
 }

 public void NotifyInvokeReceived(RequestContext request)
 {
     using (ServiceModelActivity.BoundOperation(this.activity))
     {
         ChannelHandler.Register(this.handler, request);
     }
     this.DidInvokerEnsurePump = true;
 }

		public MessageProcessingContext (OperationContext opCtx, IChannel replyOrInput)
		{
			operation_context = opCtx;
			request_context = opCtx.RequestContext;
			incoming_message = opCtx.IncomingMessage;
			user_events_handler = new UserEventsHandler (this);
			reply_or_input = replyOrInput;
		}

 private RequestContext CreateAndSendInvalidAuthenticationRequest(RequestContext requestContext)
 {
     using (Message responseMessage = authenticationManager.CreateInvalidAuthenticationRequest(requestContext.RequestMessage))
      {
     requestContext.Reply(responseMessage);
     requestContext = null;
     return requestContext;
      }
 }

 public HttpCookieSessionRequestContext(
     RequestContext innerRequestContext, 
     string sessionId, 
     bool isInitial)
 {
     this.sessionId = sessionId;
     this.innerRequestContext = innerRequestContext;
     this.isInitial = isInitial;
 }

        public bool EndTryReceiveRequest(IAsyncResult result, out RequestContext context)
        {
            _innerChannel.EndTryReceiveRequest(result, out context);

            var timeout = ((IDefaultCommunicationTimeouts)this.Manager).ReceiveTimeout;

            context = ProcessContext(context, timeout);

            return context != null;
        }

 public SelfHostHttpRequestContext(RequestContext requestContext, HttpConfiguration configuration,
     HttpRequestMessage request)
 {
     Contract.Assert(requestContext != null);
     Contract.Assert(configuration != null);
     Contract.Assert(request != null);
     _requestContext = requestContext;
     _configuration = configuration;
     _request = request;
 }

        public bool EndTryReceiveRequest(IAsyncResult result, out RequestContext context)
        {
            Task<RequestContext> task = (Task<RequestContext>) result;

            task.Wait();

            context = task.Result;

            return context != null;
        }

 public bool EndTryReceive(IAsyncResult result, out RequestContext requestContext)
 {
     Message message;
     if (this.channel.EndTryReceive(result, out message))
     {
         requestContext = this.WrapMessage(message);
         return true;
     }
     requestContext = null;
     return false;
 }

        public AzureServiceBusHttpRequest(RequestContext context)
        {
            _context = context;
            _request = _context.RequestMessage;
            _requestProperties = _context.RequestMessage.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            _serverVariables = new NameValueCollection();

            Uri via = _request.Properties.Via;
            _serverVariables.Add("SERVER_NAME", via.Host);
            _serverVariables.Add("SERVER_PORT", via.Port.ToString());
            _serverVariables.Add("SERVER_PROTOCOL", via.Scheme);
        }

 public bool EndTryReceive(IAsyncResult result, out RequestContext requestContext)
 {
     RequestContextWrapper wrapper;
     bool flag = this.inputQueue.EndDequeue(result, out wrapper);
     if (flag && (wrapper != null))
     {
         requestContext = wrapper.RequestContext;
         return flag;
     }
     requestContext = null;
     return flag;
 }

        public static void Unauthorized(ref RequestContext context, string nonauthorizedHeaderValue)
        {
            var reply = Message.CreateMessage(MessageVersion.None, null);
            var responseProperty = new HttpResponseMessageProperty() { StatusCode = HttpStatusCode.Unauthorized };

            responseProperty.Headers.Add(HttpResponseHeader.WwwAuthenticate,
                                         nonauthorizedHeaderValue);

            reply.Properties[HttpResponseMessageProperty.Name] = responseProperty;
            context.Reply(reply);
            context = null;
        }

        public bool EndTryReceiveRequest(IAsyncResult result, out RequestContext context)
        {
            bool requestAvailable =
                innerReplyChannel.EndTryReceiveRequest(result, out context);

            if (requestAvailable)
            {
                // Read the context id from the incoming message.
                ReadContextId(context.RequestMessage);
            }

            return requestAvailable;
        }