public ServerProcessing ProcessMessage(
IServerChannelSinkStack stack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream
)
{
stack.Push(this, null);
#region Check request stream header hash
string hash = requestHeaders[HashHelper.C_HASH_ITEM] as String;
//Debug.WriteLine("Server Side : request stream hash is " + hash);
bool check = HashHelper.CheckHash(ref requestStream, hash);
if (!check)
{
throw new Exception("Server Side : request stream header checksum error");
}
#endregion
ServerProcessing result = _nextSink.ProcessMessage(stack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
#region Add hash to response stream heaer
hash = HashHelper.GetHash(ref responseStream);
responseHeaders[HashHelper.C_HASH_ITEM] = hash;
//Debug.WriteLine("Server Side : response stream hash is " + hash);
#endregion
return(result);
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
// uncompressing the request
requestStream =
CompressionHelper.getUncompressedStreamCopy(requestStream);
// pushing onto stack and forwarding the call
sinkStack.Push(this, null);
ServerProcessing srvProc = _nextSink.ProcessMessage(sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
// compressing the response
responseStream =
CompressionHelper.getCompressedStreamCopy(responseStream);
// returning status information
return(srvProc);
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (NextChannelSink != null)
{
IPAddress ip =
requestHeaders[CommonTransportKeys.IPAddress] as IPAddress;
CallContext.SetData("ClientIPAddress", ip);
ServerProcessing spres = NextChannelSink.ProcessMessage(
sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
return(spres);
}
else
{
responseMsg = null;
responseHeaders = null;
responseStream = null;
return(new ServerProcessing());
}
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMessage,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMessage,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
// Hand off to the next sink for processing.
sinkStack.Push(this, null);
ServerProcessing status = nextSink.ProcessMessage(
sinkStack, requestMessage, requestHeaders, requestStream,
out responseMessage, out responseHeaders, out responseStream
);
// Print the response message properties.
Console.WriteLine("---- Message from the server ----");
IDictionary dictionary = responseMessage.Properties;
foreach (Object key in dictionary.Keys)
{
Console.WriteLine("{0} = {1}", key, dictionary[key]);
}
Console.WriteLine("---------------------------------");
return(status);
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream,
out IMessage msg, out ITransportHeaders responseHeaders,
out Stream responseStream)
{
sinkStack.Push(this, null);
ServerProcessing processing =
nextServerSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out msg,
out responseHeaders, out responseStream);
switch (processing)
{
case ServerProcessing.Complete:
{
sinkStack.Pop(this);
break;
}
case ServerProcessing.OneWay:
{
sinkStack.Pop(this);
break;
}
case ServerProcessing.Async:
{
sinkStack.Store(this, null);
break;
}
}
return(processing);
}
ServerProcessing IServerChannelSink.ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
long startTicks = TimeUtil.NOW();
string uri = null;
long inputLength = 0L;
if (requestStream != null && requestHeaders != null)
{
uri = requestHeaders["__RequestUri"].ToString();
}
ServerProcessing process = this.nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
if (null != responseMsg)
{
object methodName = responseMsg.Properties["__MethodName"];
if (uri != null && methodName != null)
{
string cmdName = uri.ToString() + methodName.ToString();
CmdMonitor.RecordCmdDetail(cmdName, TimeUtil.NOW() - startTicks, inputLength, responseStream.Length, TCPProcessCmdResults.RESULT_OK);
}
else
{
LogManager.WriteExceptionUseCache(string.Format("IServerChannelSink.ProcessMessage#uri={0},methodName={1}", uri, methodName));
}
}
else
{
LogManager.WriteExceptionUseCache(string.Format("IServerChannelSink.ProcessMessage#uri={0},responseMsg=null", uri));
}
return(process);
}
} // IServerChannelSink
internal void ServiceRequest(Object state)
{
HttpServerSocketHandler streamManager = (HttpServerSocketHandler)state;
ITransportHeaders headers = streamManager.ReadHeaders();
Stream requestStream = streamManager.GetRequestStream();
// process request
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, streamManager);
IMessage responseMessage;
ITransportHeaders responseHeaders;
Stream responseStream;
ServerProcessing processing =
_nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
sinkStack.Pop(this);
streamManager.SendResponse(responseStream, "200", "OK", responseHeaders);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// Just send back a 200 OK
streamManager.SendResponse(null, "202", "Accepted", responseHeaders);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
sinkStack.StoreAndDispatch(this, streamManager);
break;
} // case ServerProcessing.Async
} // switch (processing)
// async processing will take care if handling this later
if (processing != ServerProcessing.Async)
{
if (streamManager.CanServiceAnotherRequest())
{
streamManager.BeginReadMessage();
}
else
{
streamManager.Close();
}
}
} // ServiceRequest
public void HandleIncomingMessage(ChannelMessage msg)
{
ITransportHeaders responseHeaders;
Stream responseStream;
IMessage responseMsg;
ServerChannelSinkStack stack = new ServerChannelSinkStack();
stack.Push(this, msg);
ServerProcessing proc = _nextSink.ProcessMessage(stack, null, msg.Headers, msg.Body, out responseMsg, out responseHeaders, out responseStream);
// check the return value.
switch (proc)
{
// this message has been handled synchronously
case ServerProcessing.Complete:
// send a response message
ChannelMessage reply = new ChannelMessage(msg.From, msg.ID, responseHeaders, responseStream);
ConnectionManager.SendMessage(reply);
break;
// this message has been handled asynchronously
case ServerProcessing.Async:
// nothing needs to be done yet
break;
// it's been a one way message
case ServerProcessing.OneWay:
// nothing needs to be done yet
break;
}
}
public System.Runtime.Remoting.Channels.ServerProcessing ProcessMessage(System.Runtime.Remoting.Channels.IServerChannelSinkStack sinkStack, System.Runtime.Remoting.Messaging.IMessage requestMsg, System.Runtime.Remoting.Channels.ITransportHeaders requestHeaders, System.IO.Stream requestStream, out System.Runtime.Remoting.Messaging.IMessage responseMsg, out System.Runtime.Remoting.Channels.ITransportHeaders responseHeaders, out System.IO.Stream responseStream)
{
if (_next != null)
{
try
{
Thread.Sleep(1);
IPAddress ip = requestHeaders[CommonTransportKeys.IPAddress] as IPAddress;
CallContext.SetData("ClientIPAddress", ip);
ServerProcessing spres = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
return(spres);
}
catch
{
responseMsg = null;
responseHeaders = null;
responseStream = null;
return(new ServerProcessing());
}
}
else
{
responseMsg = null;
responseHeaders = null;
responseStream = null;
return(new ServerProcessing());
}
}
/// <summary></summary>
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (NextChannelSink != null)
{
SetClientIpAddressDataHelper(requestHeaders);
ServerProcessing spres = NextChannelSink.ProcessMessage(
sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
return(spres);
}
responseMsg = null;
responseHeaders = null;
responseStream = null;
return(new ServerProcessing());
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg,
out ITransportHeaders responseHeaders, out Stream responseStream)
{
// проверяем, задано ли имя серверного хоста или его адрес
_serverHostNameOrIp = requestHeaders["serverHostNameOrIp"];
if (_serverHostNameOrIp != null)
{
// помещаем его в контекст вызова
CallContext.SetData("serverHostNameOrIp", _serverHostNameOrIp);
// протоколируем
if (_eventLink != null)
{
_eventLink.Post(_eventSource, string.Format("Имя или IP-адрес сервера ЗАДАНО: [{0}]",
_serverHostNameOrIp));
}
}
else
{
// очишаем значение, оставшееся от предыдущих вызовов
CallContext.FreeNamedDataSlot("serverHostNameOrIp");
// протоколируем
if (_eventLink != null)
{
_eventLink.Post(_eventSource, EventType.Warning, "Имя или IP-адрес сервера НЕ задано");
}
}
// перенаправляем обработку сообщения следующему приемнику в цепи
sinkStack.Push(this, null);
ServerProcessing status = _nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders,
requestStream, out responseMsg, out responseHeaders, out responseStream);
return(status);
}
public ServerProcessing ProcessEncryptedMessage(Guid transactID, IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
ClientConnectionInfo cci;
lock (_connections.SyncRoot)
{
cci = (ClientConnectionInfo)_connections[transactID.ToString()];
}
if (cci == null)
{
throw new SecureRemotingException("No connection information about client.");
}
cci.UpdateLastUsed();
Stream decryptedStream = CryptoHelper.GetDecryptedStream(requestStream, cci.Provider);
requestStream.Close();
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, decryptedStream, out responseMsg, out responseHeaders, out responseStream);
responseHeaders[CommonHeaders.Transaction] = ((int)SecureTransaction.SendingEncryptedResult).ToString();
Stream encryptedStream = CryptoHelper.GetEncryptedStream(responseStream, cci.Provider);
responseStream.Close(); // close the plaintext stream now that we're done with it
responseStream = encryptedStream;
return(processingResult);
}
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);
}
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
bool isEncrypted = false;
//checking the headers
if (requestHeaders["X-Encrypt"] != null &&
requestHeaders["X-Encrypt"].Equals("yes"))
{
isEncrypted = true;
byte[] IV = Convert.FromBase64String(
(String)requestHeaders["X-EncryptIV"]);
// decrypt the request
requestStream = EncryptionHelper.ProcessInboundStream(
requestStream,
_encryptionAlgorithm,
_encryptionKey,
IV);
}
// pushing onto stack and forwarding the call,
// the flag "isEncrypted" will be used as state
sinkStack.Push(this, isEncrypted);
ServerProcessing srvProc = _nextSink.ProcessMessage(sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
if (isEncrypted)
{
// encrypting the response if necessary
byte[] IV;
responseStream = EncryptionHelper.ProcessOutboundStream(responseStream,
_encryptionAlgorithm, _encryptionKey, out IV);
responseHeaders["X-Encrypt"] = "yes";
responseHeaders["X-EncryptIV"] = Convert.ToBase64String(IV);
}
// returning status information
return(srvProc);
}
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;
}
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg,
out ITransportHeaders responseHeaders, out Stream responseStream)
{
sinkStack.Push(this, null);
ServerProcessing res = _nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders,
requestStream, out responseMsg, out responseHeaders, out responseStream);
responseHeaders["X-Cache"] = "60";
return(res);
}
/// <summary>
/// Creates an empty response message.
/// </summary>
/// <param name="sinkStack">The sink stack.</param>
/// <param name="requestMsg">Request message.</param>
/// <param name="requestHeaders">Request transport headers.</param>
/// <param name="requestStream">Request stream.</param>
/// <param name="transactionStage">Current secure transaction stage.</param>
/// <param name="responseMsg">Response message.</param>
/// <param name="responseHeaders">Response transport headers.</param>
/// <param name="responseStream">Response stream.</param>
/// <returns></returns>
private ServerProcessing SendEmptyToClient(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, SecureTransactionStage transactionStage, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
responseMsg = null;
requestStream = new MemoryStream();
responseStream = new MemoryStream();
responseHeaders = new TransportHeaders();
responseHeaders[CommonHeaderNames.SECURE_TRANSACTION_STATE] = ((int)transactionStage).ToString();
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
return processingResult;
}
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());
}
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream
)
{
if (bEnabled2)
{
Console.WriteLine("----------Request Headers-----------");
// <Snippet2>
Console.WriteLine(CommonTransportKeys.IPAddress + ":" +
requestHeaders[CommonTransportKeys.IPAddress]);
// </Snippet2>
// <Snippet3>
Console.WriteLine(CommonTransportKeys.ConnectionId + ":" +
requestHeaders[CommonTransportKeys.ConnectionId]);
// </Snippet3>
// <Snippet4>
Console.WriteLine(CommonTransportKeys.RequestUri + ":" +
requestHeaders[CommonTransportKeys.RequestUri]);
// </Snippet4>
}
sinkStack.Push(this, null);
ServerProcessing processing =
nextSink2.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg,
out responseHeaders, out responseStream);
switch (processing)
{
case ServerProcessing.Complete:
{
sinkStack.Pop(this);
break;
}
case ServerProcessing.OneWay:
{
sinkStack.Pop(this);
break;
}
case ServerProcessing.Async:
{
sinkStack.Store(this, null);
break;
}
}
return(processing);
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
if (requestMsg != null)
{
return(_next.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream));
}
try
{
IPAddress IPAddr = (IPAddress)requestHeaders[CommonTransportKeys.IPAddress];
//===================================
//Console.WriteLine(IPAddr.ToString());
//====================================
CallContext.SetData("ClientIP", IPAddr);
//IPHostEntry hostInfo = Dns.Resolve("");
//string _hs = requestHeaders[CommonTransportKeys.RequestUri].ToString() ;
//CallContext.SetData("ClientHost",_hs);
}
catch (Exception ex)
{
string errmsg = ex.Message;
}
requestStream = CompressSinkHelper.DecompressStream(requestHeaders, requestStream);
sinkStack.Push(this, null);
ServerProcessing processing = _next.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
// 这样写是否有效还未验证, ???
// if (CompressSinkHelper.IsClientSupportCompress(requestHeaders))
// CompressSinkHelper.SetClientSupportCompressFlag(responseHeaders);
switch (processing)
{
case ServerProcessing.Complete:
sinkStack.Pop(this);
if (CompressSinkHelper.IsClientSupportCompress(requestHeaders))
{
responseStream = CompressSinkHelper.CompressStream(responseHeaders, responseStream);
}
break;
case ServerProcessing.OneWay:
sinkStack.Pop(this);
break;
case ServerProcessing.Async:
sinkStack.Store(this, null);
break;
}
return(processing);
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
bool clientCompressed = false;
// decompress the shits
Stream decompressedStream;
if (object.Equals(requestHeaders[CompressionHelper.CompressKey], CompressionHelper.CompressedFlag))
{
//Debug.WriteLine("client compressed");
clientCompressed = true;
decompressedStream = CompressionHelper.DecompressStream(requestStream);
// close the request stream
requestStream.Close();
}
else
{
if (object.Equals(requestHeaders[CompressionHelper.CompressKey], CompressionHelper.CompressRequest))
{
//Debug.WriteLine("client requesting compress");
clientCompressed = true;
}
decompressedStream = requestStream;
}
sinkStack.Push(this, new ClientState(clientCompressed));
// send the decompressed message on through the sink chain
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, decompressedStream, out responseMsg, out responseHeaders, out responseStream);
// get the compressed stream
if (clientCompressed && processingResult == ServerProcessing.Complete)
{
Stream compressedStream = CompressionHelper.CompressStream(responseStream);
responseStream.Close();
responseStream = compressedStream;
responseHeaders[CompressionHelper.CompressKey] = CompressionHelper.CompressedFlag;
}
// Take us off the stack and return the result.
if (processingResult == ServerProcessing.Async)
{
sinkStack.Store(this, new ClientState(clientCompressed));
}
else
{
sinkStack.Pop(this);
}
return(processingResult);
}
// <Snippet3>
public ServerProcessing ProcessMessage(IServerChannelSinkStack myServerChannelSinkStack,
IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage msg, out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (myBoolEnabled)
{
LoggingHelper.PrintRequest(myTextWriterOutput, requestHeaders, ref requestStream);
}
myServerChannelSinkStack.Push(this, null);
// <Snippet4>
// <Snippet5>
// <Snippet6>
ServerProcessing myServerProcessing =
myNewNextSink.ProcessMessage(myServerChannelSinkStack, requestMsg, requestHeaders, requestStream, out msg,
out responseHeaders, out responseStream);
Console.WriteLine("ServerProcessing.Complete value is: " + ServerProcessing.Complete);
Console.WriteLine("ServerProcessing.OneWay Value is: " + ServerProcessing.OneWay);
Console.WriteLine("ServerProcessing.Async value is: " + ServerProcessing.Async);
switch (myServerProcessing)
{
case ServerProcessing.Complete:
{
myServerChannelSinkStack.Pop(this);
if (myBoolEnabled)
{
LoggingHelper.PrintResponse(myTextWriterOutput, responseHeaders, ref responseStream);
}
break;
}
case ServerProcessing.OneWay:
{
myServerChannelSinkStack.Pop(this);
break;
}
case ServerProcessing.Async:
{
myServerChannelSinkStack.Store(this, null);
break;
}
}
return(myServerProcessing);
// </Snippet6>
// </Snippet5>
// </Snippet4>
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
LogicalCallContext lcc =
(LogicalCallContext)requestMsg.Properties["__CallContext"];
// storing the current priority
ThreadPriority oldprio = Thread.CurrentThread.Priority;
// check if the logical call context contains "priority"
if (lcc != null && lcc.GetData("priority") != null)
{
// fetch the priorty from the call context
ThreadPriority priority =
(ThreadPriority)lcc.GetData("priority");
Console.WriteLine(" -> Pre-execution priority change {0} to {1}",
oldprio.ToString(), priority.ToString());
// set the priority
Thread.CurrentThread.Priority = priority;
}
// push on the stack and pass the call to the next sink
// the old priority will be used as "state" for the response
sinkStack.Push(this, oldprio);
ServerProcessing spres = _next.ProcessMessage(sinkStack,
requestMsg, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream);
//restore priority if call is not asynchronous
if (spres != ServerProcessing.Async)
{
if (lcc != null && lcc.GetData("priority") != null)
{
Console.WriteLine(" -> Post-execution change back to {0}", oldprio);
Thread.CurrentThread.Priority = oldprio;
}
}
return(spres);
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
bool isCompressed = false;
// decompress the stream if necessary
String xcompress = (String)requestHeaders["X-Compress"];
if (xcompress != null && xcompress == "yes")
{
requestStream = CompressionHelper.GetUncompressedStreamCopy(requestStream);
isCompressed = true;
}
// Pushing onto stack and forwarding the call.
// The state object contains true if the request has been compressed,
// else false.
sinkStack.Push(this, isCompressed);
ServerProcessing srvProc = _nextSink.ProcessMessage(sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
if (srvProc == ServerProcessing.Complete)
{
// compressing the response if necessary
if (isCompressed)
{
responseStream = CompressionHelper.GetCompressedStreamCopy(responseStream);
responseHeaders["X-Compress"] = "yes";
}
}
// returning status information
return(srvProc);
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
try
{
if (_next != null)
{
ip = (IPAddress)requestHeaders[CommonTransportKeys.IPAddress];
if (ip != null && (ip.ToString().Trim() == "127.0.0.1" || CheckAuthorizedIP(ip.ToString())))
{
Common.CurrentStatus(ip.ToString().Trim());
ServerProcessing spres = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
return(spres);
}
else
{
Common.Log("Unauthorized Remoting IP: " + ip.ToString().Trim());
responseMsg = null;
responseHeaders = null;
responseStream = null;
return(new ServerProcessing());
}
}
else
{
responseMsg = null;
responseHeaders = null;
responseStream = null;
return(new ServerProcessing());
}
}
catch (Exception err)
{
Common.Log(err);
responseMsg = null;
responseHeaders = null;
responseStream = null;
return(new ServerProcessing());
}
}
/// <summary>
/// Processes the encrypted message.
/// </summary>
/// <param name="transactID">Secure transaction identifier.</param>
/// <param name="sinkStack">The sink stack.</param>
/// <param name="requestMsg">Request message.</param>
/// <param name="requestHeaders">Request transport headers.</param>
/// <param name="requestStream">Request stream.</param>
/// <param name="responseMsg">Response message.</param>
/// <param name="responseHeaders">Response transport headers.</param>
/// <param name="responseStream">Response stream.</param>
public ServerProcessing ProcessEncryptedMessage(Guid transactID, IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
// Get the client connection data
ClientConnectionData connectionData;
lock (_connections.SyncRoot)
{
connectionData = (ClientConnectionData)_connections[transactID.ToString()];
}
if (connectionData == null)
{
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_ClientConnectionInfoMissing);
}
// Update the timestamp and indicate that method call is in progress
connectionData.UpdateTimestamp();
connectionData.BeginMethodCall();
try
{
// Decrypt the data stream
Stream decryptedStream = CryptoTools.GetDecryptedStream(requestStream, connectionData.CryptoProvider);
requestStream.Close();
// Pass decrypted message for further processing to the next channel sink
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, decryptedStream, out responseMsg, out responseHeaders, out responseStream);
// Update secure transaction state
responseHeaders[CommonHeaderNames.SECURE_TRANSACTION_STATE] = ((int)SecureTransactionStage.SendingEncryptedResult).ToString();
// Encrypt the response stream and close the original response stream now that we're done with it
Stream encryptedStream = CryptoTools.GetEncryptedStream(responseStream, connectionData.CryptoProvider);
responseStream.Close(); //
// Use encrypted data stream as a response stream
responseStream = encryptedStream;
return(processingResult);
}
finally
{
// Method call is finished, so the connection data can be swept
connectionData.EndMethodCall();
connectionData.UpdateTimestamp();
}
}
internal void InternalProcessMessage(ClientConnection connection, Stream stream)
{
// Reads the headers and the request stream
Stream requestStream;
ITransportHeaders requestHeaders;
requestStream = TcpMessageIO.ReceiveMessageStream(stream, out requestHeaders, connection.Buffer);
requestHeaders [CommonTransportKeys.IPAddress] = connection.ClientAddress;
requestHeaders [CommonTransportKeys.ConnectionId] = connection.Id;
string uri = (string)requestHeaders [CommonTransportKeys.RequestUri];
TcpChannel.ParseChannelUrl(uri, out uri);
if (uri != null)
{
requestHeaders [CommonTransportKeys.RequestUri] = uri;
}
// 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:
TcpMessageIO.SendMessageStream(stream, responseStream, responseHeaders, connection.Buffer);
stream.Flush();
break;
case ServerProcessing.Async:
case ServerProcessing.OneWay:
break;
}
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
// Push this onto the sink stack
sinkStack.Push(this, null);
// If the request has the compression flag, decompress the stream.
if (requestHeaders[CommonHeaders.CompressionEnabled] != null)
{
// Process the message and decompress it.
requestStream = CompressHelper.Decompress(requestStream);
}
// Retrieve the response from the server.
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders,
requestStream, out responseMsg, out responseHeaders,
out responseStream);
// If the response stream length is greater than the threshold,
// message is not exempt from compression, and client supports compression,
// compress the stream.
if (processingResult == ServerProcessing.Complete &&
_compressionThreshold > 0 &&
responseStream.Length > _compressionThreshold &&
!IsCompressionExempt(responseMsg) &&
requestHeaders[CommonHeaders.CompressionSupported] != null)
{
// Process the message and compress it.
responseStream = CompressHelper.Compress(responseStream);
// Send the compression flag to the client.
responseHeaders[CommonHeaders.CompressionEnabled] = true;
}
// Take off the stack and return the result.
sinkStack.Pop(this);
return(processingResult);
}
/// <summary>
/// Entschlüsselt die eingehende Nachricht vom Client.
/// </summary>
/// <param name="transactID">Sicherheitstransaktionskennung</param>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="requestMsg">Anfrage-Nachricht vom Client</param>
/// <param name="requestHeaders">Anfrage-Header vom Cient</param>
/// <param name="requestStream">Anfrage-Datenstrom</param>
/// <param name="responseMsg">Antwort-Nachricht</param>
/// <param name="responseHeaders">Antwort-Header</param>
/// <param name="responseStream">Antwort-Datenstrom</param>
/// <returns>Verarbeitungsstatus</returns>
public ServerProcessing ProcessEncryptedMessage(Guid transactID, IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
// Variable für Client-Verbindungsinformationen
ClientConnectionData connectionData;
lock (_connections.SyncRoot)
{
// Client-Verbindungsdaten über die angegebene Sicherheitstransaktionskennung abrufen
connectionData = (ClientConnectionData)_connections[transactID.ToString()];
}
// Wenn keine Verbindungsdaten zu dieser Sicherheitstransaktionskennung gefunden wurden ...
if (connectionData == null)
{
// Ausnahme werfen
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_ClientConnectionInfoMissing);
}
// Zeitstempel aktualisieren
connectionData.UpdateTimestamp();
// Datenstrom entschlüsseln
Stream decryptedStream = CryptoTools.GetDecryptedStream(requestStream, connectionData.CryptoProvider);
// Verschlüsselten-Quelldatenstrom schließen
requestStream.Close();
// Entschlüsselte Nachricht zur Weiterverarbeitung an die nächste Kanalsenke weitergeben
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, decryptedStream, out responseMsg, out responseHeaders, out responseStream);
// Status der Sicherheitstransaktion auf "verschlüsselte Atwortnachricht senden" einstellen
responseHeaders[CommonHeaderNames.SECURE_TRANSACTION_STATE] = ((int)SecureTransactionStage.SendingEncryptedResult).ToString();
// Antwortnachricht verschlüsseln
Stream encryptedStream = CryptoTools.GetEncryptedStream(responseStream, connectionData.CryptoProvider);
// Unverschlüsselten Quell-Datenstrom schließen
responseStream.Close(); // close the plaintext stream now that we're done with it
// Verschlüsselten Datenstrom als Antwort-Datenstrom verwenden
responseStream = encryptedStream;
// Verarbeitungsstatus zurückgeben
return(processingResult);
}
internal void ServiceRequest(object state)
{
IMessage message;
ITransportHeaders headers2;
Stream stream2;
HttpServerSocketHandler handler = (HttpServerSocketHandler)state;
ITransportHeaders requestHeaders = handler.ReadHeaders();
Stream requestStream = handler.GetRequestStream();
requestHeaders["__CustomErrorsEnabled"] = handler.CustomErrorsEnabled();
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, handler);
ServerProcessing processing = this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out message, out headers2, out stream2);
switch (processing)
{
case ServerProcessing.Complete:
sinkStack.Pop(this);
handler.SendResponse(stream2, "200", "OK", headers2);
break;
case ServerProcessing.OneWay:
handler.SendResponse(null, "202", "Accepted", headers2);
break;
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, handler);
break;
}
if (processing != ServerProcessing.Async)
{
if (handler.CanServiceAnotherRequest())
{
handler.BeginReadMessage();
}
else
{
handler.Close();
}
}
}
public override void Process()
{
ServerProcessing = _serverSink.ProcessMessage(_sinkStack, _requestMsg, _requestHeaders, _requestStream, out ResponseMsg, out ResponseHeaders, out ResponseStream);
}
