C# IServerChannelSinkStack.Push方法代码示例

 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;
 }

 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;
     }
 }

        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;
        }

        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;
        }

		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;
			}
		}

        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;
        }

		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;
			
		}

        /// <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;
        }

//.........这里部分代码省略.........
                        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

    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;
    }

        /// <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
            }
        }

        /// <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;
        }

		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;
		} 

        /// <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;
        }

		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;
		}