public Message Get(Message message) { HttpRequestMessageProperty requestMessageProperty = (HttpRequestMessageProperty) message.Properties[HttpRequestMessageProperty.Name]; HttpResponseMessageProperty responseMessageProperty = new HttpResponseMessageProperty(); if ((requestMessageProperty != null) && IsServiceUnchanged(requestMessageProperty.Headers[JsonGlobals.IfModifiedSinceString])) { Message responseMessage = Message.CreateMessage(MessageVersion.None, string.Empty); responseMessageProperty.StatusCode = HttpStatusCode.NotModified; responseMessage.Properties.Add(HttpResponseMessageProperty.Name, responseMessageProperty); return responseMessage; } string proxyContent = this.GetProxyContent(UriTemplate.RewriteUri(this.endpoint.Address.Uri, requestMessageProperty.Headers[HttpRequestHeader.Host])); Message response = new WebScriptMetadataMessage(string.Empty, proxyContent); responseMessageProperty.Headers.Add(JsonGlobals.LastModifiedString, ServiceLastModifiedRfc1123String); responseMessageProperty.Headers.Add(JsonGlobals.ExpiresString, ServiceLastModifiedRfc1123String); if (AspNetEnvironment.Current.AspNetCompatibilityEnabled) { HttpContext.Current.Response.Cache.SetCacheability(HttpCacheability.Public); } else { responseMessageProperty.Headers.Add(JsonGlobals.CacheControlString, JsonGlobals.publicString); } response.Properties.Add(HttpResponseMessageProperty.Name, responseMessageProperty); return response; }
public void BeforeSendReply(ref Message reply, object correlationState) { var state = correlationState as CorsState; if (state != null) { if (state.Message != null) { reply = state.Message; } HttpResponseMessageProperty responseProperty = null; if (reply.Properties.ContainsKey(HttpResponseMessageProperty.Name)) { responseProperty = reply.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty; } if (responseProperty == null) { responseProperty = new HttpResponseMessageProperty(); reply.Properties.Add(HttpResponseMessageProperty.Name, responseProperty); } //Acao should be added for all cors responses responseProperty.Headers.Set("Access-Control-Allow-Origin", _behavior.AllowOrigin); if (state.Message != null) { //the following headers should only be added for OPTIONS requests responseProperty.Headers.Set("Access-Control-Allow-Methods", _behavior.AllowMethods); responseProperty.Headers.Set("Access-Control-Allow-Headers", _behavior.AllowHeaders); } } }
internal IncomingWebResponseContext (OperationContext context) { if (context.IncomingMessageProperties != null) hp = (HttpResponseMessageProperty) context.IncomingMessageProperties [HttpResponseMessageProperty.Name]; else hp = new HttpResponseMessageProperty (); }
void AuthenticationService_Authenticating(object sender, System.Web.ApplicationServices.AuthenticatingEventArgs e) { string roles = string.Empty; e.Authenticated = new UserValidator().IsUserValid(e.UserName, e.Password, out roles); e.AuthenticationIsComplete = true; if (e.Authenticated) { FormsAuthenticationTicket ticket = new FormsAuthenticationTicket( 1, e.UserName, DateTime.Now, DateTime.Now.AddHours(24), true, roles, FormsAuthentication.FormsCookiePath); // Encrypt the ticket using machine key string encryptedValue = FormsAuthentication.Encrypt(ticket); // Attach Cookie to Operation Context header HttpResponseMessageProperty response = new HttpResponseMessageProperty(); response.Headers[HttpResponseHeader.SetCookie] = FormsAuthentication.FormsCookieName + "=" + encryptedValue; OperationContext.Current.OutgoingMessageProperties[HttpResponseMessageProperty.Name] = response; } }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { // var newEx = new FaultException(string.Format("WCF接口出错 {0}", error.TargetSite.Name)); // var newEx = new FaultException(error.Message); // MessageFault msgFault = newEx.CreateMessageFault(); // fault = Message.CreateMessage(version, msgFault, newEx.Action); string errMsg = new JavaScriptSerializer().Serialize(new Fault(error.Message, "测试")); fault = Message.CreateMessage(version, "",errMsg, new DataContractJsonSerializer(typeof (string))); // tell WCF to use JSON encoding rather than default XML WebBodyFormatMessageProperty wbf = new WebBodyFormatMessageProperty(WebContentFormat.Json); // Add the formatter to the fault fault.Properties.Add(WebBodyFormatMessageProperty.Name, wbf); //Modify response HttpResponseMessageProperty rmp = new HttpResponseMessageProperty(); // return custom error code, 500. rmp.StatusCode = System.Net.HttpStatusCode.InternalServerError; rmp.StatusDescription = "InternalServerError"; //Mark the jsonerror and json content rmp.Headers[HttpResponseHeader.ContentType] = "application/json"; rmp.Headers[HttpResponseHeader.ContentEncoding] = "utf-8"; rmp.Headers["jsonerror"] = "true"; //Add to msg fault.Properties.Add(HttpResponseMessageProperty.Name, rmp); }
public void BeginReply_Ignores_HttpResponseMessageProperty_When_Response_Is_Not_HttpMessage() { Message message = Message.CreateMessage(MessageVersion.None, string.Empty, "some content"); HttpResponseMessageProperty property = new HttpResponseMessageProperty(); property.StatusCode = HttpStatusCode.OK; property.SuppressEntityBody = false; property.Headers.Add(HttpResponseHeader.ContentType, "someType/someSubType"); message.Properties.Add(HttpResponseMessageProperty.Name, property); MockRequestContext innerRequestContext = new MockRequestContext(); innerRequestContext.OnReplyReceived = innerMessage => { HttpResponseMessageProperty innerProperty = innerMessage.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty; Assert.IsNotNull(innerProperty, "The inner HttpMessage instance should have had an HttpResponseMessageProperty."); Assert.AreNotSame(property, innerProperty, "The inner HttpResponseMessageProperty should have been a different instance from the one on the response message."); Assert.AreEqual(HttpStatusCode.InternalServerError, innerProperty.StatusCode, "HttpResponseMessageProperty.StatusCode should have been HttpStatusCode.InternalServerError."); Assert.IsTrue(innerProperty.SuppressEntityBody, "HttpResponseMessageProperty.SuppressEntityBody should have been 'true'."); Assert.AreEqual(0, innerProperty.Headers.Count, "HttpResponseMessageProperty.Header.Count should have been zero."); }; HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext); requestContext.BeginReply(message, null, null); Assert.IsTrue(innerRequestContext.BeginReplyCalled, "HttpMessageEncodingRequestContext.BeginReply should have called BeginReply on the inner RequestContext."); }
private HttpResponseMessageProperty CreateResponseProperty() { var responseProperty = new HttpResponseMessageProperty(); responseProperty.StatusCode = HttpStatusCode.Unauthorized; responseProperty.Headers.Add(BasicAuthenticationHeaderName, string.Format(CultureInfo.InvariantCulture, "Basic realm=\"{0}\"", realm)); return responseProperty; }
public void BeforeSendReply(ref Message reply, object correlationState) { if ((reply != null) && reply.IsFault) { var property = new HttpResponseMessageProperty { StatusCode = HttpStatusCode.OK }; reply.Properties[HttpResponseMessageProperty.Name] = property; } }
public Message GetFlashPolicy(Message request) { HttpRequestMessageProperty httpRequestProperty; if (request.Properties.ContainsKey(HttpRequestMessageProperty.Name)) { httpRequestProperty = request.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty; if (!httpRequestProperty.Method.Equals("GET", StringComparison.OrdinalIgnoreCase)) { Message reply = Message.CreateMessage(MessageVersion.None, String.Empty); HttpResponseMessageProperty responseProperty = new HttpResponseMessageProperty(); responseProperty.StatusCode = System.Net.HttpStatusCode.MethodNotAllowed; responseProperty.SuppressEntityBody = true; reply.Properties.Add(HttpResponseMessageProperty.Name, responseProperty); return reply; } } string result = @"<?xml version=""1.0""?> <!DOCTYPE cross-domain-policy SYSTEM ""http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd""> <cross-domain-policy> <allow-access-from domain=""*"" /> </cross-domain-policy>"; WebOperationContext.Current.OutgoingResponse.ContentType = "application/xml"; Message replyMessage = StreamMessageHelper.CreateMessage(MessageVersion.None, String.Empty, new MemoryStream(Encoding.UTF8.GetBytes(result))); HttpResponseMessageProperty replyProperty = new HttpResponseMessageProperty(); replyProperty.StatusCode = System.Net.HttpStatusCode.OK; replyProperty.Headers[HttpResponseHeader.ContentType] = "text/xml;charset=utf-8"; replyMessage.Properties.Add(HttpResponseMessageProperty.Name, replyProperty); return replyMessage; }
public void BeforeSendReply(ref Message reply, object correlationState) { HttpResponseMessageProperty property = null; if (reply == null) { // This will usually be for a preflight response reply = Message.CreateMessage(MessageVersion.None, null); property = new HttpResponseMessageProperty(); reply.Properties[HttpResponseMessageProperty.Name] = property; property.StatusCode = HttpStatusCode.OK; } else { property = reply.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty; } PreflightDetected preflightRequest = OperationContext.Current.Extensions.Find<PreflightDetected>(); if (preflightRequest != null) { // Add allow HTTP headers to respond to the preflight request if (preflightRequest.RequestedHeaders == string.Empty) property.Headers.Add("Access-Control-Allow-Headers", "Accept"); else property.Headers.Add("Access-Control-Allow-Headers", preflightRequest.RequestedHeaders + ", Accept"); property.Headers.Add("Access-Control-Allow-Methods", "*"); } // Add allow-origin header to each response message, because client expects it if (property != null) property.Headers.Add("Access-Control-Allow-Origin", "*"); }
public override void ProcessRequest(ref System.ServiceModel.Channels.RequestContext requestContext) { var request = requestContext.RequestMessage; if (endpointFilter == null || endpointFilter(request)) { IPrincipal principal = ExtractCredentials(request); if (principal != null) { InitializeSecurityContext(request, principal); } else { var reply = Message.CreateMessage(MessageVersion.None, null); var responseProperty = new HttpResponseMessageProperty() { StatusCode = HttpStatusCode.Unauthorized }; if (sendChallenge) { var ts = Hawk.ConvertToUnixTimestamp(DateTime.Now).ToString(); var challenge = string.Format("ts=\"{0}\" ntp=\"{1}\"", ts, "pool.ntp.org"); responseProperty.Headers.Add("WWW-Authenticate", challenge); } reply.Properties[HttpResponseMessageProperty.Name] = responseProperty; requestContext.Reply(reply); requestContext = null; } } }
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; } }
Message HandlePreflight(Message input) { HttpRequestMessageProperty httpRequest = (HttpRequestMessageProperty)input.Properties[HttpRequestMessageProperty.Name]; string origin = httpRequest.Headers[CorsConstants.Origin]; string requestMethod = httpRequest.Headers[CorsConstants.AccessControlRequestMethod]; string requestHeaders = httpRequest.Headers[CorsConstants.AccessControlRequestHeaders]; Message reply = Message.CreateMessage(MessageVersion.None, replyAction); HttpResponseMessageProperty httpResponse = new HttpResponseMessageProperty(); reply.Properties.Add(HttpResponseMessageProperty.Name, httpResponse); httpResponse.SuppressEntityBody = true; httpResponse.StatusCode = HttpStatusCode.OK; if (origin != null) { httpResponse.Headers.Add(CorsConstants.AccessControlAllowOrigin, origin); } if (requestMethod != null && this.allowedHttpMethods.Contains(requestMethod)) { httpResponse.Headers.Add(CorsConstants.AccessControlAllowMethods, string.Join(",", this.allowedHttpMethods)); } if (requestHeaders != null) { httpResponse.Headers.Add(CorsConstants.AccessControlAllowHeaders, requestHeaders); } return reply; }
/// <summary> /// Enables the creation of a custom <see cref="System.ServiceModel.FaultException"/> /// that is returned from an exception in the course of a service method. /// </summary> /// <param name="error"></param> /// <param name="version"></param> /// <param name="faultMessage"></param> public void ProvideFault(Exception error, MessageVersion version, ref Message faultMessage) { // Gets a serializable Fault object fromn error. Fault fault = Fault.GetFault(error); // Now we make the message by serializing the Fault to JSON. faultMessage = Message.CreateMessage(version, null, fault, new DataContractJsonSerializer(fault.GetType())); // Gotta set HTTP status codes. HttpResponseMessageProperty prop = new HttpResponseMessageProperty() { StatusCode = HttpStatusCode.InternalServerError, // 500 StatusDescription = "An internal server error occurred." // Could use elaboration. }; // Make sure to set the content type. Important for avoiding // certain kinds of encoding-specific XSS attacks. prop.Headers[HttpResponseHeader.ContentType] = "application/json; charset=utf-8"; // Set a few other properties of the Message. faultMessage.Properties.Add(HttpResponseMessageProperty.Name, prop); faultMessage.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Json)); }
private static HttpResponseMessageProperty CreateResponseProperty(DigestHeader digestHeader) { var responseProperty = new HttpResponseMessageProperty(); responseProperty.StatusCode = HttpStatusCode.Unauthorized; responseProperty.Headers.Add(DigestAuthenticationHeaderName, digestHeader.GenerateHeaderString()); return responseProperty; }
private static void AssignLogStatus(HttpResponseMessageProperty httpResp, Message reply, Log log) { string errorElement = log["SuccessElement"]; if(string.IsNullOrEmpty(errorElement)) return; if (!log.Response.Contains(errorElement)) log.Status = Status.Failure; }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { var errorModel = new ErrorModel {Message = error.Message, Type = error.GetType().Name, Success = false}; fault = Message.CreateMessage(version, null, errorModel, new DataContractJsonSerializer(typeof (ErrorModel))); fault.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Json)); if (IsAuthenticationException(error)) { var rmp = new HttpResponseMessageProperty {StatusCode = HttpStatusCode.Unauthorized}; rmp.StatusDescription = rmp.StatusCode.ToString(); rmp.Headers[HttpResponseHeader.ContentType] = "application/json"; fault.Properties.Add(HttpResponseMessageProperty.Name, rmp); } else if (error.GetType() == typeof (InvalidOperationException) || error.GetType() == typeof (ArgumentException)) { var rmp = new HttpResponseMessageProperty {StatusCode = HttpStatusCode.BadRequest}; rmp.StatusDescription = rmp.StatusCode.ToString(); rmp.Headers[HttpResponseHeader.ContentType] = "application/json"; fault.Properties.Add(HttpResponseMessageProperty.Name, rmp); } else { errorModel.Message = "Unable to perform the operation"; var rmp = new HttpResponseMessageProperty {StatusCode = HttpStatusCode.InternalServerError}; rmp.StatusDescription = rmp.StatusCode.ToString(); rmp.Headers[HttpResponseHeader.ContentType] = "application/json"; fault.Properties.Add(HttpResponseMessageProperty.Name, rmp); } }
public static void SetHttpResponseProperty(this Message message, HttpResponseMessageProperty httpResponse) { if (message.Properties.ContainsKey(HttpResponseMessageProperty.Name)) message.Properties.Remove(HttpResponseMessageProperty.Name); message.Properties.Add(HttpResponseMessageProperty.Name, httpResponse); }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { var errType = error.GetType(); var rmp = new HttpResponseMessageProperty(); var fe = error as FaultException<int>; if (fe != null) { //Detail for the returned value var faultCode = fe.Detail; var cause = fe.Message; //The json serializable object var msErrObject = new Result { errorType = errType.Name, install_status = faultCode, message = cause}; //The fault to be returned fault = Message.CreateMessage(version, "", msErrObject, new DataContractJsonSerializer(msErrObject.GetType())); //fault = Message.CreateMessage(version, new FaultCode(errType.Name), error.Message, ""); var wbf = new WebBodyFormatMessageProperty(WebContentFormat.Json); // Add the formatter to the fault fault.Properties.Add(WebBodyFormatMessageProperty.Name, wbf); // return custom error code, 400. rmp.StatusCode = HttpStatusCode.BadRequest; rmp.StatusDescription = "Bad request"; } else { //Arbitraty error var msErrObject = new Result { errorType = errType.Name, install_status = 0, message = error.Message }; // create a fault message containing our FaultContract object fault = Message.CreateMessage(version, "", msErrObject, new DataContractJsonSerializer(msErrObject.GetType())); // tell WCF to use JSON encoding rather than default XML var wbf = new WebBodyFormatMessageProperty(WebContentFormat.Json); fault.Properties.Add(WebBodyFormatMessageProperty.Name, wbf); //Internal server error with exception mesasage as status. bool isForbidden = false; var webEx = error as WebException; if (webEx != null) { var httpResp = (HttpWebResponse) webEx.Response; if (httpResp != null) isForbidden = httpResp.StatusCode == HttpStatusCode.Forbidden; } if ((error is AuthenticationException) || isForbidden) rmp.StatusCode = HttpStatusCode.Forbidden; else rmp.StatusCode = HttpStatusCode.InternalServerError; rmp.StatusDescription = error.Message; } //Mark the jsonerror and json content rmp.Headers[HttpResponseHeader.ContentType] = "application/json"; rmp.Headers["jsonerror"] = "true"; //Add to fault fault.Properties.Add(HttpResponseMessageProperty.Name, rmp); }
/// <summary> /// Provides the fault. /// </summary> /// <param name="error">The error.</param> /// <param name="version">The version.</param> /// <param name="fault">The fault.</param> public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { if (fault != null) { HttpResponseMessageProperty properties = new HttpResponseMessageProperty(); properties.StatusCode = HttpStatusCode.InternalServerError; fault.Properties.Add(HttpResponseMessageProperty.Name, properties); } }
public Message ProcessRequest(Message request) { Console.WriteLine("Server received a request from client"); HttpResponseMessageProperty httpResponseProperty = new HttpResponseMessageProperty(); httpResponseProperty.Headers.Add("Content-Type", "application/octet-stream"); request.Properties.Add(HttpResponseMessageProperty.Name, httpResponseProperty); Console.WriteLine("Server is sending back the same image to client"); return request; }
/// <summary> /// Get the HttpResponseMessageProperty /// </summary> /// <param name="fault"></param> /// <param name="statusCode"></param> /// <param name="statusDescription"></param> protected virtual void ApplyHttpResponseSettings(ref Message fault, System.Net.HttpStatusCode statusCode, string statusDescription) { var httpResponse = new HttpResponseMessageProperty() { StatusCode = statusCode, StatusDescription = statusDescription }; fault.Properties.Add(HttpResponseMessageProperty.Name, httpResponse); }
/// <summary> /// Called after the operation has returned but before the reply message is sent. /// </summary> /// <param name="reply">The reply message. This value is null if the operation is one way.</param><param name="correlationState">The correlation object returned from the <see cref="M:System.ServiceModel.Dispatcher.IDispatchMessageInspector.AfterReceiveRequest(System.ServiceModel.Channels.Message@,System.ServiceModel.IClientChannel,System.ServiceModel.InstanceContext)"/> method.</param> public void BeforeSendReply(ref Message reply, object correlationState) { if (reply.IsFault) { var property = new HttpResponseMessageProperty(); // Here the response code is changed to 200. property.StatusCode = HttpStatusCode.OK; reply.Properties[HttpResponseMessageProperty.Name] = property; } }
void IDispatchMessageInspector.BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { if (reply.IsFault) { HttpResponseMessageProperty property = new HttpResponseMessageProperty(); property.StatusCode = System.Net.HttpStatusCode.OK; // 200 reply.Properties[HttpResponseMessageProperty.Name] = property; } }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { var realException = GetRealException(error); FaultException fe = new FaultException(realException.Message); MessageFault messageFault = fe.CreateMessageFault(); fault = Message.CreateMessage(version, messageFault, "http://microsoft.wcf.documentation/default"); HttpResponseMessageProperty property = new HttpResponseMessageProperty(); property.StatusCode = System.Net.HttpStatusCode.OK; fault.Properties[HttpResponseMessageProperty.Name] = property; }
public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result) { Message message = Message.CreateMessage(messageVersion, null, new MyJSSBodyWriter(result)); HttpResponseMessageProperty httpProp = new HttpResponseMessageProperty(); message.Properties.Add(HttpResponseMessageProperty.Name, httpProp); httpProp.Headers[HttpResponseHeader.ContentType] = "application/json"; WebBodyFormatMessageProperty bodyFormat = new WebBodyFormatMessageProperty(WebContentFormat.Raw); message.Properties.Add(WebBodyFormatMessageProperty.Name, bodyFormat); return message; }
protected override bool CheckAccessCore(OperationContext operationContext) { var prop = new HttpResponseMessageProperty(); prop.Headers.Add("Access-Control-Allow-Origin", "*"); prop.Headers.Add("Access-Control-Allow-Methods", "POST, GET, DELETE, PUT, OPTIONS"); prop.Headers.Add("Access-Control-Allow-Headers", "Content-Type, accept"); operationContext.OutgoingMessageProperties.Add(HttpResponseMessageProperty.Name, prop); return true; }
IMessageProperty IMessageProperty.CreateCopy () { var copy = new HttpResponseMessageProperty (); // FIXME: Clone headers? copy.headers = headers; copy.status_desc = status_desc; copy.status_code = status_code; copy.suppress_entity = suppress_entity; return copy; }
public Message ProcessMessage(Message request) { Message response = null; //The HTTP Method (e.g. GET) from the incoming HTTP request //can be found on the HttpRequestMessageProperty. The MessageProperty //is added by the HTTP Transport when the message is received. HttpRequestMessageProperty requestProperties = (HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name]; //Here we dispatch to different internal implementation methods //based on the incoming HTTP verb. if (requestProperties != null) { if (String.Equals("GET", requestProperties.Method, StringComparison.OrdinalIgnoreCase)) { response = GetCustomer(request); } else if (String.Equals("PUT", requestProperties.Method, StringComparison.OrdinalIgnoreCase)) { response = UpdateCustomer(request); } else if (String.Equals("POST", requestProperties.Method, StringComparison.OrdinalIgnoreCase)) { response = AddCustomer(request); } else if (String.Equals("DELETE", requestProperties.Method, StringComparison.OrdinalIgnoreCase)) { response = DeleteCustomer(request); } else { //This service doesn't implement handlers for other HTTP verbs (such as HEAD), so we //construct a response message and use the HttpResponseMessageProperty to //set the HTTP status code to 405 (Method Not Allowed) which indicates the client //used an HTTP verb not supported by the server. response = Message.CreateMessage(MessageVersion.None, String.Empty, String.Empty); HttpResponseMessageProperty responseProperty = new HttpResponseMessageProperty(); responseProperty.StatusCode = HttpStatusCode.MethodNotAllowed; response.Properties.Add( HttpResponseMessageProperty.Name, responseProperty ); } } else { throw new InvalidOperationException( "This service requires the HTTP transport" ); } return response; }
public Message CreateEmptyResponse() { Message response = Message.CreateMessage(MessageVersion.Default, null, (object)null); HttpResponseMessageProperty http = new HttpResponseMessageProperty(); http.StatusCode = System.Net.HttpStatusCode.OK; http.SuppressEntityBody = true; response.Properties.Add(HttpResponseMessageProperty.Name, http); return response; }
HttpResponseMessage CreateHttpResponseMessage(Message message) { HttpResponseMessage httpResponseMessage = HttpResponseMessageProperty.GetHttpResponseMessageFromMessage(message); if (httpResponseMessage == null) { HttpResponseMessageProperty property = message.Properties.GetValue <HttpResponseMessageProperty>(HttpResponseMessageProperty.Name); httpResponseMessage = new HttpResponseMessage(); httpResponseMessage.StatusCode = message.IsFault ? HttpStatusCode.InternalServerError : HttpStatusCode.OK; this.httpOutput.ConfigureHttpResponseMessage(message, httpResponseMessage, property); } return(httpResponseMessage); }
private Message CreateAckMessage(HttpStatusCode statusCode, string statusDescription) { Message message = new NullMessage(); HttpResponseMessageProperty property = new HttpResponseMessageProperty { StatusCode = statusCode, SuppressEntityBody = true }; if (statusDescription.Length > 0) { property.StatusDescription = statusDescription; } message.Properties.Add(HttpResponseMessageProperty.Name, property); return(message); }
public HttpResponseMessageProperty CreateTraditionalResponseMessageProperty() { HttpResponseMessageProperty copiedProperty = new HttpResponseMessageProperty(); copiedProperty.Headers.Add(this.Headers); if (this.StatusCode != TraditionalHttpResponseMessageProperty.DefaultStatusCode) { copiedProperty.StatusCode = this.StatusCode; } copiedProperty.StatusDescription = this.StatusDescription; copiedProperty.SuppressEntityBody = this.SuppressEntityBody; return(copiedProperty); }
Message CreateAckMessage(HttpStatusCode statusCode, string statusDescription) { Message ackMessage = new NullMessage(); HttpResponseMessageProperty httpResponseProperty = new HttpResponseMessageProperty(); httpResponseProperty.StatusCode = statusCode; httpResponseProperty.SuppressEntityBody = true; if (statusDescription.Length > 0) { httpResponseProperty.StatusDescription = statusDescription; } ackMessage.Properties.Add(HttpResponseMessageProperty.Name, httpResponseProperty); return(ackMessage); }
protected override void ProcessReply(Message msg, TimeSpan timeout) { if (msg == null) { throw new ArgumentNullException("msg"); } // FIXME: should this be done here? if (channel.MessageVersion.Addressing.Equals(AddressingVersion.None)) { msg.Headers.Action = null; // prohibited } MemoryStream ms = new MemoryStream(); channel.Encoder.WriteMessage(msg, ms); ctx.Response.ContentType = channel.Encoder.ContentType; string pname = HttpResponseMessageProperty.Name; bool suppressEntityBody = false; if (msg.Properties.ContainsKey(pname)) { HttpResponseMessageProperty hp = (HttpResponseMessageProperty)msg.Properties [pname]; string contentType = hp.Headers ["Content-Type"]; if (contentType != null) { ctx.Response.ContentType = contentType; } ctx.Response.Headers.Add(hp.Headers); if (hp.StatusCode != default(HttpStatusCode)) { ctx.Response.StatusCode = (int)hp.StatusCode; } ctx.Response.StatusDescription = hp.StatusDescription; if (hp.SuppressEntityBody) { suppressEntityBody = true; } } if (!suppressEntityBody) { ctx.Response.ContentLength64 = ms.Length; ctx.Response.OutputStream.Write(ms.GetBuffer(), 0, (int)ms.Length); ctx.Response.OutputStream.Flush(); } }
internal static HttpResponseMessage GetHttpResponseMessageFromMessage(Message message) { HttpResponseMessage httpResponseMessage = null; HttpResponseMessageProperty property = message.Properties.GetValue <HttpResponseMessageProperty>(HttpResponseMessageProperty.Name); if (property != null) { httpResponseMessage = property.HttpResponseMessage; if (httpResponseMessage != null) { httpResponseMessage.CopyPropertiesFromMessage(message); message.EnsureReadMessageState(); } } return(httpResponseMessage); }
void OnSendHttpCookies(Message message, ContextMessageProperty context, Uri requestUri) { object tmpProperty; HttpResponseMessageProperty property = null; if (message.Properties.TryGetValue(HttpResponseMessageProperty.Name, out tmpProperty)) { property = tmpProperty as HttpResponseMessageProperty; } if (property == null) { property = new HttpResponseMessageProperty(); message.Properties.Add(HttpResponseMessageProperty.Name, property); } string setCookieHeader = HttpCookieToolbox.EncodeContextAsHttpSetCookieHeader(context, requestUri); property.Headers.Add(HttpResponseHeader.SetCookie, setCookieHeader); }
protected override void ProcessReply(Message msg, TimeSpan timeout) { ctx.Response.ContentType = Channel.Encoder.ContentType; MemoryStream ms = new MemoryStream(); Channel.Encoder.WriteMessage(msg, ms); string pname = HttpResponseMessageProperty.Name; bool suppressEntityBody = false; if (msg.Properties.ContainsKey(pname)) { HttpResponseMessageProperty hp = (HttpResponseMessageProperty)msg.Properties [pname]; string contentType = hp.Headers ["Content-Type"]; if (contentType != null) { ctx.Response.ContentType = contentType; } ctx.Response.Headers.Add(hp.Headers); if (hp.StatusCode != default(HttpStatusCode)) { ctx.Response.StatusCode = (int)hp.StatusCode; } ctx.Response.StatusDescription = hp.StatusDescription; if (hp.SuppressEntityBody) { suppressEntityBody = true; } } if (msg.IsFault) { ctx.Response.StatusCode = 500; } if (!suppressEntityBody) { ctx.Response.AddHeader("Content-Length", ms.Length.ToString(CultureInfo.InvariantCulture)); ctx.Response.OutputStream.Write(ms.GetBuffer(), 0, (int)ms.Length); ctx.Response.OutputStream.Flush(); } else { ctx.Response.SuppressContent = true; } }
public bool SendResponse() { if (onSendCompleted == null) { onSendCompleted = Fx.ThunkCallback(new AsyncCallback(OnSendResponseCompletedCallback)); } bool success = false; try { this.closeOutputAfterReply = context.PrepareReply(ref this.responseMessage); if (onHttpPipelineSend == null) { onHttpPipelineSend = new Action <object, HttpResponseMessage>(OnHttpPipelineSendCallback); } if (context.httpPipeline.SendAsyncReply(this.responseMessage, onHttpPipelineSend, this) == AsyncCompletionResult.Queued) { //// In Async send + HTTP pipeline path, we will send the response back after the result coming out from the pipeline. //// So we don't need to call it here. success = true; return(false); } HttpResponseMessage httpResponseMessage = null; if (this.context.HttpMessagesSupported) { httpResponseMessage = HttpResponseMessageProperty.GetHttpResponseMessageFromMessage(this.responseMessage); } return(this.SendResponseCore(httpResponseMessage, out success)); } finally { if (!success && this.message != null && !object.ReferenceEquals(this.message, this.responseMessage)) { this.responseMessage.Close(); } } }
public HttpResponseMessageProperty CreateTraditionalResponseMessageProperty() { HttpResponseMessageProperty copiedProperty = new HttpResponseMessageProperty(); foreach (var headerKey in this.Headers.AllKeys) { copiedProperty.Headers[headerKey] = this.Headers[headerKey]; } if (this.StatusCode != TraditionalHttpResponseMessageProperty.DefaultStatusCode) { copiedProperty.StatusCode = this.StatusCode; } copiedProperty.StatusDescription = this.StatusDescription; copiedProperty.SuppressEntityBody = this.SuppressEntityBody; return(copiedProperty); }
protected override void SendReplyCore(Message message, TimeSpan timeout) { this.TraceProcessResponseStart(); ThreadTrace.Trace("Begin sending http reply"); HttpOutput httpOutput = this.GetHttpOutput(message); HttpResponseMessage response = HttpResponseMessageProperty.GetHttpResponseMessageFromMessage(message); if (response != null) { httpOutput.Send(response, timeout); } else { httpOutput.Send(timeout); } ThreadTrace.Trace("End sending http reply"); this.TraceProcessResponseStop(); }
public void BeforeSendReply(ref Message reply, object correlationState) { if (DEBUG && correlationState != null) { QZ.RealTimeRequestLogService.RequestLog rt = (QZ.RealTimeRequestLogService.RequestLog)correlationState; TimeSpan ts = DateTime.Now - rt.Time; rt.TotalSpend = ts.Milliseconds; if (reply != null) { MessageProperties mp = reply.Properties; object obj; if (mp.TryGetValue("httpResponse", out obj)) { System.ServiceModel.Channels.HttpResponseMessageProperty wh = (System.ServiceModel.Channels.HttpResponseMessageProperty)obj; rt.ResponseHeader = wh.Headers.ToString(); rt.ResponseContentType = wh.Headers[System.Net.HttpResponseHeader.ContentType]; rt.ResponseStatusCode = (int)wh.StatusCode; rt.ResponseStatusStr = wh.StatusCode.ToString(); } if (rt.ResponseStatusCode == 200) { rt.Response = GetReponseBody(reply); } else { rt.Response = string.Empty; } } else { rt.ResponseStatusStr = "no reply message captured, unable to read the response infomation."; } QZ.RealTimeRequestLogService.RealTimeRequestLog.AppendLog(rt); } }
void GotResponse(IAsyncResult result) { HttpChannelRequestAsyncResult channelResult = (HttpChannelRequestAsyncResult)result.AsyncState; channelResult.CompletedSynchronously &= result.CompletedSynchronously; WebResponse res; Stream resstr; try { res = channelResult.WebRequest.EndGetResponse(result); resstr = res.GetResponseStream(); } catch (WebException we) { res = we.Response; if (res == null) { channelResult.Complete(we); return; } var hrr2 = (HttpWebResponse)res; if ((int)hrr2.StatusCode >= 400 && (int)hrr2.StatusCode < 500) { Exception exception = new WebException( String.Format("There was an error on processing web request: Status code {0}({1}): {2}", (int)hrr2.StatusCode, hrr2.StatusCode, hrr2.StatusDescription), null, WebExceptionStatus.ProtocolError, hrr2); if ((int)hrr2.StatusCode == 404) { // Throw the same exception .NET does exception = new EndpointNotFoundException( "There was no endpoint listening at {0} that could accept the message. This is often caused by an incorrect address " + "or SOAP action. See InnerException, if present, for more details.", exception); } channelResult.Complete(exception); return; } try { // The response might contain SOAP fault. It might not. resstr = res.GetResponseStream(); } catch (WebException we2) { channelResult.Complete(we2); return; } } var hrr = (HttpWebResponse)res; if ((int)hrr.StatusCode >= 400 && (int)hrr.StatusCode < 500) { channelResult.Complete(new WebException(String.Format("There was an error on processing web request: Status code {0}({1}): {2}", (int)hrr.StatusCode, hrr.StatusCode, hrr.StatusDescription))); } try { Message ret; // TODO: unit test to make sure an empty response never throws // an exception at this level if (hrr.ContentLength == 0) { ret = Message.CreateMessage(Encoder.MessageVersion, String.Empty); } else { using (var responseStream = resstr) { MemoryStream ms = new MemoryStream(); byte [] b = new byte [65536]; int n = 0; while (true) { n = responseStream.Read(b, 0, 65536); if (n == 0) { break; } ms.Write(b, 0, n); } ms.Seek(0, SeekOrigin.Begin); ret = Encoder.ReadMessage( ms, (int)source.Transport.MaxReceivedMessageSize, res.ContentType); } } var rp = new HttpResponseMessageProperty() { StatusCode = hrr.StatusCode, StatusDescription = hrr.StatusDescription }; #if MOONLIGHT if (hrr.SupportsHeaders) { foreach (string key in hrr.Headers) { rp.Headers [key] = hrr.Headers [key]; } } #else foreach (var key in hrr.Headers.AllKeys) { rp.Headers [key] = hrr.Headers [key]; } #endif ret.Properties.Add(HttpResponseMessageProperty.Name, rp); channelResult.Response = ret; channelResult.Complete(); } catch (Exception ex) { channelResult.Complete(ex); } finally { res.Close(); } }
protected override void ProcessReply(Message msg, TimeSpan timeout) { if (msg == null) { throw new ArgumentNullException("msg"); } // Handle DestinationUnreacheable as 400 (it is what .NET does). if (msg.IsFault) { // FIXME: isn't there any better way? var mb = msg.CreateBufferedCopy(0x10000); var fault = MessageFault.CreateFault(mb.CreateMessage(), 0x10000); if (fault.Code.Name == "DestinationUnreachable") { ctx.Response.StatusCode = 400; return; } else { msg = mb.CreateMessage(); } } // FIXME: should this be done here? if (channel.MessageVersion.Addressing.Equals(AddressingVersion.None)) { msg.Headers.Action = null; // prohibited } MemoryStream ms = new MemoryStream(); channel.Encoder.WriteMessage(msg, ms); ctx.Response.ContentType = channel.Encoder.ContentType; string pname = HttpResponseMessageProperty.Name; bool suppressEntityBody = false; if (msg.Properties.ContainsKey(pname)) { HttpResponseMessageProperty hp = (HttpResponseMessageProperty)msg.Properties [pname]; string contentType = hp.Headers ["Content-Type"]; if (contentType != null) { ctx.Response.ContentType = contentType; } ctx.Response.Headers.Add(hp.Headers); if (hp.StatusCode != default(HttpStatusCode)) { ctx.Response.StatusCode = (int)hp.StatusCode; } ctx.Response.StatusDescription = hp.StatusDescription; if (hp.SuppressEntityBody) { suppressEntityBody = true; } } if (!suppressEntityBody) { ctx.Response.ContentLength64 = ms.Length; ctx.Response.OutputStream.Write(ms.GetBuffer(), 0, (int)ms.Length); ctx.Response.OutputStream.Flush(); } }