public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
			IMessage msg, ITransportHeaders headers, Stream responseStream)
		{
			ContextWithId ctx = (ContextWithId) state;
			WriteOut (ctx.Context, headers, responseStream);
			ctx.Context.Response.Close ();
		}

		public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack,
						 object state,
						 IMessage msg,
						 ITransportHeaders headers)
		{
			return null;
		}

		public void AsyncProcessResponse(
			IServerResponseChannelSinkStack sinkStack_in, 
			object state_in,
			IMessage message_in, 
			ITransportHeaders headers_in, 
			Stream stream_in
		) {
#if DEBUG
			Console.WriteLine("compression sink: AsyncProcessResponse...");
#endif
			bool _hasBeenCompressed = (bool)state_in;

			if (_hasBeenCompressed) {
				#region compress...
				headers_in[CompressionHelper.X_COMPRESS] = "1";

				stream_in = CompressionHelper.GetCompressedStreamCopy(
					stream_in
				); 
				#endregion
			} else {
				if (this.mustdo_) {
					throw new Exception("\n\n\t\tyour activity is being logged!\n\n\t\tun-compressed communications not allowed!\n\n");
				}
			}

			sinkStack_in.AsyncProcessResponse(
				message_in,
				headers_in, 
				stream_in
			);
		} 

 public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack,
                                  object state,
                                  IMessage msg,
                                  ITransportHeaders headers)
 {
   throw new NotImplementedException();
 }

		public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack,
						  object state,
						  IMessage msg,
						  ITransportHeaders headers,
						  Stream stream)
		{
			throw new NotSupportedException ();	// Never called
		}

 public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
 {
     HttpServerSocketHandler handler = (HttpServerSocketHandler) state;
     if (handler.AllowChunkedResponse)
     {
         return handler.GetResponseStream("200", "OK", headers);
     }
     return null;
 }

 public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack
     , object state
     , IMessage msg
     , ITransportHeaders headers
     , Stream stream)
 {
     SerializeResponseMessage(sinkStack, msg, ref headers, ref stream);
     sinkStack.AsyncProcessResponse(msg, headers, stream);
 }

 public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
                                   IMessage msg, ITransportHeaders headers, Stream responseStream)
 {
     ClientConnection connection = (ClientConnection)state;
     NetworkStream stream = new NetworkStream (connection.Client);
     UnixMessageIO.SendMessageStream (stream, responseStream, headers, connection.Buffer);
     stream.Flush ();
     stream.Close ();
 }

 public void AsyncProcessResponse(
     IServerResponseChannelSinkStack sinkStack,
     object state,
     IMessage msg,
     ITransportHeaders headers,
     Stream stream)
 {
     // Send the response to the client.
     sinkStack.AsyncProcessResponse(msg, headers, stream);
 }

		/// <summary></summary>
		public void AsyncProcessResponse(
			IServerResponseChannelSinkStack sinkStack,
			Object state,
			IMessage message,
			ITransportHeaders headers,
			Stream stream)
		{
			SetClientIpAddressDataHelper(headers);
			sinkStack.AsyncProcessResponse(message, headers, stream);
		}

 public void AsyncProcessResponse(
         IServerResponseChannelSinkStack sinkStack,
         Object state,
         IMessage message,
         ITransportHeaders headers,
         Stream stream)
 {
     IPAddress ip = headers[CommonTransportKeys.IPAddress] as IPAddress;
         CallContext.SetData("ClientIPAddress", ip);
         sinkStack.AsyncProcessResponse(message, headers, stream);
 }

        public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
        {
            ClientState cs = state as ClientState;
            if (cs != null && cs.clientCompressed) {
                // compress the shits
                stream = CompressionHelper.CompressStream(stream);
                headers[CompressionHelper.CompressKey] = CompressionHelper.CompressedFlag;
            }

            sinkStack.AsyncProcessResponse(msg, headers, stream);
        }

		public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
						  IMessage message, ITransportHeaders headers, Stream stream)
		{
			ITransportHeaders responseHeaders = new TransportHeaders();

			if (sinkStack != null) stream = sinkStack.GetResponseStream (message, responseHeaders);
			if (stream == null) stream = new MemoryStream();

			_binaryCore.Serializer.Serialize (stream, message, null);
			if (stream is MemoryStream) stream.Position = 0;

			sinkStack.AsyncProcessResponse (message, responseHeaders, stream);
		}

 public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
 {
     HttpServerSocketHandler handler = null;
     handler = (HttpServerSocketHandler) state;
     handler.SendResponse(stream, "200", "OK", headers);
     if (handler.CanServiceAnotherRequest())
     {
         handler.BeginReadMessage();
     }
     else
     {
         handler.Close();
     }
 }

		public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage responseMsg, ITransportHeaders responseHeaders)
		{
			// parameters validation
			if (responseHeaders == null)
				throw new ArgumentNullException("responseHeaders");

			IMethodReturnMessage methodReturn = responseMsg as IMethodReturnMessage;
			if (methodReturn == null)
				throw new NotSupportedException();

			IConnection connection = state as IConnection;
			if (connection == null)
				throw new NotSupportedException();

			// return stream for writing response
			return connection.GetResponseStream(methodReturn, responseHeaders);
		}

		public void AsyncProcessResponse(
			IServerResponseChannelSinkStack sinkStack_in,
			object state_in,
			IMessage message_in,
			ITransportHeaders headers_in,
			Stream stream_in
		) {
			CallContext.SetData(
				"ClientIPAddress", 
				((IPAddress)headers_in[CommonTransportKeys.IPAddress]).ToString()
			);

			sinkStack_in.AsyncProcessResponse(
				message_in, 
				headers_in, 
				stream_in
			);
		}

        public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage responseMsg, ITransportHeaders responseHeaders, Stream responseStream)
        {
            // parameters validation
            if (sinkStack == null)
                throw new ArgumentNullException("sinkStack");
            if (responseHeaders == null)
                throw new ArgumentNullException("responseHeaders");
            if (responseStream == null)
                throw new ArgumentNullException("responseStream");

            var methodReturn = responseMsg as IMethodReturnMessage;
            if (methodReturn == null)
                throw new NotSupportedException();

            // serialize response
            _formatter.SerializeResponse(methodReturn, responseHeaders, responseStream);

            // process response asynchronously
            sinkStack.AsyncProcessResponse(responseMsg, responseHeaders, responseStream);
        }

		public void AsyncProcessResponse(
			IServerResponseChannelSinkStack sinkStack_in, 
			object state_in,
			IMessage message_in, 
			ITransportHeaders headers_in, 
			Stream stream_in
		) {
#if DEBUG
			Console.WriteLine("encryption sink: AsyncProcessResponse");
#endif

			bool _hasBeenEncrypted 
				= (state_in != null) 
					? ((StateStruct)state_in).isEncripted
					: false
				;

			if (_hasBeenEncrypted) {
				#region encrypt...
				headers_in[EncryptionHelper.X_ENCRYPT] = "1";
				stream_in
					= EncryptionHelper.Encrypt(
						stream_in,
						true,
						keyspath_,
						((StateStruct)state_in).ClientID
					); 
				#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.AsyncProcessResponse(
				message_in,
				headers_in, 
				stream_in
			);
		} 

		public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack, object state,
						IMessage msg, ITransportHeaders headers)
		{
			// this method shouldn't be called
			throw new NotSupportedException ();
		}

		public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
						  IMessage msg, ITransportHeaders headers, Stream stream)
						  
		{
			ITransportHeaders responseHeaders = new TransportHeaders();

			if(sinkStack != null) stream = sinkStack.GetResponseStream(msg, responseHeaders);
			if(stream == null) stream = new MemoryStream();

			SoapMessageFormatter soapMsgFormatter = (SoapMessageFormatter)state;

			SoapMessage soapMessage = (SoapMessage) soapMsgFormatter.BuildSoapMessageFromMethodResponse((IMethodReturnMessage)msg, out responseHeaders);

			_soapCore.Serializer.Serialize(stream, soapMessage, null);

			if(stream is MemoryStream) stream.Position = 0;
			sinkStack.AsyncProcessResponse (msg, responseHeaders, stream);
		}