public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream) { if (requestMsg != null) { // The message has already been deserialized so delegate to the next sink. return(_nextSink.ProcessMessage( sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream)); } SdlType sdlType; if (!ShouldIntercept(requestHeaders, out sdlType)) { return(_nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream)); } // generate sdl and return it responseHeaders = new TransportHeaders(); GenerateSdl(sdlType, sinkStack, requestHeaders, responseHeaders, out responseStream); responseMsg = null; return(ServerProcessing.Complete); } // ProcessMessage
public IPEndPoint Read(out ITransportHeaders headers, out Stream stream, out IPEndPoint remote) { // FIXME: 1) reliability 2) exceptions remote = new IPEndPoint(IPAddress.Loopback, 0); var buffer = UdpClient.Receive(ref remote); using (var ms = new MemoryStream(buffer)) using (var br = new BinaryReader(ms)) { var marker = br.ReadInt16(); if (marker != HeaderMarker && marker != DataMarker) { throw new InvalidDataException("Unexpected datagram format"); } // read transport headers headers = new TransportHeaders(); while (marker != DataMarker) { var name = br.ReadString(); var value = br.ReadString(); headers[name] = value; marker = br.ReadInt16(); } // get response stream var length = br.ReadInt32(); stream = new MemoryStream(buffer, (int)ms.Position, length); } return(remote); }
private void SerializeResponse(IMessage responseMsg, ref ITransportHeaders responseHeaders, ref Stream responseStream, IXmlRpcStreamRequestConfig config) { XmlRpcResponseSerializer serializer = new XmlRpcResponseSerializer(); responseStream = new MemoryStream(); responseHeaders = new TransportHeaders(); ReturnMessage retMsg = (ReturnMessage)responseMsg; XmlRpcResponse response; if (retMsg.Exception == null) { response = new XmlRpcResponse(retMsg.ReturnValue); } else if (retMsg.Exception is XmlRpcException) { response = new XmlRpcResponse(); response.Fault = (retMsg.Exception as XmlRpcException).Fault; } else { response = new XmlRpcResponse(); response.Fault = new XmlRpcFault(1, retMsg.Exception.Message); } serializer.WriteResponse(responseStream, response, config, TypeSerializerFactory); responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\""; }
public IMessage SyncProcessMessage(IMessage msg) { try { ITransportHeaders call_headers = new TransportHeaders(); call_headers["__RequestUri"] = ((IMethodCallMessage)msg).Uri; call_headers["Content-Type"] = "application/octet-stream"; Stream call_stream = _nextInChain.GetRequestStream(msg, call_headers); if (call_stream == null) { call_stream = new MemoryStream(); } // Serialize msg to the stream _binaryCore.Serializer.Serialize(call_stream, msg, null); if (call_stream is MemoryStream) { call_stream.Position = 0; } Stream response_stream; ITransportHeaders response_headers; _nextInChain.ProcessMessage(msg, call_headers, call_stream, out response_headers, out response_stream); // Deserialize response_stream return((IMessage)_binaryCore.Deserializer.DeserializeMethodResponse(response_stream, null, (IMethodCallMessage)msg)); } catch (Exception e) { return(new ReturnMessage(e, (IMethodCallMessage)msg)); } }
} // SendContinue public void SendResponse(Stream httpContentStream, String statusCode, String reasonPhrase, ITransportHeaders headers) { if (_responseStream != null) { _responseStream.Close(); if (_responseStream != httpContentStream) { throw new RemotingException( CoreChannel.GetResourceString("Remoting_Http_WrongResponseStream")); } // we are done with the response stream _responseStream = null; } else { if (headers == null) { headers = new TransportHeaders(); } String serverHeader = (String)headers["Server"]; if (serverHeader != null) { serverHeader = HttpServerTransportSink.ServerHeader + ", " + serverHeader; } else { serverHeader = HttpServerTransportSink.ServerHeader; } headers["Server"] = serverHeader; // Add length to response headers if necessary if (!AllowChunkedResponse && (httpContentStream != null)) { headers["Content-Length"] = httpContentStream.Length.ToString(CultureInfo.InvariantCulture); } else if (httpContentStream == null) { headers["Content-Length"] = "0"; } GetResponseStream(statusCode, reasonPhrase, headers); // write HTTP content if (httpContentStream != null) { StreamHelper.CopyStream(httpContentStream, _responseStream); _responseStream.Close(); httpContentStream.Close(); } // we are done with the response stream _responseStream = null; } } // SendResponse
public ITransportHeaders ReadHeaders() { TransportHeaders headers = new TransportHeaders(); // read uri (and make sure that no channel specific data is present) String uri = ReadString(); if (uri != "" && uri != null) { String chanuri, objuri; chanuri = PipeConnection.Parse(uri, out objuri); if (chanuri == null) { objuri = uri; } headers[CommonTransportKeys.RequestUri] = objuri; } // read to end of headers ushort marker = ReadUShort(); while (marker == HeaderMarker) { String hname = ReadString(); String hvalue = ReadString(); headers[hname] = hvalue; marker = ReadUShort(); } return(headers); }
public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream) { UnixConnection connection = null; try { if (requestHeaders == null) { requestHeaders = new TransportHeaders(); } requestHeaders["__RequestUri"] = ((IMethodMessage)msg).Uri; connection = UnixConnectionPool.GetConnection(this._path); UnixMessageIO.SendMessageStream(connection.Stream, requestStream, requestHeaders, connection.Buffer); connection.Stream.Flush(); if (UnixMessageIO.ReceiveMessageStatus(connection.Stream, connection.Buffer) != MessageStatus.MethodMessage) { throw new RemotingException("Unknown response message from server"); } responseStream = UnixMessageIO.ReceiveMessageStream(connection.Stream, out responseHeaders, connection.Buffer); } finally { if (connection != null) { connection.Release(); } } }
void SerializeResponse( IMessage responseMsg, ref ITransportHeaders responseHeaders, ref Stream responseStream) { XmlRpcResponseSerializer serializer = new XmlRpcResponseSerializer(); responseStream = new MemoryStream(); responseHeaders = new TransportHeaders(); ReturnMessage retMsg = (ReturnMessage)responseMsg; if (retMsg.Exception == null) { XmlRpcResponse xmlRpcResp = new XmlRpcResponse(retMsg.ReturnValue); serializer.SerializeResponse(responseStream, xmlRpcResp); } else if (retMsg.Exception is XmlRpcFaultException) { serializer.SerializeFaultResponse(responseStream, (XmlRpcFaultException)retMsg.Exception); } else { serializer.SerializeFaultResponse(responseStream, new XmlRpcFaultException(1, retMsg.Exception.Message)); } responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\""; }
public IMessage SyncProcessMessage(IMessage msg) { IMethodCallMessage mcall = msg as IMethodCallMessage; Trace.WriteLine("IceClientFormatterSink: ProcessMessage: " + mcall.MethodBase); try { Stream msgStream; FormatMessage(msg, out msgStream); // send downstream for processing TransportHeaders reqHeaders = new TransportHeaders(); ITransportHeaders respHeaders; Stream respStream; _next.ProcessMessage(msg, reqHeaders, msgStream, out respHeaders, out respStream); // convert back into a response message IMessage result = (IMessage)IceChannelUtils.ProtocolReplyToMessage(respStream, msg); respStream.Close(); return(result); } catch (Exception e) { return(new ReturnMessage(e, mcall)); } }
} // SendContinue public void SendResponse(Stream httpContentStream, String statusCode, String reasonPhrase, ITransportHeaders headers) { if (_responseStream != null) { _responseStream.Close(); if (_responseStream != httpContentStream) { throw new RemotingException( "Http transport sink was not given the stream that it returned from GetResponseStream()."); } // we are done with the response stream _responseStream = null; } else { if (headers == null) { headers = new TransportHeaders(); } String serverHeader = (String)headers["Server"]; if (serverHeader != null) { serverHeader = HttpServerTransportSink.ServerHeader + ", " + serverHeader; } else { serverHeader = HttpServerTransportSink.ServerHeader; } headers["Server"] = serverHeader; // Add length to response headers if necessary if (!AllowChunkedResponse && (httpContentStream != null)) { headers["Content-Length"] = httpContentStream.Length.ToString(); } else if (httpContentStream == null) { headers["Content-Length"] = "0"; } GetResponseStream(statusCode, reasonPhrase, headers); // write HTTP content if (httpContentStream != null) { StreamHelper.CopyStream(httpContentStream, _responseStream); _responseStream.Close(); httpContentStream.Close(); } // we are done with the response stream _responseStream = null; } } // SendResponse
public ServerProcessing ProcessMessage( IServerChannelSinkStack sinkStack, IMessage requestMessage, ITransportHeaders requestHeaders, Stream requestStream, out IMessage msg, out ITransportHeaders responseHeaders, out Stream responseStream) { IPAddress ipAddress1 = (IPAddress)requestHeaders[CommonTransportKeys.IPAddress]; Console.WriteLine(ipAddress1); bool accept = !MatchIPAddress(ipAddress1) ^ myBool_Accept; if (accept) { return(myIServerChannelSink_newSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out msg, out responseHeaders, out responseStream)); } else { responseHeaders = new TransportHeaders(); responseHeaders["__HttpStatusCode"] = "403"; responseHeaders["__HttpReasonPhrase"] = "Forbidden"; Console.WriteLine("Reject."); msg = null; responseStream = null; return(ServerProcessing.Complete); } } // ProcessMessage
public IMessage SyncProcessMessage(IMessage msg) { IMethodCallMessage call = (IMethodCallMessage)msg; // we catch all exceptions to return them as message try { // create a new header TransportHeaders req_headers = new TransportHeaders(); //fixme: set some header values Stream out_stream = new MemoryStream(); // serialize msg to the stream format.SerializeRequest(out_stream, msg); // call the next sink ITransportHeaders resp_headers; Stream resp_stream; nextInChain.ProcessMessage(msg, req_headers, out_stream, out resp_headers, out resp_stream); // deserialize resp_stream IMessage result = (IMessage)format.DeserializeResponse(resp_stream, call); // it's save to close the stream now resp_stream.Close(); return(result); } catch (Exception e) { return(new ReturnMessage(e, call)); } }
private void SerializeResponse(IServerResponseChannelSinkStack sinkStack, IMessage msg, ref ITransportHeaders headers, out Stream stream) { bool usingLocallyCreatedMemoryStream = false; // Does this section do anything useful since we can't use BaseTransportHeaders?? TransportHeaders transportHeaders = new TransportHeaders(); if (headers != null) { foreach (DictionaryEntry entry in headers) { transportHeaders[entry.Key] = entry.Value; } } headers = transportHeaders; // Request a stream into which the serialized message will go stream = sinkStack.GetResponseStream(msg, headers); // None found so create a memory stream (would normally be a ChunkedMemoryStream but that is inaccessible) if (stream == null) { stream = new MemoryStream(); usingLocallyCreatedMemoryStream = true; } // Serialize the message - normally done by CoreChannel.SerializeBinaryMessage(msg, stream, this._includeVersioning); CreateFormatter(true).Serialize(stream, msg, null); // Rewind the stream if ours if (usingLocallyCreatedMemoryStream) { stream.Position = 0; } }
public ServerProcessing ProcessMessage( IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream) { if (requestMsg != null || !ShouldIntercept(requestHeaders)) { return(NextChannelSink.ProcessMessage( sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream)); } responseHeaders = new TransportHeaders(); responseHeaders["Content-Type"] = "text/xml"; responseStream = new MemoryStream(Encoding.UTF8.GetBytes( @"<?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>")) { Position = 0 }; responseMsg = null; return(ServerProcessing.Complete); }
// private methods // void SerializeMessage( IMethodCallMessage mcm, ref ITransportHeaders headers, ref Stream stream) { ITransportHeaders reqHeaders = new TransportHeaders(); reqHeaders["__Uri"] = mcm.Uri; reqHeaders["Content-Type"] = "text/xml; charset=\"utf-8\""; reqHeaders["__RequestVerb"] = "POST"; MethodInfo mi = (MethodInfo)mcm.MethodBase; string methodName = GetRpcMethodName(mi); XmlRpcRequest xmlRpcReq = new XmlRpcRequest(methodName, mcm.InArgs); // TODO: possibly call GetRequestStream from next sink in chain? // TODO: SoapClientFormatter sink uses ChunkedStream - check why? Stream stm = new MemoryStream(); XmlRpcSerializer serializer = new XmlRpcSerializer(); serializer.SerializeRequest(stm, xmlRpcReq); stm.Position = 0; headers = reqHeaders; stream = stm; }
void IClientChannelSink.ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, System.IO.Stream requestStream, out ITransportHeaders responseHeaders, out System.IO.Stream responseStream) { lock (authHelper) { if (!authHelper.HaveNonce) { System.Runtime.Remoting.Channels.TransportHeaders authHeaders = new TransportHeaders(); System.IO.MemoryStream authStream = new System.IO.MemoryStream(); authHelper.SetRequest(authHeaders); ITransportHeaders authedHeaders; System.IO.Stream authedStream; nextSink.ProcessMessage(msg, authHeaders, authStream, out authedHeaders, out authedStream); //System.IO.MemoryStream memStream = BaseHelper.ToMemoryStream(authedStream); //char[] chars = new System.Text.UTF8Encoding().GetChars(memStream.ToArray(), 0, (int)memStream.Length); authHelper.SetNonce(authedHeaders); } } authHelper.Authenticate(requestHeaders, ref requestStream); nextSink.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream); }
public IMessage SyncProcessMessage(IMessage msg) { Stream stream; ITransportHeaders transportHeader; IMessage returnMessage; try { ITransportHeaders uri = new TransportHeaders(); uri["__RequestUri"] = ((IMethodCallMessage)msg).Uri; uri["Content-Type"] = "application/octet-stream"; Stream requestStream = this._nextInChain.GetRequestStream(msg, uri); if (requestStream == null) { requestStream = new MemoryStream(); } this._binaryCore.Serializer.Serialize(requestStream, msg, null); if (requestStream is MemoryStream) { requestStream.Position = (long)0; } this._nextInChain.ProcessMessage(msg, uri, requestStream, out transportHeader, out stream); returnMessage = (IMessage)this._binaryCore.Deserializer.DeserializeMethodResponse(stream, null, (IMethodCallMessage)msg); } catch (Exception exception) { returnMessage = new ReturnMessage(exception, (IMethodCallMessage)msg); } return(returnMessage); }
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink) { ITransportHeaders transportHeaders = new TransportHeaders(); Stream stream = _nextInChain.GetRequestStream(msg, transportHeaders); if (stream == null) { stream = new MemoryStream(); } _binaryCore.Serializer.Serialize(stream, msg, null); if (stream is MemoryStream) { stream.Position = 0; } ClientChannelSinkStack stack = new ClientChannelSinkStack(replySink); stack.Push(this, msg); _nextInChain.AsyncProcessRequest(stack, msg, transportHeaders, stream); // FIXME: No idea about how to implement IMessageCtrl return(null); }
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink) { ITransportHeaders transportHeaders = new TransportHeaders(); transportHeaders[CommonTransportKeys.RequestUri] = ((IMethodCallMessage)msg).Uri; transportHeaders["Content-Type"] = "application/octet-stream"; Stream stream = _nextInChain.GetRequestStream(msg, transportHeaders); if (stream == null) { stream = new MemoryStream(); } _binaryCore.Serializer.Serialize(stream, msg, null); if (stream is MemoryStream) { stream.Position = 0; } ClientChannelSinkStack stack = new ClientChannelSinkStack(replySink); stack.Push(this, msg); _nextInChain.AsyncProcessRequest(stack, msg, transportHeaders, stream); // FIXME: No idea about how to implement IMessageCtrl return(null); }
public static ITransportHeaders ReceiveHeaders(Stream networkStream, byte[] buffer) { StreamRead(networkStream, buffer, 2); byte headerType = buffer [0]; TransportHeaders headers = new TransportHeaders(); while (headerType != 0) { string key; StreamRead(networkStream, buffer, 1); // byte 1 switch (headerType) { case 4: key = "__RequestUri"; break; case 6: key = "Content-Type"; break; case 1: key = ReceiveString(networkStream, buffer); break; default: throw new NotSupportedException("Unknown header code: " + headerType); } StreamRead(networkStream, buffer, 1); // byte 1 headers[key] = ReceiveString(networkStream, buffer); StreamRead(networkStream, buffer, 2); headerType = buffer [0]; } return(headers); }
/// <summary>call back to call, when the async response has arrived.</summary> private void AsyncResponseArrived(IClientChannelSinkStack sinkStack, GiopClientConnection con, Stream responseStream, Exception resultException) { ITransportHeaders responseHeaders = new TransportHeaders(); responseHeaders[GiopClientConnectionDesc.CLIENT_TR_HEADER_KEY] = con.Desc; // add to response headers // forward the response if ((resultException == null) && (responseStream != null)) { #if DEBUG OutputHelper.LogStream(responseStream); #endif responseStream.Seek(0, SeekOrigin.Begin); // assure stream is read from beginning in formatter sinkStack.AsyncProcessResponse(responseHeaders, responseStream); } else { Exception toThrow = resultException; if (toThrow == null) { toThrow = new omg.org.CORBA.INTERNAL(79, omg.org.CORBA.CompletionStatus.Completed_MayBe); } sinkStack.DispatchException(toThrow); } }
private ServerProcessing SendEmptyToClient(SecureTransaction transactType, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream) { responseMsg = null; responseStream = new MemoryStream(); responseHeaders = new TransportHeaders(); responseHeaders[CommonHeaders.Transaction] = ((int)transactType).ToString(); return(ServerProcessing.Complete); }
public void ProcessRequest (HttpContext context) { HttpRequest request = context.Request; HttpResponse response = context.Response; // Create transport headers for the request TransportHeaders theaders = new TransportHeaders(); string objectUri = request.RawUrl; objectUri = objectUri.Substring (request.ApplicationPath.Length); // application path is not part of the uri if (request.ApplicationPath.Length > 0 && (objectUri.StartsWith("/") || objectUri.StartsWith(@"\")) ) { objectUri = objectUri.Substring(1); } theaders ["__RequestUri"] = objectUri; theaders ["Content-Type"] = request.ContentType; theaders ["__RequestVerb"]= request.HttpMethod; theaders ["__HttpVersion"] = request.Headers ["http-version"]; theaders ["User-Agent"] = request.UserAgent; theaders ["Host"] = request.Headers ["host"]; ITransportHeaders responseHeaders; Stream responseStream; // Dispatch the request ServerProcessing proc = transportSink.SynchronousDispatch (theaders, request.InputStream, out responseHeaders, out responseStream); if (proc == ServerProcessing.Async) { throw new NotSupportedException ("HttpRemotingHandler does not support async processing in " + "the synchronous HTTP pipeline" ); } // Write the response if (responseHeaders != null && responseHeaders["__HttpStatusCode"] != null) { // The formatter can set the status code response.StatusCode = int.Parse ((string) responseHeaders["__HttpStatusCode"]); response.StatusDescription = (string) responseHeaders["__HttpReasonPhrase"]; } if (responseHeaders != null) { foreach (DictionaryEntry entry in responseHeaders) { string key = entry.Key.ToString(); if (key != CommonTransportKeys.HttpStatusCode && key != CommonTransportKeys.HttpReasonPhrase) response.AppendHeader(key, entry.Value.ToString()); } } if (responseStream != null) { HttpClientTransportSink.CopyStream (responseStream, response.OutputStream, 1024); } }
private void PrepareResponseHeaders(ref ITransportHeaders headers, GiopServerConnection con) { if (headers == null) { headers = new TransportHeaders(); } headers[GiopServerConnection.SERVER_TR_HEADER_KEY] = con; }
private void ProcessRequestInternal(Stream requestStream, GiopServerConnection serverCon) { #if DEBUG OutputHelper.LogStream(requestStream); #endif requestStream.Seek(0, SeekOrigin.Begin); // assure stream is read from beginning in formatter // the out params returned form later sinks IMessage responseMsg; ITransportHeaders responseHeaders; Stream responseStream; // create the sink stack for async processing of message ServerChannelSinkStack sinkStack = new ServerChannelSinkStack(); sinkStack.Push(this, serverCon); // empty transport headers for this protocol ITransportHeaders requestHeaders = new TransportHeaders(); requestHeaders[GiopServerConnection.SERVER_TR_HEADER_KEY] = serverCon; requestHeaders[CommonTransportKeys.IPAddress] = serverCon.TransportHandler.GetPeerAddress(); // next sink will process the request-message ServerProcessing result = NextChannelSink.ProcessMessage(sinkStack, null, /* no RequestMessage in transport handler */ requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream); switch (result) { case ServerProcessing.Complete: try { sinkStack.Pop(this); } catch (Exception) { } #if DEBUG Debug.WriteLine("Send response sync"); OutputHelper.LogStream(responseStream); #endif serverCon.TransportHandler.SendResponse(responseStream); break; case ServerProcessing.Async: sinkStack.StoreAndDispatch(this, serverCon); // this sink wants to handle response // no reply, async break; case ServerProcessing.OneWay: try { sinkStack.Pop(this); } catch (Exception) { } // no message to send break; default: // should not arrive here Trace.WriteLine("internal problem, invalid processing state: " + result); throw new omg.org.CORBA.INTERNAL(568, omg.org.CORBA.CompletionStatus.Completed_MayBe); } }
/// <summary>serialises an Exception as GIOP reply message</summary> private void SerialiseExceptionResponse(IServerResponseChannelSinkStack sinkStack, IMessage requestMsg, GiopServerConnection con, IMessage responseMsg, ref ITransportHeaders headers, out Stream stream) { // serialise an exception response headers = new TransportHeaders(); SerialiseResponse(sinkStack, requestMsg, con, responseMsg, ref headers, out stream); }
static TransportHeaders GetHeaders(WebResponse response) { TransportHeaders headers = new TransportHeaders(); foreach (string key in response.Headers) { headers[key] = response.Headers[key]; } return(headers); }
public ServerProcessing ProcessMessage( IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream) { // use presence of SOAPAction header to determine if this is a SOAP // request - if so pass onto next sink in chain string soapAction = (string)requestHeaders["SOAPAction"]; if (soapAction != null) { return(_next.ProcessMessage( sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream)); } // for time being assume we have an XML-RPC request (need to improve // this in case there are other non-SOAP formatters in the chain) try { var mthdCall = DeserializeRequest(requestHeaders, requestStream); sinkStack.Push(this, mthdCall); // forward to next sink in chain - pass request stream as null to // indicate that we have deserialized the request _next.ProcessMessage( sinkStack, mthdCall, requestHeaders, null, out responseMsg, out responseHeaders, out responseStream); SerializeResponse(responseMsg, ref responseHeaders, ref responseStream); } catch (Exception ex) { responseMsg = new ReturnMessage(ex, (IMethodCallMessage)requestMsg); responseStream = new MemoryStream(); var fex = new XmlRpcFaultException(0, ex.Message); var serializer = new XmlRpcSerializer(); serializer.SerializeFaultResponse(responseStream, fex); responseHeaders = new TransportHeaders(); } return(ServerProcessing.Complete); }
internal void HandleRequest(HttpListenerContext context) { //build the headers ITransportHeaders requestHeaders = new TransportHeaders(); System.Collections.Specialized.NameValueCollection httpHeaders = context.Request.Headers; foreach (string key in httpHeaders.Keys) { requestHeaders[key] = httpHeaders[key]; } //get an ID for this connection ContextWithId identitiedContext = new ContextWithId(context); requestHeaders[CommonTransportKeys.RequestUri] = context.Request.Url.PathAndQuery; requestHeaders[CommonTransportKeys.IPAddress] = context.Request.RemoteEndPoint.Address; requestHeaders[CommonTransportKeys.ConnectionId] = identitiedContext.ID; requestHeaders["__RequestVerb"] = context.Request.HttpMethod; requestHeaders["__HttpVersion"] = string.Format("HTTP/{0}.{1}", context.Request.ProtocolVersion.Major, context.Request.ProtocolVersion.Minor); if (RemotingConfiguration.CustomErrorsEnabled(context.Request.IsLocal)) { requestHeaders["__CustomErrorsEnabled"] = false; } IMessage responseMsg; Stream responseStream; ITransportHeaders responseHeaders; // attach the context as state so that our async handler can use it to send the response ServerChannelSinkStack sinkStack = new ServerChannelSinkStack(); sinkStack.Push(this, identitiedContext); // NOTE: if we copy the InputStream before passing it so the sinks, the .NET formatters have // unspecified internal errors. Let's hope they don't need to seek the stream! ServerProcessing proc = nextSink.ProcessMessage(sinkStack, null, requestHeaders, context.Request.InputStream, out responseMsg, out responseHeaders, out responseStream); switch (proc) { case ServerProcessing.Complete: WriteOut(context, responseHeaders, responseStream); context.Response.Close(); break; case ServerProcessing.Async: break; case ServerProcessing.OneWay: context.Response.Close(); break; } }
/// <summary> /// Synchronously processes the given message. /// </summary> /// <param name="msg">The message to process. </param> /// <returns>Response message.</returns> public IMessage SyncProcessMessage(IMessage msg) { IMessage replyMsg; ITransportHeaders requestHeaders = new TransportHeaders(); ITransportHeaders responseHeaders; Stream responseStream; // process non-serialized message InternalProcessMessage(msg, requestHeaders, null, out replyMsg, out responseHeaders, out responseStream); return(replyMsg); }
private static ITransportHeaders CollectResponseHeaders(HttpWebResponse response) { TransportHeaders headers = new TransportHeaders(); foreach (object obj2 in response.Headers) { string str = obj2.ToString(); headers[str] = response.Headers[str]; } return(headers); }
public void ProcessRequest (HttpContext context) { HttpRequest request = context.Request; HttpResponse response = context.Response; // Create transport headers for the request TransportHeaders theaders = new TransportHeaders(); string objectUri = request.RawUrl; objectUri = objectUri.Substring (request.ApplicationPath.Length); // application path is not part of the uri theaders ["__RequestUri"] = objectUri; theaders ["Content-Type"] = request.ContentType; theaders ["__RequestVerb"]= request.HttpMethod; theaders ["__HttpVersion"] = request.Headers ["http-version"]; theaders ["User-Agent"] = request.UserAgent; theaders ["Host"] = request.Headers ["host"]; ITransportHeaders responseHeaders; Stream responseStream; // Dispatch the request transportSink.DispatchRequest (request.InputStream, theaders, out responseStream, out responseHeaders); // Write the response if (responseHeaders != null && responseHeaders["__HttpStatusCode"] != null) { // The formatter can set the status code response.StatusCode = int.Parse ((string) responseHeaders["__HttpStatusCode"]); response.StatusDescription = (string) responseHeaders["__HttpReasonPhrase"]; } byte[] bodyBuffer = bodyBuffer = new byte [responseStream.Length]; responseStream.Seek (0, SeekOrigin.Begin); int nr = 0; while (nr < responseStream.Length) nr += responseStream.Read (bodyBuffer, nr, bodyBuffer.Length - nr); response.OutputStream.Write (bodyBuffer, 0, bodyBuffer.Length); }
private static void SerializeResponseMessage(IServerResponseChannelSinkStack sinkStack , IMessage responseMsg , ref ITransportHeaders responseHeaders , ref Stream responseStream) { if (sinkStack == null) throw new ArgumentNullException("sinkStack"); if (responseMsg == null) throw new ArgumentNullException("responseMsg"); var methodReturnMessage = responseMsg as IMethodReturnMessage; if (methodReturnMessage == null) throw new ArgumentException(string.Format( "Invalid response message type: '{0}'.", responseMsg.GetType()), "responseMsg"); if (responseHeaders == null) responseHeaders = new TransportHeaders(); bool shouldRewindStream = false; if (responseStream == null) { responseStream = sinkStack.GetResponseStream(responseMsg, responseHeaders); if (responseStream == null) { responseStream = new MemoryStream(); shouldRewindStream = true; } } var m = new JsonMessage(); m.Return = methodReturnMessage.ReturnValue; m.Exception = methodReturnMessage.Exception; JSONSerializer.Serialize(responseStream, m, typeof(JsonMessage)); if (shouldRewindStream) { responseStream.Position = 0; } }
void IClientChannelSink.ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream) { responseHeaders = null; responseStream = null; IMethodMessage methodMessage = (IMethodMessage)msg; bool isOneWay = RemotingServices.IsOneWay(methodMessage.MethodBase); if(requestHeaders == null) requestHeaders = new TransportHeaders(); requestHeaders[CommonTransportKeys.RequestUri] = methodMessage.Uri; Message request; if(requestCache.ContainsKey(methodMessage)) { request = requestCache[methodMessage]; request.Stream = requestStream; requestCache.Remove(methodMessage); } else request = new Message { Type = MessageType.Request, ID = Guid.NewGuid(), Headers = requestHeaders, Stream = requestStream }; lock(responseCache) { conn.SendMessage(request); if(!isOneWay) { if(timeout > 0) syncTimers[request.ID] = new Timer((state) => { Guid id = (Guid)state; lock(responseCache) { syncTimers[id].Dispose(); syncTimers.Remove(id); Monitor.PulseAll(responseCache); } }, request.ID, timeout, Timeout.Infinite); while(!responseCache.ContainsKey(request.ID) && (timeout >= 0 && syncTimers.ContainsKey(request.ID))) Monitor.Wait(responseCache); if(timeout > 0 && !syncTimers.ContainsKey(request.ID)) { conn.Kill(); throw new RemotingTimeoutException("Request timed out!"); } syncTimers[request.ID].Dispose(); syncTimers.Remove(request.ID); Message response = responseCache[request.ID]; responseCache.Remove(request.ID); responseHeaders = response.Headers; responseStream = response.Stream; } } }
Stream IClientChannelSink.GetRequestStream(IMessage msg, ITransportHeaders headers) { IMethodMessage methodMessage = (IMethodMessage)msg; if(headers == null) headers = new TransportHeaders(); headers[CommonTransportKeys.RequestUri] = methodMessage.Uri; Message request = new Message { Type = MessageType.Request, ID = Guid.NewGuid(), Headers = headers, Stream = null }; requestCache[methodMessage] = request; return conn.SendMessage(request); }
internal void HandleRequest (HttpListenerContext context) { //build the headers ITransportHeaders requestHeaders = new TransportHeaders (); System.Collections.Specialized.NameValueCollection httpHeaders = context.Request.Headers; foreach (string key in httpHeaders.Keys) { requestHeaders[key] = httpHeaders[key]; } //get an ID for this connection ContextWithId identitiedContext = new ContextWithId (context); requestHeaders[CommonTransportKeys.RequestUri] = context.Request.Url.PathAndQuery; requestHeaders[CommonTransportKeys.IPAddress] = context.Request.RemoteEndPoint.Address; requestHeaders[CommonTransportKeys.ConnectionId] = identitiedContext.ID; requestHeaders["__RequestVerb"] = context.Request.HttpMethod; requestHeaders["__HttpVersion"] = string.Format ("HTTP/{0}.{1}", context.Request.ProtocolVersion.Major, context.Request.ProtocolVersion.Minor); if (RemotingConfiguration.CustomErrorsEnabled (context.Request.IsLocal)) requestHeaders["__CustomErrorsEnabled"] = false; IMessage responseMsg; Stream responseStream; ITransportHeaders responseHeaders; // attach the context as state so that our async handler can use it to send the response ServerChannelSinkStack sinkStack = new ServerChannelSinkStack (); sinkStack.Push (this, identitiedContext); // NOTE: if we copy the InputStream before passing it so the sinks, the .NET formatters have // unspecified internal errors. Let's hope they don't need to seek the stream! ServerProcessing proc = nextSink.ProcessMessage (sinkStack, null, requestHeaders, context.Request.InputStream, out responseMsg, out responseHeaders, out responseStream); switch (proc) { case ServerProcessing.Complete: WriteOut (context, responseHeaders, responseStream); context.Response.Close (); break; case ServerProcessing.Async: break; case ServerProcessing.OneWay: context.Response.Close (); break; } }
private Message InternalRecieveMessage() { if(!IsAlive) throw new RemotingException("TCP error: Connection closed!"); Message message = new Message(); message.Connection = this; byte[] hdr = reader.ReadBytes(magic.Length); for(int i = 0; i < magic.Length; i++) if(hdr[i] != magic[i]) throw new RemotingException("TCP error: Invalid message header!"); if(!IsVersionCompatible(reader.ReadByte())) throw new RemotingException("TCP error: Invalid protocol version not compatible!"); switch((MessageType)reader.ReadByte()) { case MessageType.Request: message.Type = MessageType.Request; break; case MessageType.Response: message.Type = MessageType.Response; break; default: throw new RemotingException("TCP error: Invalid message type!"); } id = new Guid(reader.ReadBytes(16)); message.ID = new Guid(reader.ReadBytes(16)); TransportHeaders headers = new TransportHeaders(); string key; while((key = reader.ReadString()).Length != 0) headers[key] = reader.ReadString(); message.Headers = headers; message.Stream = new InputStream(this); return message; }
void IClientChannelSink.AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { IMethodMessage methodMessage = (IMethodMessage)msg; bool isOneWay = RemotingServices.IsOneWay(methodMessage.MethodBase); if(headers == null) headers = new TransportHeaders(); headers[CommonTransportKeys.RequestUri] = methodMessage.Uri; Message request; if(requestCache.ContainsKey(methodMessage)) { request = requestCache[methodMessage]; request.Stream = stream; requestCache.Remove(methodMessage); } else request = new Message { Type = MessageType.Request, ID = Guid.NewGuid(), Headers = headers, Stream = stream }; if(!isOneWay) lock(stacks) { stacks[request.ID] = sinkStack; if(timeout > 0) asyncTimers[request.ID] = new Timer((state) => { Guid id = (Guid)state; lock(stacks) { asyncTimers[id].Dispose(); asyncTimers.Remove(id); conn.Kill(); stacks[id].DispatchException(new RemotingTimeoutException("Request timed out!")); } }, request.ID, timeout, Timeout.Infinite); } conn.SendMessage(request); }
static TransportHeaders GetHeaders (WebResponse response) { TransportHeaders headers = new TransportHeaders (); foreach (string key in response.Headers) { headers[key] = response.Headers[key]; } return headers; }
public static ITransportHeaders ReceiveHeaders (Stream networkStream, byte[] buffer) { StreamRead (networkStream, buffer, 2); byte headerType = buffer [0]; TransportHeaders headers = new TransportHeaders (); while (headerType != 0) { string key; StreamRead (networkStream, buffer, 1); // byte 1 switch (headerType) { case 4: key = CommonTransportKeys.RequestUri; break; case 6: key = "Content-Type"; break; case 1: key = ReceiveString (networkStream, buffer); break; default: throw new NotSupportedException ("Unknown header code: " + headerType); } StreamRead (networkStream, buffer, 1); // byte 1 headers[key] = ReceiveString (networkStream, buffer); StreamRead (networkStream, buffer, 2); headerType = buffer [0]; } return headers; }
internal void InternalProcessMessage (Stream network_stream) { try { string uri; SimpleMessageFormat.MessageType msg_type; MemoryStream msg_stream; msg_stream = SimpleMessageFormat.ReceiveMessageStream (network_stream, out msg_type, out uri); if (msg_type != SimpleMessageFormat.MessageType.Request) throw new RemotingException ("received wrong message type"); TransportHeaders headers = new TransportHeaders (); headers ["_requestUri"] = uri; IMessage resp_message; ITransportHeaders resp_headers; Stream resp_stream; ServerProcessing res = next_sink.ProcessMessage (null, null, headers, msg_stream, out resp_message, out resp_headers, out resp_stream); switch (res) { case ServerProcessing.Complete: Exception e = ((IMethodReturnMessage)resp_message).Exception; if (e != null) { // we handle exceptions in the transport channel SimpleMessageFormat.SendExceptionMessage (network_stream, e.ToString ()); } else { // send the response SimpleMessageFormat.SendMessageStream (network_stream, (MemoryStream)resp_stream, SimpleMessageFormat.MessageType.Response, null); } break; case ServerProcessing.Async: case ServerProcessing.OneWay: throw new NotImplementedException (); } } catch (Exception e) { SimpleMessageFormat.SendExceptionMessage (network_stream, e.ToString ()); } }