+2003-11-13 Lluis Sanchez Gual <lluis@ximian.com>
+
+ * HttpChannel.cs: Moved initialization code in SetupChannel to the
+ respective client and server channels. Added implementatoin of the
+ interface IChannelReceiverHook.
+ * HttpRemotingHandler.cs: Implemented.
+ * HttpRemotingHandlerFactory.cs: Implemented.
+ * HttpServer.cs: In general, use Stream instances instead of Socket. It is
+ more reusable in this way. Also improved formatting.
+ * HttpServerChannel.cs: Implemented support for IChannelReceiverHook.
+ Added new method DispatchRequest in HttpServerTransportSink that can
+ be reused by HttpRemotingHandler.
+
2003-11-12 Lluis Sanchez Gual <lluis@ximian.com>
* HttpServerChannel.cs: Removed StartListening call from constructor. It
namespace System.Runtime.Remoting.Channels.Http
{
- public class HttpChannel: IChannelReceiver, IChannelSender, IChannel
+ public class HttpChannel: IChannelReceiver, IChannelSender, IChannel, IChannelReceiverHook
{
private HttpServerChannel serverChannel;
private HttpClientChannel clientChannel;
SetupChannel(Properties,clientSinkProvider,serverSinkProvider);
}
-
- private void SetupChannel(IDictionary Properties,IClientChannelSinkProvider clientSinkProvider,IServerChannelSinkProvider serverSinkProvider)
+ private void SetupChannel (IDictionary properties, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider)
{
- if(Properties == null)
- {
- clientChannel = new HttpClientChannel();
- serverChannel = new HttpServerChannel();
- }
- else if(Properties.Count == 1)
- {
- clientChannel = new HttpClientChannel();
- serverChannel = new HttpServerChannel(Convert.ToInt32(Properties["port"].ToString()));
- }
- else
- {
- IDictionary clientProperties = new Hashtable();
- IDictionary serverProperties = new Hashtable();
- foreach(DictionaryEntry DictEntry in Properties)
- {
- switch(DictEntry.Key.ToString())
- {
- // Properties Supported By : HttpChannel,HttpServerChannel,HttpClientChannel
- case "name":
- channelName = DictEntry.Value.ToString();
- break;
-
- case "priority":
- channelPriority = Convert.ToInt32(DictEntry.Value.ToString());
- break;
-
- // Properties Supported By : HttpChannel , HttpClientChannel ONLY
- case "clientConnectionLimit":
- clientProperties["clientConnectionLimit"] = DictEntry.Value;
- break;
-
- case "proxyName":
- clientProperties["proxyName"] = DictEntry.Value;
- break;
-
- case "proxyPort":
- clientProperties["proxyPort"] = DictEntry.Value;
- break;
-
- case "useDefaultCredentials":
- clientProperties["useDefaultCredentials"] = DictEntry.Value;
- break;
-
- // Properties Supported By : HttpChannel , HttpServerChannel ONLY
- case "bindTo":
- serverProperties["bindTo"] = DictEntry.Value;
- break;
- case "listen":
- serverProperties["listen"] = DictEntry.Value;
- break;
- case "machineName":
- serverProperties["machineName"] = DictEntry.Value;
- break;
- case "port":
- serverProperties["port"] = DictEntry.Value;
- break;
- case "suppressChannelData":
- serverProperties["suppressChannelData"] = DictEntry.Value;
- break;
- case "useIpAddress":
- serverProperties["useIpAddress"] = DictEntry.Value;
- break;
- }
-
- }
- clientChannel = new HttpClientChannel(clientProperties,clientSinkProvider);
- serverChannel = new HttpServerChannel(serverProperties,serverSinkProvider);
- }
+ clientChannel = new HttpClientChannel (properties, clientSinkProvider);
+ serverChannel = new HttpServerChannel (properties, serverSinkProvider);
+
+ object val = properties ["name"];
+ if (val != null) channelName = val as string;
+
+ val = properties ["priority"];
+ if (val != null) channelPriority = Convert.ToInt32 (val);
}
return HttpHelper.Parse(url, out objectURI);
}
-
-
//IChannelSender Members
public IMessageSink CreateMessageSink(String url, Object remoteChannelData, out String objectURI)
{
return clientChannel.CreateMessageSink(url, remoteChannelData, out objectURI);
}
-
//IChannelReciever Members
public String[] GetUrlsForUri(String objectURI)
{
{
serverChannel.StopListening(data);
}
+
public Object ChannelData
{
get { return serverChannel.ChannelData; }
}
+
+ public String ChannelScheme
+ {
+ get { return "http"; }
+ }
+
+ public bool WantsToListen
+ {
+ get { return serverChannel.WantsToListen; }
+ set { serverChannel.WantsToListen = value; }
+ }
+
+ public IServerChannelSink ChannelSinkChain
+ {
+ get { return serverChannel.ChannelSinkChain; }
+ }
+
+ public void AddHookChannelUri (String channelUri)
+ {
+ serverChannel.AddHookChannelUri (channelUri);
+ }
}
}
//
// Authors:
// Martin Willemoes Hansen (mwh@sysrq.dk)
+// Lluis Sanchez Gual (lluis@ximian.com)
//
// (C) 2003 Martin Willemoes Hansen
//
+using System;
+using System.IO;
using System.Web;
namespace System.Runtime.Remoting.Channels.Http
{
- public class HttpRemotingHandler : IHttpHandler
+ public class HttpRemotingHandler : IHttpHandler
{
- [MonoTODO]
- public HttpRemotingHandler()
+ HttpServerTransportSink transportSink;
+
+ public HttpRemotingHandler ()
{
}
+ internal HttpRemotingHandler (HttpServerTransportSink sink)
+ {
+ transportSink = sink;
+ }
+
public bool IsReusable {
- [MonoTODO]
- get { throw new NotImplementedException(); }
+ get { return true; }
}
- [MonoTODO]
public void ProcessRequest (HttpContext context)
{
- throw new NotImplementedException();
- }
+ HttpRequest request = context.Request;
+ HttpResponse response = context.Response;
+
+ // Create transport headers for the request
+
+ TransportHeaders theaders = new TransportHeaders();
- [MonoTODO]
- ~HttpRemotingHandler()
- {
+ 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);
}
}
}
//
// Authors:
// Martin Willemoes Hansen (mwh@sysrq.dk)
+// Lluis Sanchez Gual (lluis@ximian.com)
//
// (C) 2003 Martin Willemoes Hansen
//
using System.Web;
+using System.IO;
+using System.Runtime.Remoting;
+using System.Runtime.Remoting.Channels;
namespace System.Runtime.Remoting.Channels.Http
{
public class HttpRemotingHandlerFactory : IHttpHandlerFactory
{
- [MonoTODO]
+ static bool webConfigLoaded = false;
+ static HttpServerTransportSink transportSink = null;
+
public HttpRemotingHandlerFactory ()
{
}
- [MonoTODO]
public IHttpHandler GetHandler (HttpContext context,
string verb,
string url,
string filePath)
{
- throw new NotImplementedException();
+ if (!webConfigLoaded)
+ ConfigureHttpChannel (context);
+
+ return new HttpRemotingHandler (transportSink);
}
-
- [MonoTODO]
- public void ReleaseHandler (IHttpHandler handler)
+
+ public void ConfigureHttpChannel (HttpContext context)
{
- throw new NotImplementedException();
+ lock (GetType())
+ {
+ if (webConfigLoaded) return;
+
+ // Read the configuration file
+
+ string webconfig = Path.Combine (context.Request.PhysicalApplicationPath, "web.config");
+ RemotingConfiguration.Configure (webconfig);
+
+ // Look for a channel that wants to receive http request
+
+ foreach (IChannel channel in ChannelServices.RegisteredChannels)
+ {
+ IChannelReceiverHook chook = channel as IChannelReceiverHook;
+ if (chook == null) continue;
+
+ if (chook.ChannelScheme != "http")
+ throw new RemotingException ("Only http channels are allowed when hosting remoting objects in a web server");
+
+ if (!chook.WantsToListen) continue;
+
+ // Register the uri for the channel. The channel uri includes the scheme, the
+ // host and the application path
+
+ string channelUrl = context.Request.Url.GetLeftPart(UriPartial.Authority);
+ channelUrl += context.Request.ApplicationPath;
+ chook.AddHookChannelUri (channelUrl);
+
+ transportSink = new HttpServerTransportSink (chook.ChannelSinkChain);
+ }
+ webConfigLoaded = true;
+ }
}
- [MonoTODO]
- ~HttpRemotingHandlerFactory()
+ public void ReleaseHandler (IHttpHandler handler)
{
}
}
namespace System.Runtime.Remoting.Channels.Http
{
- class RequestArguments
+ internal class RequestArguments
{
- public RequestArguments(Socket SOCKET, HttpServerTransportSink SNK)
+ public RequestArguments (Socket socket, HttpServerTransportSink sink)
{
- socket = SOCKET;
- snk = SNK;
+ NetworkStream ns = new NetworkStream (socket);
+ InputStream = ns;
+ OutputStream = ns;
+ Sink = sink;
}
- public Socket socket;
- public HttpServerTransportSink snk;
+
+ public RequestArguments (Stream inputStream, Stream outputStream, HttpServerTransportSink sink)
+ {
+ InputStream = inputStream;
+ OutputStream = outputStream;
+ Sink = sink;
+ }
+ public Stream InputStream;
+ public Stream OutputStream;
+ public HttpServerTransportSink Sink;
}
internal sealed class HttpServer
}
- public static void ProcessRequest(object Object)
+ public static void ProcessRequest (object reqInfo)
{
- if(Object as RequestArguments == null)
+ if(reqInfo as RequestArguments == null)
return;
- Socket socket;
- HttpServerTransportSink snk;
-
- RequestArguments reqArg = (RequestArguments)Object;
+ RequestArguments reqArg = (RequestArguments)reqInfo;
- socket = reqArg.socket;
- snk = reqArg.snk;
-
- if(!socket.Connected)
- return;
-
//Step (1) Start Reciceve the header
- ArrayList Headers = RecieveHeader(socket);
+ ArrayList Headers = RecieveHeader (reqArg);
//Step (2) Start Parse the header
IDictionary HeaderFields = new Hashtable();
IDictionary CustomHeaders = new Hashtable();
- if(!ParseHeader(socket,Headers,HeaderFields,CustomHeaders))
+ if (!ParseHeader (reqArg, Headers, HeaderFields, CustomHeaders))
return;
//Step (3)
- if(!CheckRequest(socket,HeaderFields,CustomHeaders))
+ if (!CheckRequest (reqArg, HeaderFields, CustomHeaders))
return;
//Step (4) Recieve the entity body
byte [] buffer =new byte[(int)HeaderFields["content-length"]];
- if(!RecieveEntityBody(socket,buffer))
+ if (!RecieveEntityBody (reqArg, buffer))
return ;
//Step (5)
- if(! SendRequestForChannel(socket,snk,HeaderFields,CustomHeaders,buffer))
- return ;
+ SendRequestForChannel (reqArg, HeaderFields, CustomHeaders, buffer);
}
- private static ArrayList RecieveHeader(Socket socket)
+ private static ArrayList RecieveHeader (RequestArguments reqArg)
{
bool bLastLine = false;
bool bEndOfLine = false;
byte[] buffer = new byte[1024];
ArrayList Headers = new ArrayList();
+
+ Stream ist = reqArg.InputStream;
int index =0;
- while(!bLastLine)
+ while (!bLastLine)
{
//recieve line by line
index = 0;
bEndOfLine = false;
//Step (1) is it an empty line?
- socket.Receive(buffer,index,1,SocketFlags.None);
+ ist.Read (buffer, index, 1);
if(buffer[index++]==13)
{
- socket.Receive(buffer,index,1,SocketFlags.None);
+ ist.Read (buffer, index, 1);
bLastLine=true;
bEndOfLine = true;
}
//Step (2) recieve line bytes
- while(!bEndOfLine)
+ while (!bEndOfLine)
{
- socket.Receive(buffer,index,1,SocketFlags.None);
+ ist.Read (buffer, index, 1);
- if(buffer[index++]==13)
+ if(buffer [index++]==13)
{
bEndOfLine = true;
- socket.Receive(buffer,index,1,SocketFlags.None);
+ ist.Read (buffer,index,1);
}
-
}
//Step (3) convert bytes to a string
- if(bLastLine)
+ if (bLastLine)
continue;
- Headers.Add( Encoding.ASCII.GetString(buffer,0,index));
+
+ Headers.Add (Encoding.ASCII.GetString (buffer,0,index));
}//end while loop
return Headers;
}
- private static bool ParseHeader(Socket socket, ArrayList Headers,IDictionary HeaderFields, IDictionary CustomHeaders)
+ private static bool ParseHeader (RequestArguments reqArg, ArrayList Headers, IDictionary HeaderFields, IDictionary CustomHeaders)
{
-
- for(int i=0;i<Headers.Count;i++)
+ for (int i=0;i<Headers.Count;i++)
{
-
- if( ReqMessageParser.ParseHeaderField((string)Headers[i],HeaderFields))
+ if (ReqMessageParser.ParseHeaderField ((string)Headers[i],HeaderFields))
continue;
- if(!ReqMessageParser.IsCustomHeader((string)Headers[i],CustomHeaders ) )
+
+ if (!ReqMessageParser.IsCustomHeader((string)Headers[i],CustomHeaders ) )
{
- SendResponse(socket,400,null,null);
+ SendResponse (reqArg, 400, null, null);
return false;
}
-
}
return true;
}
-
-
- private static bool CheckRequest(Socket socket,IDictionary HeaderFields , IDictionary CustomHeaders)
+ private static bool CheckRequest (RequestArguments reqArg, IDictionary HeaderFields, IDictionary CustomHeaders)
{
string temp;
//Check the method
temp = HeaderFields["method"].ToString();
- if(temp!="POST")
+ if (temp!="POST")
{
- SendResponse(socket,501,null,null);
+ SendResponse (reqArg, 501, null, null);
return false;
}
if (HeaderFields["expect"].ToString() == "100-continue")
- SendResponse(socket,100,null,null);
+ SendResponse (reqArg, 100, null, null);
//Check for the content-length field
- if(HeaderFields["content-length"]==null)
+ if (HeaderFields["content-length"]==null)
{
- SendResponse(socket,411,null,null);
+ SendResponse (reqArg, 411, null, null);
return false;
}
return true;
}
- private static bool RecieveEntityBody(Socket socket, byte[] buffer)
+ private static bool RecieveEntityBody (RequestArguments reqArg, byte[] buffer)
{
try
{
int nr = 0;
while (nr < buffer.Length)
- nr += socket.Receive (buffer, nr, buffer.Length - nr,SocketFlags.None);
+ nr += reqArg.InputStream.Read (buffer, nr, buffer.Length - nr);
}
- catch(SocketException e)
+ catch (SocketException e)
{
switch(e.ErrorCode)
{
case 10060 : //TimeOut
- SendResponse(socket,408,null,null);
+ SendResponse (reqArg, 408, null, null);
break;
default :
//<Exception>
return true;
}
- private static bool SendRequestForChannel(Socket socket ,HttpServerTransportSink snk ,IDictionary HeaderFields , IDictionary CustomHeaders, byte[]buffer)
+ private static bool SendRequestForChannel (RequestArguments reqArg, IDictionary HeaderFields, IDictionary CustomHeaders, byte[] buffer)
{
TransportHeaders THeaders = new TransportHeaders();
//THeaders["__ConnectionId"] = Int64.Parse("1");
//THeaders["__IPAddress"]= ((IPEndPoint)socket.RemoteEndPoint).Address;
- THeaders["__RequestUri"] =FixURI((string)HeaderFields["request-url"]);
- THeaders["Content-Type"]=HeaderFields["content-type"];
- THeaders["__RequestVerb"]=HeaderFields["method"];
+ THeaders["__RequestUri"] = FixURI((string)HeaderFields["request-url"]);
+ THeaders["Content-Type"]= HeaderFields["content-type"];
+ THeaders["__RequestVerb"]= HeaderFields["method"];
THeaders["__HttpVersion"] = HeaderFields["http-version"];
THeaders["User-Agent"] = HeaderFields["user-agent"];
THeaders["Host"] = HeaderFields["host"];
THeaders[DictEntry.Key.ToString()] = DictEntry.Value.ToString();
}
- snk.ServiceRequest(socket,stream,THeaders);
+ reqArg.Sink.ServiceRequest (reqArg, stream, THeaders);
return true;
}
}
- public static bool SendResponse(Socket socket, int HttpStatusCode, ITransportHeaders headers , Stream responseStream)
+ public static bool SendResponse (RequestArguments reqArg, int HttpStatusCode, ITransportHeaders headers , Stream responseStream)
{
byte [] headersBuffer = null;
byte [] entityBuffer = null;
ResponseStr.Append("\r\n");
- headersBuffer = Encoding.ASCII.GetBytes(ResponseStr.ToString());
+ headersBuffer = Encoding.ASCII.GetBytes (ResponseStr.ToString());
try
{
-
//send headersBuffer
- if(socket.Send(headersBuffer,0,headersBuffer.Length,SocketFlags.None) != headersBuffer.Length)
- return false;
-
-
-
- if(entityBuffer != null)
- if(socket.Send(entityBuffer,0,entityBuffer.Length,SocketFlags.None) != entityBuffer.Length)
- return false;
+ reqArg.OutputStream.Write (headersBuffer, 0, headersBuffer.Length);
+ if (entityBuffer != null)
+ reqArg.OutputStream.Write (entityBuffer, 0, entityBuffer.Length);
}
catch (SocketException )
{
//may be its the client's fault so just return with false
return false;
}
-
- return true;
+
+ return true;
}
public static bool SendResponse(Socket socket , int HttpStatusCode ,string ReasonPhrase, ITransportHeaders headers , Stream responseStream )
return true;
}
- private static string GetReasonPhrase(int HttpStatusCode)
+ internal static string GetReasonPhrase(int HttpStatusCode)
{
switch (HttpStatusCode)
{
- public ReqMessageParser()
+ public ReqMessageParser ()
{
-
-
}
- public static bool ParseHeaderField(string buffer,IDictionary headers)
+ public static bool ParseHeaderField(string buffer,IDictionary headers)
{
try
private IServerChannelSinkProvider _sinkProvider = null;
private HttpServerTransportSink _transportSink = null;
- private IServerChannelSink _sinkChain = null;
private bool _wantsToListen = true;
// to start listening, that will get set here.
private AutoResetEvent _waitForStartListening = new AutoResetEvent(false);
-
-
public HttpServerChannel() : base()
{
SetupChannel(null);
-
}
public HttpServerChannel(int port) : base()
{
_port = port;
SetupChannel(null);
-
}
-
public HttpServerChannel(String name, int port) : base()
{
_channelName = name;
_port = port;
+ _wantsToListen = false;
SetupChannel(null);
-
}
-
public HttpServerChannel(String name, int port, IServerChannelSinkProvider sinkProvider) : base()
{
//enter the name later ya gameeel
_port = port;
+ _wantsToListen = false;
SetupChannel(sinkProvider);
-
}
-
-
- public HttpServerChannel(IDictionary properties, IServerChannelSinkProvider sinkProvider) : base()
- {
-
- if(properties != null)
+ public HttpServerChannel (IDictionary properties, IServerChannelSinkProvider sinkProvider) : base()
+ {
+ if (properties != null)
foreach(DictionaryEntry Dict in properties)
{
switch((string)Dict.Key)
_channelName = (string)Dict.Value;
break;
case "bindTo":
- _bindToAddr = IPAddress.Parse((string)Dict.Value);
+ _bindToAddr = IPAddress.Parse ((string)Dict.Value);
break;
case "listen":
- _wantsToListen = Boolean.Parse((string)Dict.Value);;
+ _wantsToListen = Convert.ToBoolean (Dict.Value);;
break;
case "machineName":
_machineName = (string)Dict.Value;
break;
case "port":
- _port =(int) Dict.Value;
+ _wantsToListen = false;
+ _port = Convert.ToInt32 (Dict.Value);
break;
case "suppressChannelData":
- _bSuppressChannelData = Boolean.Parse((string)Dict.Value);
+ _bSuppressChannelData = Convert.ToBoolean (Dict.Value);
break;
case "useIpAddress":
- _bUseIpAddress = Boolean.Parse((string)Dict.Value);
+ _bUseIpAddress = Convert.ToBoolean (Dict.Value);
break;
}
}
- SetupChannel(sinkProvider);
-
+ SetupChannel (sinkProvider);
}
- void SetupChannel(IServerChannelSinkProvider sinkProvider)
+ void SetupChannel (IServerChannelSinkProvider sinkProvider)
{
-
SetupMachineName();
_sinkProvider = sinkProvider;
-
String[] urls = { this.GetChannelUri() };
// needed for CAOs
_channelData = new ChannelDataStore(urls);
-
if(_sinkProvider == null)
_sinkProvider = new SoapServerFormatterSinkProvider();
IServerChannelSink snk =
ChannelServices.CreateServerChannelSinkChain(_sinkProvider,this);
- _transportSink = new HttpServerTransportSink(snk);
+ _transportSink = new HttpServerTransportSink (snk);
}
public void Listen()
while(true)
{
Socket socket = _tcpListener.AcceptSocket();
- RequestArguments reqArg = new RequestArguments(socket,_transportSink);
+ RequestArguments reqArg = new RequestArguments (socket, _transportSink);
ThreadPool.QueueUserWorkItem (new WaitCallback (HttpServer.ProcessRequest), reqArg);
}
}
- public void StartListening(Object data)
+ public void StartListening (Object data)
{
- if(_port == 0) return; // TODO: take unused port
+ if(_port <= 0) return; // TODO: take unused port
- _tcpListener = new TcpListener( _bindToAddr,_port);
+ _tcpListener = new TcpListener (_bindToAddr, _port);
if(!_bListening)
_tcpListener.Start();
}
_bListening = false;
-
}
return "http://" + _machineName + ":" + _port;
}
}
-
public virtual String[] GetUrlsForUri(String objectUri)
{
}
}
- public String ChannelScheme { get { return "http"; } }
-
+ public String ChannelScheme
+ {
+ get { return "http"; }
+ }
public bool WantsToListen
{
get { return _wantsToListen; }
set { _wantsToListen = value; }
}
-
- public IServerChannelSink ChannelSinkChain { get { return _sinkChain; } }
-
+ public IServerChannelSink ChannelSinkChain
+ {
+ get { return _transportSink.NextChannelSink; }
+ }
- public void AddHookChannelUri(String channelUri)
+ public void AddHookChannelUri (String channelUri)
{
- }
+ string [] uris = _channelData.ChannelUris;
+
+ string [] newUris = new string[1] { channelUri };
+ _channelData.ChannelUris = newUris;
+ _wantsToListen = false;
+ }
public Object this[Object key]
{
break;
}
}
- }
-
+ }
public ICollection Keys
{
}
}
-
-
} // HttpServerChannel
-
-
internal class HttpServerTransportSink : IServerChannelSink
{
private IServerChannelSink _nextSink;
- public HttpServerTransportSink(IServerChannelSink nextSink)
+ public HttpServerTransportSink (IServerChannelSink nextSink)
{
_nextSink = nextSink;
} // IServerChannelSink
-
-
-
- internal void ServiceRequest(Socket socket , Stream requestStream , ITransportHeaders headers)
- {
- ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
- sinkStack.Push(this, socket);
- IMessage responseMessage;
+ internal void ServiceRequest (RequestArguments reqArg, Stream requestStream, ITransportHeaders headers)
+ {
ITransportHeaders responseHeaders;
Stream responseStream;
- ServerProcessing processing = ServerProcessing.Complete;
+ ServerProcessing processing;
try
{
- processing =
- _nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
- out responseMessage,
- out responseHeaders, out responseStream);
+ processing = DispatchRequest (requestStream, headers, out responseStream, out responseHeaders);
switch (processing)
{
case ServerProcessing.Complete:
- sinkStack.Pop(this);
- if(!HttpServer.SendResponse(socket,200,responseHeaders,responseStream))
+ if (!HttpServer.SendResponse (reqArg, 200, responseHeaders, responseStream))
{
//ooops couldnot send response !!!!!! and error occured
}
break;
case ServerProcessing.OneWay:
- if(!HttpServer.SendResponse(socket,200,null,null))
+ if (!HttpServer.SendResponse (reqArg, 200, null, null))
{
//ooops couldnot send response !!!!!! and error occured
}
break;
}
}
- catch(Exception )
+ catch (Exception ex)
{
+ Console.WriteLine (ex);
}
}
+ internal ServerProcessing DispatchRequest (Stream requestStream, ITransportHeaders headers, out Stream responseStream, out ITransportHeaders responseHeaders)
+ {
+ ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
+
+ IMessage responseMessage;
+ return _nextSink.ProcessMessage (sinkStack, null, headers, requestStream,
+ out responseMessage,
+ out responseHeaders, out responseStream);
+ }
+
//
// IServerChannelSink implementation
//
- public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
+ public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders,
} // ProcessMessage
- public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, Object state,
+ public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
- Socket socket = (Socket) state;
-
- if(!HttpServer.SendResponse(socket,200,headers,stream))
- {
- //Ooops could not send response!!!!!!!!!1
- }
- } // AsyncProcessResponse
+ // Never called
+ throw new NotSupportedException ();
+ }
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, Object state,
projects / mono.git / commitdiff