void IClientChannelSink.ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, System.IO.Stream requestStream, out ITransportHeaders responseHeaders, out System.IO.Stream responseStream)
{
lock (authHelper)
{
if (!authHelper.HaveNonce)
{
System.Runtime.Remoting.Channels.TransportHeaders authHeaders = new TransportHeaders();
System.IO.MemoryStream authStream = new System.IO.MemoryStream();
authHelper.SetRequest(authHeaders);
ITransportHeaders authedHeaders;
System.IO.Stream authedStream;
nextSink.ProcessMessage(msg, authHeaders, authStream, out authedHeaders, out authedStream);
//System.IO.MemoryStream memStream = BaseHelper.ToMemoryStream(authedStream);
//char[] chars = new System.Text.UTF8Encoding().GetChars(memStream.ToArray(), 0, (int)memStream.Length);
authHelper.SetNonce(authedHeaders);
}
}
authHelper.Authenticate(requestHeaders, ref requestStream);
nextSink.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
}
private SymmetricAlgorithm ObtainSharedKey(IMessage msg)
{
TransportHeaders requestHeaders = new TransportHeaders();
MemoryStream requestStream = new MemoryStream();
ITransportHeaders responseHeaders;
Stream responseStream;
CreateSharedKeyRequest(requestHeaders);
_next.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
return(ProcessSharedKeyResponse(responseHeaders));
}
public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
{
Stream origStream = requestStream;
long origPos = requestStream.Position;
bool didCompress = true;
if ((checkedCompress && serverCanCompress) || (!checkedCompress && assumeCompress))
{
requestHeaders[CompressionHelper.CompressKey] = CompressionHelper.CompressedFlag;
requestStream = CompressionHelper.CompressStream(requestStream);
}
else
{
didCompress = false;
requestHeaders[CompressionHelper.CompressKey] = CompressionHelper.CompressRequest;
}
responseStream = null;
responseHeaders = null;
// Send the compressed request to the server
try {
_next.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
serverCanCompress = object.Equals(responseHeaders[CompressionHelper.CompressKey], CompressionHelper.CompressedFlag);
checkedCompress = true;
if (!serverCanCompress && didCompress)
{
origStream.Position = origPos;
_next.ProcessMessage(msg, requestHeaders, origStream, out responseHeaders, out responseStream);
}
}
catch (Exception) {
serverCanCompress = false;
throw;
}
if (serverCanCompress)
{
//Debug.WriteLine("Server can compress");
Stream decompressedStream = CompressionHelper.DecompressStream(responseStream);
// close that ish as nobody wants it any more
responseStream.Close();
responseStream = decompressedStream;
}
}
void IClientChannelSink.ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, System.IO.Stream requestStream, out ITransportHeaders responseHeaders, out System.IO.Stream responseStream)
{
if (!crypto.IsCryptoReady)
{
Authenticate(msg);
}
requestHeaders[CommonHeaders.EncryptionType] = EncryptionType.Encrypted;
nextSink.ProcessMessage(msg, requestHeaders, crypto.EncryptEx(requestStream), out responseHeaders, out responseStream);
if (responseHeaders[CommonHeaders.EncryptionType] != null && responseHeaders[CommonHeaders.EncryptionType].ToString() == EncryptionType.Encrypted.ToString())
{
responseStream = crypto.DecryptEx(responseStream);
}
}
/// <summary>
/// Requests the shared key for symmetrical encryption algorithm from the server.
/// </summary>
/// <param name="msg">The message.</param>
private SymmetricAlgorithm ObtainSharedKey(IMessage msg)
{
TransportHeaders requestHeaders = new TransportHeaders();
MemoryStream requestStream = new MemoryStream();
ITransportHeaders responseHeaders;
Stream responseStream;
// Generate a request for the shared key
CreateSharedKeyRequest(requestHeaders);
// Send the request to the next sink to communicate with the CryptoServerChannelSink across the wire
_next.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
// Process server's response
return(ProcessSharedKeyResponse(responseHeaders));
}
public void ProcessMessage(IMessage msg,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
byte[] IV;
requestStream = EncryptionHelper.ProcessOutboundStream(requestStream,
_encryptionAlgorithm, _encryptionKey, out IV);
requestHeaders["X-Encrypt"] = "yes";
requestHeaders["X-EncryptIV"] = Convert.ToBase64String(IV);
// forward the call to the next sink
_nextSink.ProcessMessage(msg,
requestHeaders,
requestStream,
out responseHeaders,
out responseStream);
if (responseHeaders["X-Encrypt"] != null &&
responseHeaders["X-Encrypt"].Equals("yes"))
{
IV = Convert.FromBase64String((String)responseHeaders["X-EncryptIV"]);
responseStream = EncryptionHelper.ProcessInboundStream(
responseStream,
_encryptionAlgorithm,
_encryptionKey,
IV);
}
}
public void ProcessMessage(
IMessage msg,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
// If the request stream length is greater than the threshold
// and message is not exempt from compression, compress the stream.
if (_compressionThreshold > 0 &&
requestStream.Length > _compressionThreshold &&
!IsCompressionExempt(msg))
{
// Process the message and compress it.
requestStream = CompressHelper.Compress(requestStream);
// Send the compression flag to the server.
requestHeaders[CommonHeaders.CompressionEnabled] = true;
}
// Send the compression supported flag to the server.
requestHeaders[CommonHeaders.CompressionSupported] = true;
// Send the request to the server.
_next.ProcessMessage(
msg, requestHeaders, requestStream,
out responseHeaders, out responseStream);
// If the response has the compression flag, decompress the stream.
if (responseHeaders[CommonHeaders.CompressionEnabled] != null)
{
// Process the message and decompress it.
responseStream = CompressHelper.Decompress(responseStream);
}
}
public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
{
CompressSinkHelper.SetClientSupportCompressFlag(requestHeaders);
requestStream = CompressSinkHelper.CompressStream(requestHeaders, requestStream);
_next.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
responseStream = CompressSinkHelper.DecompressStream(responseHeaders, responseStream);
}
public IMessage SyncProcessMessage(IMessage msg)
{
IMethodCallMessage mcall = msg as IMethodCallMessage;
Trace.WriteLine("IceClientFormatterSink: ProcessMessage: " + mcall.MethodBase);
try {
Stream msgStream;
FormatMessage(msg, out msgStream);
// send downstream for processing
TransportHeaders reqHeaders = new TransportHeaders();
ITransportHeaders respHeaders;
Stream respStream;
_next.ProcessMessage(msg, reqHeaders, msgStream, out respHeaders, out respStream);
// convert back into a response message
IMessage result = (IMessage)IceChannelUtils.ProtocolReplyToMessage(respStream, msg);
respStream.Close();
return(result);
} catch (Exception e) {
return(new ReturnMessage(e, mcall));
}
}
public IMessage SyncProcessMessage(IMessage msg)
{
IMethodCallMessage mcm = msg as IMethodCallMessage;
IMessage retMsg;
try
{
// serialize message
ITransportHeaders headers;
Stream requestStream;
SerializeMessage(msg, out headers, out requestStream);
// process message
Stream returnStream;
ITransportHeaders returnHeaders;
_nextSink.ProcessMessage(msg, headers, requestStream,
out returnHeaders, out returnStream);
if (returnHeaders == null)
{
throw new ArgumentNullException("returnHeaders");
}
// deserialize stream
retMsg = DeserializeMessage(mcm, returnHeaders, returnStream);
}
catch (Exception e)
{
retMsg = new ReturnMessage(e, mcm);
}
return(retMsg);
} // SyncProcessMessage
public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders,
Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
{
RemotingResult result = cache.GetPreviousResults(msg, requestHeaders, false);
if (result == null)
{
_nextSink.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
object objCacheLimit = responseHeaders["X-Cache"];
if (objCacheLimit != null && Convert.ToInt32(objCacheLimit) > 0)
{
byte[] response = ExtractContents(responseStream);
//responseStream can only be read once - give back new stream
responseStream = new MemoryStream(response, 0, response.Length);
//save for next time
cache.CacheResults(msg, requestHeaders,
new RemotingResult(response, responseHeaders, DateTime.UtcNow + TimeSpan.FromSeconds(Convert.ToInt32(objCacheLimit))), false);
}
}
else
{
responseStream = new MemoryStream(result.Response);
responseHeaders = result.Headers;
}
}
public void ProcessMessage(
IMessage msg,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream
)
{
#region Add hash to stream header
string hash = HashHelper.GetHash(ref requestStream);
requestHeaders[HashHelper.C_HASH_ITEM] = hash;
//Debug.WriteLine("Client Side : client request stream hash is " + hash);
#endregion
_nextSink.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
#region Check response stream hash
hash = responseHeaders[HashHelper.C_HASH_ITEM] as string;
//Debug.WriteLine("Client Side : response stream hash is " + hash);
bool check = HashHelper.CheckHash(ref responseStream, hash);
if (!check)
{
throw new Exception("Client Side : response stream header checksum error");
}
#endregion
}
public IMessage SyncProcessMessage(IMessage msg)
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
IMessage retMsg;
try
{
// serialize message
ITransportHeaders headers;
Stream requestStream;
SerializeMessage(mcm, out headers, out requestStream);
// process message
Stream returnStream;
ITransportHeaders returnHeaders;
_nextSink.ProcessMessage(msg, headers, requestStream,
out returnHeaders, out returnStream);
if (returnHeaders == null)
{
throw new ArgumentNullException("returnHeaders");
}
// deserialize stream
retMsg = DeserializeMessage(mcm, returnHeaders, returnStream);
}
catch (Exception e)
{
retMsg = new ReturnMessage(e, mcm);
}
catch {
retMsg = new ReturnMessage(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")), mcm);
}
return(retMsg);
} // SyncProcessMessage
public void ProcessMessage(IMessage msg,
ITransportHeaders requestHeaders, Stream requestStream,
out ITransportHeaders responseHeaders, out Stream responseStream)
{
nextClientSink.ProcessMessage(msg, requestHeaders, requestStream,
out responseHeaders, out responseStream);
}
private IMessage SyncProcessMessageOnce(IMessage msg,
Ior target)
{
IIorProfile selectedProfile;
uint reqId;
try {
// allocate (reserve) connection
GiopClientConnectionDesc conDesc =
AllocateConnection(msg, target, out selectedProfile, out reqId);
ITransportHeaders requestHeaders;
Stream requestStream;
SerialiseRequest(msg, selectedProfile, conDesc, reqId,
out requestHeaders, out requestStream);
// pass the serialised GIOP-request to the first stream handling sink
// when the call returns, the response message has been received
ITransportHeaders responseHeaders;
Stream responseStream;
m_nextSink.ProcessMessage(msg, requestHeaders, requestStream,
out responseHeaders, out responseStream);
// now deserialise the response
return(DeserialiseResponse(responseStream,
responseHeaders, msg, conDesc));
} finally {
m_conManager.RequestOnConnectionCompleted(msg); // release the connection, because this interaction is complete
}
}
public IMessage SyncProcessMessage(IMessage msg)
{
try {
ITransportHeaders call_headers = new TransportHeaders();
call_headers[CommonTransportKeys.RequestUri] = ((IMethodCallMessage)msg).Uri;
call_headers["Content-Type"] = "application/octet-stream";
Stream call_stream = _nextInChain.GetRequestStream(msg, call_headers);
if (call_stream == null)
{
call_stream = new MemoryStream();
}
// Serialize msg to the stream
_binaryCore.Serializer.Serialize(call_stream, msg, null);
if (call_stream is MemoryStream)
{
call_stream.Position = 0;
}
Stream response_stream;
ITransportHeaders response_headers;
_nextInChain.ProcessMessage(msg, call_headers, call_stream, out response_headers,
out response_stream);
// Deserialize response_stream
return((IMessage)_binaryCore.Deserializer.DeserializeMethodResponse(response_stream, null, (IMethodCallMessage)msg));
} catch (Exception e) {
return(new ReturnMessage(e, (IMethodCallMessage)msg));
}
}
/// <summary>
/// ProcessMessage encrypt the data stream and send it over
/// to the server and decrypt the response data stream from the server
/// </summary>
/// <param name="msg">IMessage object</param>
/// <param name="requestHeaders">header object for the request</param>
/// <param name="requestStream">request stream</param>
/// <param name="responseHeaders">output parameter containing the response header information</param>
/// <param name="responseStream">response stream</param>
public void ProcessMessage(
IMessage msg, ITransportHeaders requestHeaders, Stream requestStream,
out ITransportHeaders responseHeaders, out Stream responseStream)
{
string identity = cc.GetIdentityByURI(destination.AbsoluteUri);
//add the sender's identity to request header; to be retrieve on
//the server side
requestHeaders["Identity"] = identity;
//create the encrypted stream for the request
Stream encryptedStream = helper.EncryptStream(identity, sinkType, requestHeaders, requestStream);
//pass the encrypted request to next sink of the chain
next.ProcessMessage(
msg, requestHeaders, encryptedStream,
out responseHeaders, out responseStream);
//retrieve the identity information om server side
identity = responseHeaders["Identity"].ToString();
//decrypt the response stream
Stream decryptedStream = helper.DecryptStream(identity, sinkType, responseHeaders, responseStream);
//set the output parameter responseStream to the decrypted stream
responseStream = decryptedStream;
}
public IMessage SyncProcessMessage(IMessage msg)
{
IMethodCallMessage call = (IMethodCallMessage)msg;
// we catch all exceptions to return them as message
try {
// create a new header
TransportHeaders req_headers = new TransportHeaders();
//fixme: set some header values
Stream out_stream = new MemoryStream();
// serialize msg to the stream
format.SerializeRequest(out_stream, msg);
// call the next sink
ITransportHeaders resp_headers;
Stream resp_stream;
nextInChain.ProcessMessage(msg, req_headers, out_stream, out resp_headers,
out resp_stream);
// deserialize resp_stream
IMessage result = (IMessage)format.DeserializeResponse(resp_stream, call);
// it's save to close the stream now
resp_stream.Close();
return(result);
} catch (Exception e) {
return(new ReturnMessage(e, call));
}
}
public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream,
out ITransportHeaders responseHeaders, out Stream responseStream)
{
// помещаем имя серверного хоста или его IP-адрес в заголовки запроса
requestHeaders["serverHostNameOrIp"] = _serverHostNameOrIp;
// перенаправляем вызов следующему приемнику в стеке
_nextSink.ProcessMessage(msg, requestHeaders, requestStream,
out responseHeaders, out responseStream);
}
public void ProcessMessage(IMessage msg,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
SetSinkProperties(msg);
_nextSink.ProcessMessage(msg, requestHeaders, requestStream,
out responseHeaders, out responseStream);
}
void IClientChannelSink.ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, System.IO.Stream requestStream, out ITransportHeaders responseHeaders, out System.IO.Stream responseStream)
{
if (!encrHelper.HasKey)
{
ITransportHeaders encrHeaders = new TransportHeaders();
System.IO.MemoryStream encrStream = new System.IO.MemoryStream();
encrHelper.Initiate(encrHeaders);
ITransportHeaders encredHeaders;
System.IO.Stream encredStream;
try
{
nextSink.ProcessMessage(msg, encrHeaders, encrStream, out encredHeaders, out encredStream);
encrHelper.Finalize(encredHeaders);
}
catch (Exception ex)
{
encrHelper = new EncryptionHelper();
}
}
/*System.IO.MemoryStream memStream = EncryptionHelper.ToMemoryStream(requestStream);
* string text = new string(System.Text.UTF8Encoding.UTF8.GetChars(memStream.ToArray()));
* requestStream = memStream;*/
encrHelper.Encrypt(requestHeaders, ref requestStream);
nextSink.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
if (EncryptionHelper.IsEncrypted(responseHeaders))
{
encrHelper.Decrypt(responseHeaders, ref responseStream);
}
else
{
encrHelper = new EncryptionHelper();
}
/*
* System.IO.MemoryStream respStream = EncryptionHelper.ToMemoryStream(responseStream);
* text = new string(System.Text.UTF8Encoding.UTF8.GetChars(respStream.ToArray()));
* responseStream = respStream;*/
}
public void ProcessMessage(IMessage msg,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
_next.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
Exception ex = GetExceptionIfNecessary(ref responseHeaders, ref responseStream);
if (ex != null)
{
throw ex;
}
}
/// <summary>
/// Fordert einen gemeinsamen Schlüssel vom Server an.
/// </summary>
/// <param name="msg">Original-Remoting-Nachricht</param>
/// <returns>Verschlüsselungsanbieter</returns>
private SymmetricAlgorithm ObtainSharedKey(IMessage msg)
{
// Anfrage-Transport-Header-Auflistung erzeugen
TransportHeaders requestHeaders = new TransportHeaders();
// Anfrage-Datenstrom erzeugen
MemoryStream requestStream = new MemoryStream();
// Variable für Antwort-Header-Auflistung
ITransportHeaders responseHeaders;
// Variable für Antwort-Datenstrom
Stream responseStream;
// Anfrage nach Gemeinsamen Schlüssel erzeugen
CreateSharedKeyRequest(requestHeaders);
// Anforderungsnachricht für gemeinsamen Schlüssel über die Senkenkette versenden
_next.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
// Antwort vom Server verarbeiten
return(ProcessSharedKeyResponse(responseHeaders));
}
/// <summary>
/// Creates an RSA key pair. Sends a message to the server secure sink which includes
/// the public key from the pair along with a newly created GUID to identify this client
/// to the server. The server responds with an encrypted shared key which can be used for
/// further communications between this client and server.
/// </summary>
/// <param name="msg">The original message passed to the sink.</param>
/// <returns>Byte array containing shared key</returns>
private SymmetricAlgorithm ObtainSharedKey(IMessage msg)
{
// We create new headers and a new stream for this roundtrip to the server.
// We don't need to use any headers that may have already been added to the collection
// because we can reasonably assume that they are destined for the server side sink paired
// with the client sink that created them; we're stopping at our matching server side
// sink and as sink order is most-likely mirrored on the server, any existing headers won't be
// used anyway (unless our assumption is incorrect and they are actually destined
// for an unrelated sink, but if that's the case, oh well).
TransportHeaders requestHeaders = new TransportHeaders();
MemoryStream requestStream = new MemoryStream();
ITransportHeaders responseHeaders;
Stream responseStream;
// Create the headers and stream for a shared-key request
CreateSharedKeyRequest(requestHeaders);
// Send the message. We do this by sending the message along the sink chain
// as if this were the real message.
_next.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
// Processes the response headers and pulls from them a symmetric algorithm
return(ProcessSharedKeyResponse(responseHeaders));
}
/// <summary>
/// Process a message synchronously.
/// </summary>
/// <param name="msg">Remoting message</param>
/// <param name="requestHeaders">Request transport headers</param>
/// <param name="requestStream">Request stream</param>
/// <param name="responseHeaders">Response transport headers</param>
/// <param name="responseStream">Response straem</param>
public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, System.IO.Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
{
requestStream = CreateEnvelope(requestStream, requestHeaders);
_nextSink.ProcessMessage
(
msg,
requestHeaders,
requestStream,
out responseHeaders,
out responseStream
);
responseStream = OpenEnvelope(responseStream, responseHeaders);
}
public void ProcessMessage(IMessage msg,
ITransportHeaders requestHeaders, Stream requestStream,
out ITransportHeaders responseHeaders, out Stream responseStream)
{
if (myBoolEnabled)
{
LoggingHelper.PrintRequest(myTextWriterOutput, requestHeaders, ref requestStream);
}
myNewNextSink.ProcessMessage(msg, requestHeaders, requestStream,
out responseHeaders, out responseStream);
if (myBoolEnabled)
{
LoggingHelper.PrintResponse(myTextWriterOutput, responseHeaders, ref responseStream);
}
}
public void ProcessMessage(
IMessage msg,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream
)
{
#region call context
if (requestHeaders[ChannelSinkCallContext.ChannelSinkCallContextHeader] == null)
{
ChannelSinkCallContext context = new ChannelSinkCallContext();
context.UserName = Environment.UserDomainName + @"\" + Environment.UserName;
requestHeaders[ChannelSinkCallContext.ChannelSinkCallContextHeader] = ChannelSinkCallContext.SerializeCallContextToString(context);
}
#endregion
_nextSink.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
}
public void ProcessMessage(IMessage message,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
// Print the request message properties.
Console.WriteLine("---- Message from the client ----");
IDictionary dictionary = message.Properties;
foreach (Object key in dictionary.Keys)
{
Console.WriteLine("{0} = {1}", key, dictionary[key]);
}
Console.WriteLine("---------------------------------");
// Hand off to the next sink in the chain.
nextSink.ProcessMessage(message, requestHeaders, requestStream, out responseHeaders, out responseStream);
}
public void ProcessMessage(
IMessage msg,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream
)
{
#region crypto request stream
requestStream = CryptoHelper.CryptoStream(ref requestStream);
#endregion
_nextSink.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
#region decrypt response stream
//throw new Exception("Client Side : response stream header checksum error");
#endregion
}
private IMessage SerializeAndProcessMessage(IMessage msg, IMethodCallMessage mcm)
{
ITransportHeaders headers;
Stream stream;
SerializeRequest(msg, out headers, out stream);
ITransportHeaders responseHeaders;
Stream responseStream;
nextSink.ProcessMessage(msg, headers, stream, out responseHeaders, out responseStream);
if (responseHeaders == null)
{
throw new ArgumentException("returnHeaders should not be null");
}
IMessage retVal = DeserializeResponse(mcm, responseHeaders, responseStream);
return(retVal);
}
