public NetHttpServiceRespone(OutgoingWebResponseContext response, out Stream stream) { stream = new MemoryStream(); this.stream = stream; this.writer = new StreamWriter(stream); this.response = response; }
private static void SetNancyResponseToOutgoingWebResponse(OutgoingWebResponseContext webResponse, Response nancyResponse) { SetHttpResponseHeaders(webResponse, nancyResponse); webResponse.ContentType = nancyResponse.ContentType; webResponse.StatusCode = nancyResponse.StatusCode; }
public static void CheckModifiedSince(IncomingWebRequestContext incomingRequest, OutgoingWebResponseContext outgoingResponse, DateTime serverModifiedDate) { DateTime modifiedSince = Convert.ToDateTime(incomingRequest.Headers[HttpRequestHeader.LastModified]); if (modifiedSince != serverModifiedDate) return; outgoingResponse.SuppressEntityBody = true; outgoingResponse.StatusCode = HttpStatusCode.NotModified; }
public OutgoingWebResponseContextWrapper(OutgoingWebResponseContext outgoingResponse) { if (outgoingResponse == null) { throw new ArgumentNullException("outgoingResponse"); } this.outgoingResponse = outgoingResponse; }
public static void CheckETag(IncomingWebRequestContext incomingRequest, OutgoingWebResponseContext outgoingResponse, Guid ServerETag) { string test = incomingRequest.Headers[HttpRequestHeader.IfNoneMatch]; if (test == null) return; Guid? eTag = new Guid(test); if (eTag != ServerETag) return; outgoingResponse.SuppressEntityBody = true; outgoingResponse.StatusCode = HttpStatusCode.NotModified; }
private static void SetHeader(OutgoingWebResponseContext response, string headerName, string headerValue) { if (string.IsNullOrWhiteSpace(response.Headers.Get(headerName))) { response.Headers.Add(headerName, headerValue); } else { response.Headers.Set(headerName, headerValue); } }
private static void SetHttpResponseHeaders(OutgoingWebResponseContext context, Response response) { foreach (var kvp in response.Headers) { context.Headers.Add(kvp.Key, kvp.Value); } foreach (var cookie in response.Cookies) { context.Headers.Add("Set-Cookie", cookie.ToString()); } }
public IIdentity Authenticate( IncomingWebRequestContext request, OutgoingWebResponseContext response, object[] parameters, UserNamePasswordValidator validator, bool secure, bool requiresTransportLayerSecurity, string source) { if (requiresTransportLayerSecurity && !secure) throw new BasicRequiresTransportSecurityException(); var authentication = new BasicAuthentication(request.Headers); if (!authentication.Authenticate(validator)) throw new BasicUnauthorizedException(source); return new GenericIdentity(authentication.Username, "WebBasicAuthenticationHandler"); }
/// <summary> /// Authenticates the specified request. /// </summary> /// <param name="request">The request.</param> /// <param name="response">The response.</param> /// <param name="parameters">The parameters.</param> /// <param name="secure">if set to <c>true</c> [secure].</param> /// <param name="requiresTransportLayerSecurity">if set to <c>true</c> [requires transport layer security].</param> /// <param name="scope">The scope.</param> /// <returns></returns> public IIdentity Authenticate(IncomingWebRequestContext request, OutgoingWebResponseContext response, object[] parameters, bool secure, bool requiresTransportLayerSecurity, string scope, bool allowAnonymous) { var clientProvider = new ClientProvider(); var passwordProvider = new PasswordProvider(); var tokenProvider = new TokenProvider(); var scopes = new List<string>(); var oAuthProvider = OAuthFactory.BuildOAuthProvider(clientProvider, tokenProvider, scopes, passwordProvider: passwordProvider); var token = request.Headers["Authorization"]; if (string.IsNullOrWhiteSpace(token)) { token = HttpContext.Current.Request.QueryString["access_token"]; } else { if (!string.IsNullOrWhiteSpace(token) && token.StartsWith("OAuth") && token.Contains(" ")) { var splitToken = token.Split(' '); if (splitToken.Length > 1) { token = splitToken[1]; } } } var authentication = oAuthProvider.VerifyToken(token, scope); if (authentication.ErrorCode != ErrorCode.None) { if (allowAnonymous) { return null; } var errorCode = authentication.StatusCode(); var oauthError = authentication.Error(); if (errorCode == HttpStatusCode.Unauthorized) { response.Headers.Add(HttpResponseHeader.WwwAuthenticate, string.Format("OAuth realm='PollMe Service', error='{0}'", oauthError)); } throw new WebFaultException<string>(oauthError, authentication.StatusCode()); } return new GenericIdentity("Authorized User", "OAuth2"); }
public IIdentity Authenticate( IncomingWebRequestContext request, OutgoingWebResponseContext response, object[] parameters, Type validatorType, bool secure, bool requiresTransportLayerSecurity, string source) { if (requiresTransportLayerSecurity && !secure) throw new BasicRequiresTransportSecurityException(); var authentication = new BasicAuthentication(request.Headers); var validator = validatorType != null ? DependencyResolver.Current.GetOperationService<UserNamePasswordValidator>(OperationContainer.GetCurrent(), validatorType) : DependencyResolver.Current.GetOperationService<UserNamePasswordValidator>(OperationContainer.GetCurrent()).ThrowIfNull(); if (!authentication.Authenticate(validator)) throw new BasicUnauthorizedException(source); return new GenericIdentity(authentication.Username, "WebBasicAuthenticationHandler"); }
private IAsyncResult DispatchToHttpServer( IncomingWebRequestContext incomingRequest, Stream body, OutgoingWebResponseContext outgoingResponse, bool bufferBody, AsyncCallback callback, object state) { var request = MakeHttpRequestMessageFrom(incomingRequest, body, bufferBody); var tcs = new TaskCompletionSource<Stream>(state); _server.SubmitRequestAsync(request, new CancellationToken()) .ContinueWith(t => { var response = t.Result; CopyHttpResponseMessageToOutgoingResponse(response, outgoingResponse); Action<Task<Stream>> complete = (t2) => { if (t2.IsFaulted) tcs.TrySetException( t2.Exception.InnerExceptions); else if (t2.IsCanceled) tcs.TrySetCanceled(); else tcs.TrySetResult(t2.Result); if (callback != null) callback(tcs.Task); }; if (response.Content == null) { tcs.TrySetResult(null); if (callback != null) callback(tcs.Task); } else { response.Content.ReadAsStreamAsync() .ContinueWith(complete); } }); return tcs.Task; }
private static void SetNancyResponseToOutgoingWebResponse(OutgoingWebResponseContext webResponse, Response nancyResponse) { SetHttpResponseHeaders(webResponse, nancyResponse); if (nancyResponse.ContentType != null) { webResponse.ContentType = nancyResponse.ContentType; } webResponse.StatusCode = (System.Net.HttpStatusCode)nancyResponse.StatusCode; }
public oEmbedWriter(OutgoingWebResponseContext response) { _response = response; }
private void SetCacheHeaders(OutgoingWebResponseContext response) { response.ContentType = "image/png"; response.Headers[HttpResponseHeader.CacheControl] = "public"; response.LastModified = new DateTime(1900, 1, 1); response.Headers[HttpResponseHeader.Expires] = (DateTime.Now + Settings.ClientCacheMaxAge).ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss 'GMT'"); }
public OutgoingWebResponseContextWrapper(OutgoingWebResponseContext context) { this.context = context; }
private static void CopyHttpResponseMessageToOutgoingResponse(HttpResponseMessage response, OutgoingWebResponseContext outgoingResponse) { outgoingResponse.StatusCode = response.StatusCode; outgoingResponse.StatusDescription = response.ReasonPhrase; if (response.Content == null) outgoingResponse.SuppressEntityBody = true; foreach (var kvp in response.Headers) { foreach (var value in kvp.Value) { outgoingResponse.Headers.Add(kvp.Key, value); } } if (response.Content != null) { foreach (var kvp in response.Content.Headers) { foreach (var value in kvp.Value) { outgoingResponse.Headers.Add(kvp.Key, value); } } } }
private static void SetNancyResponseToOutgoingResponse(OutgoingWebResponseContext resp, Response response) { resp.ContentType = response.ContentType; resp.StatusCode = response.StatusCode; }
private void Respond(OutgoingWebResponseContext responseContext, HttpResponseMessage responseMessage) { responseContext.StatusCode = responseMessage.StatusCode; responseContext.SuppressEntityBody = true; foreach (var header in responseMessage.Headers) { responseContext.Headers[header.Key] = header.Value.First(); } }
/// <summary> /// Submits this response to a WCF response context. Only available when no response body is included. /// </summary> /// <param name="responseContext">The response context to apply the response to.</param> public virtual void Respond(OutgoingWebResponseContext responseContext) { Requires.NotNull(responseContext, "responseContext"); if (this.ResponseStream != null) { throw new NotSupportedException(Strings.ResponseBodyNotSupported); } responseContext.StatusCode = this.Status; responseContext.SuppressEntityBody = true; foreach (string header in this.Headers) { responseContext.Headers[header] = this.Headers[header]; } }
private void CopyOwinContextToOutgoingResponse(OwinContext owinContext, OutgoingWebResponseContext outgoingResponse) { outgoingResponse.StatusCode = (HttpStatusCode)owinContext.Response.StatusCode; foreach (var h in owinContext.Response.Headers) { outgoingResponse.Headers.Add(h.Key, owinContext.Response.Headers[h.Key]); // TODO remove double lookup } }
public PortalService() { request = WebOperationContext.Current.IncomingRequest; response = WebOperationContext.Current.OutgoingResponse; }
public void CheckConditionalRetrieve(long entityTag) { string validEtag = OutgoingWebResponseContext.GenerateValidEtag(entityTag); CheckConditionalRetrieveWithValidatedEtag(validEtag); }
public void CheckConditionalUpdate(Guid entityTag) { string validEtag = OutgoingWebResponseContext.GenerateValidEtag(entityTag); CheckConditionalUpdateWithValidatedEtag(validEtag); }
private static void SetNancyResponseToOutgoingWebResponse(OutgoingWebResponseContext webResponse, Response nancyResponse) { webResponse.ContentType = nancyResponse.ContentType; webResponse.StatusCode = nancyResponse.StatusCode; }