本文整理汇总了C#中IServerChannelSinkStack.Push方法的典型用法代码示例。如果您正苦于以下问题:C# IServerChannelSinkStack.Push方法的具体用法?C# IServerChannelSinkStack.Push怎么用?C# IServerChannelSinkStack.Push使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类IServerChannelSinkStack
的用法示例。
在下文中一共展示了IServerChannelSinkStack.Push方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: ProcessMessage
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMessage, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMessage, out ITransportHeaders responseHeaders, out Stream responseStream)
{
requestStream = Zip.Decompress(requestStream);
sinkStack.Push(this, null);
ServerProcessing processing = this.m_NextSink.ProcessMessage(sinkStack, requestMessage, requestHeaders, requestStream, out responseMessage, out responseHeaders, out responseStream);
responseStream = Zip.Compress(responseStream);
return processing;
}
示例2: ProcessMessage
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 serverProcessing = _nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
switch (serverProcessing)
{
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, null);
return serverProcessing;
case ServerProcessing.OneWay:
case ServerProcessing.Complete:
sinkStack.Pop(this);
return serverProcessing;
default:
return serverProcessing;
}
}
示例3: ProcessMessage
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;
}
示例4: ProcessMessage
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
object handback = ContextUtil.NotifyServerMessage(requestMsg, requestHeaders);
sinkStack.Push(this, handback);
ServerProcessing result = _nextSink.ProcessMessage(sinkStack,
requestMsg, requestHeaders, requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
if (result != ServerProcessing.Async)
{
ContextUtil.NotifyServerMessageResponse(responseMsg, responseHeaders, handback);
}
return result;
}
示例5: ProcessMessage
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
IMethodCallMessage msg = (IMethodCallMessage) requestMsg;
// Console.WriteLine ("MESSAGE: " + msg.TypeName + " - " + msg.MethodName);
sinkStack.Push (this, null);
if (Attribute.IsDefined (msg.MethodBase, typeof(NoGuiDispatchAttribute))) {
ServerProcessing ret;
try {
ret = nextSink.ProcessMessage (sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
} finally {
sinkStack.Pop (this);
}
return ret;
}
else
{
Dispatcher d = new Dispatcher ();
d.nextSink = nextSink;
d.sinkStack = sinkStack;
d.requestMsg = requestMsg;
d.requestHeaders = requestHeaders;
d.requestStream = requestStream;
Gtk.Application.Invoke (d.Dispatch);
responseMsg = null;
responseHeaders = null;
responseStream = null;
return ServerProcessing.Async;
}
}
示例6: ProcessMessage
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
if (requestHeaders["SOAPAction"] != null)
{
// pass to next sink if this is a SOAP request with SOAPAction header.
return NextChannelSink.ProcessMessage(sinkStack,
requestMsg, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream);
}
XmlRpcHttpRequestConfig requestConfig = GetConfig(requestHeaders);
try
{
MethodCall call = DeserializeRequest(requestHeaders, requestStream, requestConfig);
sinkStack.Push(this, call);
// forward to next sink in chain - pass request stream as null to
// indicate that we have deserialized the request
NextChannelSink.ProcessMessage(sinkStack, call, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
SerializeResponse(responseMsg, ref responseHeaders, ref responseStream, requestConfig);
}
catch (Exception ex)
{
responseMsg = new ReturnMessage(ex, (IMethodCallMessage)requestMsg);
responseStream = new MemoryStream();
XmlRpcResponseSerializer serializer = new XmlRpcResponseSerializer();
XmlRpcResponse faultResponse = new XmlRpcResponse();
faultResponse.Fault = new XmlRpcFault(0, ex.Message);
serializer.WriteResponse(responseStream, faultResponse, requestConfig, TypeSerializerFactory);
responseHeaders = new TransportHeaders();
responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
}
return ServerProcessing.Complete;
}
示例7: ProcessMessage
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
responseMsg = null;
responseHeaders = null;
responseStream = null;
ServerProcessing sp;
SoapMessageFormatter soapMsgFormatter = new SoapMessageFormatter();
sinkStack.Push(this, soapMsgFormatter);
try {
string url = (string)requestHeaders[CommonTransportKeys.RequestUri];
string uri;
_receiver.Parse(url, out uri);
if(uri == null) uri = url;
Type serverType = RemotingServices.GetServerTypeForUri(uri);
if (serverType == null) throw new RemotingException ("No receiver for uri " + uri);
SoapFormatter fm = _soapCore.GetSafeDeserializer ();
SoapMessage soapMessage = soapMsgFormatter.CreateSoapMessage (true);
fm.TopObject = soapMessage;
requestStream.Position = 0;
fm.Deserialize(requestStream);
requestMsg = soapMsgFormatter.BuildMethodCallFromSoapMessage(soapMessage, uri);
sp = next_sink.ProcessMessage(sinkStack, requestMsg, requestHeaders, null, out responseMsg, out responseHeaders, out responseStream);
if(sp == ServerProcessing.Complete) {
if(responseMsg != null && responseStream == null) {
object rtnMessageObject = soapMsgFormatter.BuildSoapMessageFromMethodResponse((IMethodReturnMessage) responseMsg, out responseHeaders);
responseStream = new MemoryStream();
_soapCore.Serializer.Serialize(responseStream, rtnMessageObject);
}
}
}
catch(Exception e)
{
responseMsg = (IMethodReturnMessage)new ReturnMessage(e, (IMethodCallMessage)requestMsg);
object rtnMessageObject = soapMsgFormatter.BuildSoapMessageFromMethodResponse((IMethodReturnMessage) responseMsg, out responseHeaders);
responseStream = new MemoryStream();
_soapCore.Serializer.Serialize(responseStream, rtnMessageObject);
sp = ServerProcessing.Complete;
}
if (sp == ServerProcessing.Complete)
sinkStack.Pop(this);
return sp;
}
示例8: ProcessMessage
/// <summary>
/// Verarbeitet eine einzele Clientanfrage
/// </summary>
/// <param name="sinkStack">Aufrufstapel der Kanalsenken</param>
/// <param name="requestMsg">Anfrage-nachricht</param>
/// <param name="requestHeaders">Anfrage-Header</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>Status serverseitigen Verarbeitung der Nachricht insgesamt</returns>
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
// Sicherheitstransaktionskennung aus Anfrage-Header lesen
string strTransactID = (string)requestHeaders[CommonHeaderNames.SECURE_TRANSACTION_ID];
// In Guid umwandeln
Guid transactID = (strTransactID == null ? Guid.Empty : new Guid(strTransactID));
// Aktuellen Transaktionsschritt aus Anfrage-Header lesen
SecureTransactionStage transactionStage = (SecureTransactionStage)Convert.ToInt32((string)requestHeaders[CommonHeaderNames.SECURE_TRANSACTION_STATE]);
// IP-Adresse des Clients aus Anfrage-Header lesen
IPAddress clientAddress = requestHeaders[CommonTransportKeys.IPAddress] as IPAddress;
// Aktuelle Kanalsenke auf den Senkenstapel legen, damit AsyncProcessResponse später ggf. asynchron aufgerufen werden kann
sinkStack.Push(this, null);
// Variable für Verarbeitungsstatus
ServerProcessing processingResult;
// Aktuellen Transaktionsschritt auswerten
switch (transactionStage)
{
case SecureTransactionStage.SendingPublicKey: // Client sendet den öffentlichen Schlüssel an den Server
// Gemeinsamen Schlüssel erzeugen und mit dem öffentlichen Schlüssel des Clients verschlüsseln
processingResult = MakeSharedKey(transactID, requestHeaders, out responseMsg, out responseHeaders, out responseStream);
break;
case SecureTransactionStage.SendingEncryptedMessage: // Client sendet die verschlüsselte Anfragenachricht an den Server
// Wenn die Sicherheitstransaktionskennung des Clients bekannt ist ...
if (IsExistingSecurityTransaction(transactID))
// Verschlüsselte Nachricht verarbeiten
processingResult = ProcessEncryptedMessage(transactID, sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
else
// Leere Nachricht an den Client senden und Transaktionsschritt auf "Unbekannte Sicherheitstransaktionskennung". setzen.
processingResult = SendEmptyToClient(SecureTransactionStage.UnknownTransactionID, out responseMsg, out responseHeaders, out responseStream);
break;
case SecureTransactionStage.Uninitialized: // Uninizialisiert, noch nichts geschehen
// Wenn für diesen Client Verschlüsselung nicht zwingend notwendig ist ...
if (!RequireEncryption(clientAddress))
// Nachricht gleich an die nächste Senke zur Weiterverarbeitung übergeben
processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
else
// Ausnahme werfen
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_ServerRequiresEncryption);
break;
default:
// Ausnahme werfen
throw new CryptoRemotingException(string.Format(LanguageResource.CryptoRemotingException_InvalidClientRequest, transactionStage));
}
// Aktuelle Senke wieder vom Senkenstapel runternehmen
sinkStack.Pop(this);
// Veratbeitungsstatus zurückgeben
return processingResult;
}
示例9: ProcessMessage
//.........这里部分代码省略.........
responseHeaders["__HttpStatusCode"] = "400";
responseHeaders["__HttpReasonPhrase"] = "Bad Request";
responseStream = null;
responseMsg = null;
return ServerProcessing.Complete;
}
else
{
// The transport sink will catch this and do something here.
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Channels_InvalidRequestFormat"));
}
}
}
try
{
String objectUri = null;
if (wkRequestHeaders != null)
objectUri = wkRequestHeaders.RequestUri;
else
objectUri = (String)requestHeaders[CommonTransportKeys.RequestUri];
if (RemotingServices.GetServerTypeForUri(objectUri) == null)
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_ChnlSink_UriNotPublished"));
RemotingServices.LogRemotingStage(CoreChannel.SERVER_MSG_DESER);
// Deserialize Request - Stream to IMessage
requestMsg =
CoreChannel.DeserializeBinaryRequestMessage(objectUri, requestStream, _strictBinding);
requestStream.Close();
if(requestMsg == null)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_DeserializeMessage"));
}
// Dispatch Call
sinkStack.Push(this, null);
RemotingServices.LogRemotingStage(CoreChannel.SERVER_MSG_SINK_CHAIN);
processing =
_nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
// make sure that responseStream is null
if (responseStream != null)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_ChnlSink_WantNullResponseStream"));
}
switch (processing)
{
case ServerProcessing.Complete:
{
if (responseMsg == null)
throw new RemotingException(CoreChannel.GetResourceString("Remoting_DispatchMessage"));
sinkStack.Pop(this);
RemotingServices.LogRemotingStage(CoreChannel.SERVER_RET_SER);
SerializeResponse(sinkStack, responseMsg,
ref responseHeaders, out responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
sinkStack.Pop(this);
break;
} // case ServerProcessing.OneWay:
case ServerProcessing.Async:
{
sinkStack.Store(this, null);
break;
} // case ServerProcessing.Async
} // switch (processing)
}
catch(Exception e)
{
processing = ServerProcessing.Complete;
responseMsg = new ReturnMessage(e, (IMethodCallMessage)(requestMsg==null?new ErrorMessage():requestMsg));
responseStream = (MemoryStream)CoreChannel.SerializeBinaryMessage(responseMsg, _includeVersioning);
responseStream.Position = 0;
responseHeaders = new TransportHeaders();
if (_protocol == Protocol.Http)
{
responseHeaders["Content-Type"] = CoreChannel.BinaryMimeType;
}
}
RemotingServices.LogRemotingStage(CoreChannel.SERVER_RET_SEND);
return processing;
} // ProcessMessage
示例10: ProcessMessage
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 m_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
{
MethodCall 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
m_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();
XmlRpcFaultException fex = new XmlRpcFaultException(0, ex.Message);
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.SerializeFaultResponse(responseStream,
(XmlRpcFaultException)fex);
responseHeaders = new TransportHeaders();
}
return ServerProcessing.Complete;
}
示例11: ProcessRequestMessage
/// <summary>
/// process a giop request message.
/// </summary>
private ServerProcessing ProcessRequestMessage(IServerChannelSinkStack sinkStack,
ITransportHeaders requestHeaders,
CdrMessageInputStream msgInput,
GiopServerConnection serverCon,
out IMessage responseMsg, out ITransportHeaders responseHeaders,
out Stream responseStream) {
IMessage deserReqMsg = null;
responseHeaders = null;
try {
try {
// deserialise the request
deserReqMsg = m_messageHandler.ParseIncomingRequestMessage(msgInput,
serverCon.ConDesc);
} finally {
//request deserialised -> safe to read next request while processing request in servant
// (or sending request deserialisation exception)
try {
serverCon.NotifyDeserialiseRequestComplete();
} catch (Exception ne) {
// unexpected exception. Abort message processing, problem with transport.
throw new NotifyReadRequestException("Problem while trying to inform transport about request deserialistion.",
ne);
}
}
// processing may be done asynchronous, therefore push this sink on the stack to process a response async
AsyncServerProcessingData asyncData =
new AsyncServerProcessingData(deserReqMsg, serverCon);
sinkStack.Push(this, asyncData);
ServerProcessing processingResult;
try {
// forward the call to the next message handling sink
processingResult = m_nextSink.ProcessMessage(sinkStack, deserReqMsg,
requestHeaders, null, out responseMsg,
out responseHeaders, out responseStream);
} catch (Exception) {
sinkStack.Pop(this);
throw;
}
switch (processingResult) {
case ServerProcessing.Complete:
sinkStack.Pop(this); // not async
// send the response
SerialiseResponse(sinkStack, deserReqMsg, serverCon, responseMsg,
ref responseHeaders, out responseStream);
break;
case ServerProcessing.Async:
sinkStack.Store(this, asyncData); // this sink want's to process async response
break;
case ServerProcessing.OneWay:
// nothing to do, because no response expected
sinkStack.Pop(this);
break;
}
return processingResult;
} catch (MessageHandling.RequestDeserializationException deserEx) {
// exception from DeserialisRequest
responseMsg = deserEx.ResponseMessage;
// an exception was thrown during deserialization
SerialiseExceptionResponse(sinkStack,
deserEx.RequestMessage, serverCon, responseMsg,
ref responseHeaders, out responseStream);
return ServerProcessing.Complete;
} catch (NotifyReadRequestException nrre) {
Trace.WriteLine("Failed to inform transport about request deserialisation. Processing problem on server connection after unexpected exception: " + nrre.InnerException);
throw nrre;
} catch (Exception e) {
// serialise an exception response
if (deserReqMsg != null) {
if (deserReqMsg is IMethodCallMessage) {
responseMsg = new ReturnMessage(e, (IMethodCallMessage) deserReqMsg);
} else {
responseMsg = new ReturnMessage(e, null); // no usable information present
}
SerialiseExceptionResponse(sinkStack,
deserReqMsg, serverCon, responseMsg,
ref responseHeaders, out responseStream);
} else {
throw e;
}
return ServerProcessing.Complete; // send back an error msg
}
}
示例12: ProcessMessage
/// <summary>Requests message processing from the current sink.</summary>
/// <param name="sinkStack">A stack of channel sinks</param>
/// <param name="requestMsg">Request message.</param>
/// <param name="requestHeaders">Headers sent by client.</param>
/// <param name="requestStream">Stream to be processed..</param>
/// <param name="responseMsg">Response message.</param>
/// <param name="responseHeaders">Response headers.</param>
/// <param name="responseStream">Response stream.</param>
/// <returns>Status of the server message processing.</returns>
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
// Get header information about transaction
string strTransactID = (string)requestHeaders[CommonHeaders.ID];
Guid transactID = (strTransactID == null ? Guid.Empty : new Guid(strTransactID));
SecureTransaction transactType = (SecureTransaction)Convert.ToInt32((string)requestHeaders[CommonHeaders.Transaction]);
// For reference, find out who is connecting to us. We can use this to filter
// and to enforce security based on client identity.
IPAddress clientAddress = requestHeaders[CommonTransportKeys.IPAddress] as IPAddress;
// Set the IP address and port of our client
CallContext.SetData("ClientIP", clientAddress);
// Push this onto the sink stack
sinkStack.Push(this, null);
// Process the transaction based on its type (as stored in the CommonHeaders.Transaction header field)
ServerProcessing processingResult;
switch(transactType)
{
case SecureTransaction.SendingPublicKey:
// We've received a request from a new client asking for a shared key (by sending us
// his RSA public key). Create a shared key, encrypt it, and send it back to him.
processingResult = MakeSharedKey(transactID, requestHeaders, out responseMsg, out responseHeaders, out responseStream);
System.Diagnostics.Debug.WriteLine("Connection added: " + transactID);
break;
case SecureTransaction.SendingEncryptedMessage:
// We've received an encrypted message. Decrypt it and send it along to the next sink.
// But first make sure we have a record of the transaction.
if (PreviousTransactionWithClient(transactID))
{
processingResult = ProcessEncryptedMessage(
transactID, sinkStack,
requestMsg, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream);
}
// Otherwise, let the client know that we don't recognize him.
else
{
processingResult = SendEmptyToClient(
SecureTransaction.UnknownIdentifier,
out responseMsg, out responseHeaders, out responseStream);
System.Diagnostics.Debug.WriteLine("Unknown connection: " + transactID);
}
break;
case SecureTransaction.Uninitialized:
// The transaction type did not match any known type, or wasn't specified.
// So just pass on the message to the next sink. This shouldn't happen
// unless the client isn't using the SecureClientSink provider, in which
// case this is the correct behavior.
if (!RequireSecurity(clientAddress))
{
processingResult = _next.ProcessMessage(
sinkStack, requestMsg, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream);
}
// If the server has elected not to allow plaintext traffic, let the
// client know that we're not happy.
else throw new SecureRemotingException("Server requires a secure connection for this client");
break;
default:
// Houston, we have a problem!
throw new SecureRemotingException("Invalid request from client: " + transactType + ".");
}
// Take us off the stack and return the result.
sinkStack.Pop(this);
return processingResult;
}
示例13: ProcessMessage
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack_in,
IMessage requestMsg_in,
ITransportHeaders requestHeaders_in,
Stream requestStream_in,
out IMessage responseMsg_out,
out ITransportHeaders responseHeaders_out,
out Stream responseStream_out
) {
#if DEBUG
Console.WriteLine("encryption sink: ProcessMessage");
#endif
bool _isEncrypted = false;
if (isHeaderEncrypted(requestHeaders_in)) {
#region decrypt...
requestStream_in
= EncryptionHelper.Decrypt(
requestStream_in,
true,
keyspath_,
(string)requestHeaders_in[EncryptionHelper.X_CLIENTID]
);
_isEncrypted = true;
#endregion
} else {
if (mustdo_) {
throw new Exception("\n\n\t\tyour activity is being logged!\n\n\t\tun-encrypted communications not allowed!\n\n");
}
}
sinkStack_in.Push(
this,
new StateStruct(
_isEncrypted,
_isEncrypted ? (string)requestHeaders_in[EncryptionHelper.X_CLIENTID] : ""
)
);
ServerProcessing _output = nextchannelsink_.ProcessMessage(
sinkStack_in,
requestMsg_in,
requestHeaders_in,
requestStream_in,
out responseMsg_out,
out responseHeaders_out,
out responseStream_out
);
if (_output == ServerProcessing.Complete) {
if (_isEncrypted) {
#region encrypt...
responseHeaders_out[EncryptionHelper.X_ENCRYPT] = "1";
responseStream_out
= EncryptionHelper.Encrypt(
responseStream_out,
true,
keyspath_,
(string)requestHeaders_in[EncryptionHelper.X_CLIENTID]
);
#endregion
}
//// previously checked!
//else {
// if (mustdo_) {
// throw new Exception("\n\n\t\tyour activity is being logged!\n\n\t\tun-encrypted communications not allowed!\n\n");
// }
//}
}
return _output;
}
示例14: ProcessMessage
/// <summary>
/// Verarbeitet eine einzele Clientanfrage
/// </summary>
/// <param name="sinkStack">Aufrufstapel der Kanalsenken</param>
/// <param name="requestMsg">Anfrage-nachricht</param>
/// <param name="requestHeaders">Anfrage-Header</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>Status serverseitigen Verarbeitung der Nachricht insgesamt</returns>
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
// Aktuelle Kanalsenke auf den Senkenstapel legen, damit AsyncProcessResponse später ggf. asynchron aufgerufen werden kann
sinkStack.Push(this, null);
//Threadsave
lock (_lockObject)
{
//Verarbeite die Nachricht
DoProcessMessageBefore(requestMsg, requestHeaders, requestStream);
}
// Variable für Verarbeitungsstatus
ServerProcessing processingResult;
// Nachricht gleich an die nächste Senke zur Weiterverarbeitung übergeben
processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
//Threadsave
lock (_lockObject)
{
//Verarbeite die Nachricht
DoProcessMessageAfter(responseMsg, responseHeaders, responseStream, requestHeaders);
}
// Aktuelle Senke wieder vom Senkenstapel runternehmen
sinkStack.Pop(this);
return processingResult;
}
示例15: ProcessMessage
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;
try
{
string url = (string)requestHeaders["__RequestUri"];
string uri;
receiver.Parse (url, out uri);
if (uri == null) uri = url;
MethodCallHeaderHandler mhh = new MethodCallHeaderHandler(uri);
requestMsg = (IMessage) _binaryCore.Deserializer.Deserialize (requestStream, new HeaderHandler(mhh.HandleHeaders));
res = next_sink.ProcessMessage (sinkStack, requestMsg, requestHeaders, null, out responseMsg, out responseHeaders, out responseStream);
}
catch (Exception ex)
{
responseMsg = new ReturnMessage (ex, (IMethodCallMessage)requestMsg);
res = ServerProcessing.Complete;
responseHeaders = null;
responseStream = null;
}
if (res == ServerProcessing.Complete)
{
for (int n=0; n<3; n++) {
responseStream = null;
responseHeaders = new TransportHeaders();
if (sinkStack != null) responseStream = sinkStack.GetResponseStream (responseMsg, responseHeaders);
if (responseStream == null) responseStream = new MemoryStream();
try {
_binaryCore.Serializer.Serialize (responseStream, responseMsg);
break;
} catch (Exception ex) {
if (n == 2) throw ex;
else responseMsg = new ReturnMessage (ex, (IMethodCallMessage)requestMsg);
}
}
if (responseStream is MemoryStream) responseStream.Position = 0;
sinkStack.Pop (this);
}
return res;
}