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();
}
}
}
public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers, Stream responseStream)
{
ClientConnection connection = (ClientConnection)state;
NetworkStream stream = new NetworkStream (connection.Client);
UnixMessageIO.SendMessageStream (stream, responseStream, headers, connection.Buffer);
stream.Flush ();
stream.Close ();
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream requestStream)
{
UnixConnection connection = null;
bool isOneWay = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase);
try
{
if (headers == null)
{
headers = new TransportHeaders();
}
headers ["__RequestUri"] = ((IMethodMessage)msg).Uri;
// Sends the stream using a connection from the pool
// and creates a WorkItem that will wait for the
// response of the server
connection = UnixConnectionPool.GetConnection(_path);
UnixMessageIO.SendMessageStream(connection.Stream, requestStream, headers, connection.Buffer);
connection.Stream.Flush();
if (!isOneWay)
{
sinkStack.Push(this, connection);
ThreadPool.QueueUserWorkItem(new WaitCallback(data =>
{
try {
ReadAsyncUnixMessage(data);
}
catch {}
}), sinkStack);
}
else
{
connection.Release();
}
}
catch
{
if (connection != null)
{
connection.Release();
}
if (!isOneWay)
{
throw;
}
}
}
internal void InternalProcessMessage(ClientConnection connection, Stream stream)
{
ITransportHeaders transportHeader;
ITransportHeaders transportHeader1;
Stream stream1;
IMessage message;
Stream stream2 = UnixMessageIO.ReceiveMessageStream(stream, out transportHeader, connection.Buffer);
ServerChannelSinkStack serverChannelSinkStack = new ServerChannelSinkStack();
serverChannelSinkStack.Push(this, connection);
switch (this.next_sink.ProcessMessage(serverChannelSinkStack, null, transportHeader, stream2, out message, out transportHeader1, out stream1))
{
case ServerProcessing.Complete:
{
UnixMessageIO.SendMessageStream(stream, stream1, transportHeader1, connection.Buffer);
stream.Flush();
break;
}
}
}
internal void InternalProcessMessage(ClientConnection connection, Stream stream)
{
// Reads the headers and the request stream
Stream requestStream;
ITransportHeaders requestHeaders;
requestStream = UnixMessageIO.ReceiveMessageStream(stream, out requestHeaders, connection.Buffer);
/* try {
* PeerCred cred = connection.Client.PeerCredential;
* requestHeaders["__uid"] = cred.UserID;
* } catch (Exception e) {
* Console.WriteLine ("Couldn't get the peer cred: " + e);
* }
*/
// Pushes the connection object together with the sink. This information
// will be used for sending the response in an async call.
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, connection);
ITransportHeaders responseHeaders;
Stream responseStream;
IMessage responseMsg;
ServerProcessing proc = next_sink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
switch (proc)
{
case ServerProcessing.Complete:
UnixMessageIO.SendMessageStream(stream, responseStream, responseHeaders, connection.Buffer);
stream.Flush();
break;
case ServerProcessing.Async:
case ServerProcessing.OneWay:
break;
}
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream)
{
UnixConnection connection = null;
bool flag = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase);
try
{
if (headers == null)
{
headers = new TransportHeaders();
}
headers["__RequestUri"] = ((IMethodMessage)msg).Uri;
connection = UnixConnectionPool.GetConnection(this._path);
UnixMessageIO.SendMessageStream(connection.Stream, requestStream, headers, connection.Buffer);
connection.Stream.Flush();
if (flag)
{
connection.Release();
}
else
{
sinkStack.Push(this, connection);
ThreadPool.QueueUserWorkItem(new WaitCallback(this.ReadAsyncUnixMessage), sinkStack);
}
}
catch
{
if (connection != null)
{
connection.Release();
}
if (!flag)
{
throw;
}
}
}