public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack_in,
object state_in,
ITransportHeaders headers_in,
Stream stream_in
)
{
#region decrypt...
if (isHeaderEncrypted(headers_in))
{
stream_in
= EncryptionHelper.Decrypt(
stream_in,
false,
this.keyspath_,
this.clientid_
);
}
#endregion
sinkStack_in.AsyncProcessResponse(
headers_in,
stream_in
);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// process response como no lo he visto ejecutarse, mas vale prevenir.
if (!stream.CanWrite)
{
try
{
AbrirStream(ref stream);
}
catch
{
AbrirStream(ref stream,
System.Convert.ToInt32((string)headers["TamañoComprimido"]));
}
}
ProcessResponse(null, headers, ref stream, state);
try
{
sinkStack.AsyncProcessResponse(headers, stream);
}
catch (Exception e)
{
Console.Write(e.Message);
}
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
RequestState rs = state as RequestState;
if (rs != null && rs.didCompress)
{
bool compressOK = object.Equals(headers[CompressionHelper.CompressKey], CompressionHelper.CompressedFlag);
if (!compressOK)
{
serverCanCompress = false;
checkedCompress = true;
// synchronously send the message now
rs.origStream.Position = rs.origPos;
ProcessMessage(rs.msg, rs.headers, rs.origStream, out headers, out stream);
}
else
{
// decompress stuff
stream = CompressionHelper.DecompressStream(stream);
serverCanCompress = true;
checkedCompress = true;
}
rs.origStream.Close();
}
// process through the rest of the stacks
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack,
object state,
ITransportHeaders headers,
Stream stream)
{
// Send the request to the server.
sinkStack.AsyncProcessResponse(headers, stream);
}
/// <summary>
/// Requests asynchronous processing of a response to a method call on the current sink.
/// </summary>
/// <param name="sinkStack">A stack of sinks that called this sink.</param>
/// <param name="state">Information generated on the request side that is associated with this sink.</param>
/// <param name="headers">The headers retrieved from the server response stream.</param>
/// <param name="stream">The stream coming back from the transport sink.</param>
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// Gets the asynchronous processing state
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
SecureTransactionStage currentStage = (SecureTransactionStage)Convert.ToInt32((string)headers[CommonHeaderNames.SECURE_TRANSACTION_STATE]);
switch (currentStage)
{
case SecureTransactionStage.SendingEncryptedResult: // Get the encrypted response from the server
lock (_lockObject)
{
if (asyncState.SecureTransactionID.Equals(_secureTransactionID))
{
stream = DecryptResponse(stream, headers);
}
else
{
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_KeyChanged);
}
}
break;
case SecureTransactionStage.UnknownTransactionID: // Bad transaction identifier
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_InvalidTransactionID);
default:
case SecureTransactionStage.Uninitialized: // Secure transaction is not yet set up
break;
}
}
catch (CryptoRemotingException)
{
lock (_lockObject)
{
// If remote transaction identifier matches the local secure transaction identifier, reset the shared key
if (_provider == null || asyncState.SecureTransactionID.Equals(_secureTransactionID))
{
ClearSharedKey();
}
ProcessMessage(asyncState.Message, asyncState.Headers, asyncState.Stream, out headers, out stream);
}
}
finally
{
// Close the input stream
asyncState.Stream.Close();
}
// Pass on to the next sink to continue processing
sinkStack.AsyncProcessResponse(headers, stream);
}
/// <summary>
/// Requests asynchronous processing of a response to a method call on the current sink.
/// </summary>
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state,
ITransportHeaders headers, Stream stream)
{
// process response
ProcessResponse(headers, ref stream);
// forward to the next
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack stack,
object state,
ITransportHeaders headers,
Stream stream
)
{
stack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack,
object state,
ITransportHeaders responseHeaders,
Stream responseStream)
{
Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} 异步请求处理完毕：{state}");
sinkStack.AsyncProcessResponse(responseHeaders, responseStream);
}
void IClientChannelSink.AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state,
ITransportHeaders headers, Stream stream)
{
// process response
ProcessResponse(null, headers, ref stream, state);
// forward to the next
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
SecureTransaction transactType = (SecureTransaction)Convert.ToInt32((string)headers[CommonHeaders.Transaction]);
switch (transactType)
{
case SecureTransaction.SendingEncryptedResult:
{
lock (_transactionLock)
{
if (asyncState.ID.Equals(_transactID))
{
stream = DecryptResponse(stream, headers);
}
else
{
throw new SecureRemotingException("The key has changed since the message was decrypted.");
}
}
break;
}
case SecureTransaction.UnknownIdentifier:
{
throw new SecureRemotingException("The server sink was unable to identify the client, most likely due to the connection information timing out.");
}
default:
case SecureTransaction.Uninitialized:
{
break;
}
}
}
catch (SecureRemotingException)
{
lock (_transactionLock)
{
if (_provider == null || asyncState.ID.Equals(_transactID))
{
ClearSharedKey();
}
ProcessMessage(asyncState.Message, asyncState.Headers, asyncState.Stream, out headers, out stream);
}
}
finally
{
asyncState.Stream.Close();
}
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack,
object state,
ITransportHeaders headers,
Stream stream)
{
// deflate the response
stream =
CompressionHelper.getUncompressedStreamCopy(stream);
// forward the request
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack,
object state, ITransportHeaders headers, Stream stream)
{
if (_asyncMessage != null)
{
try{
object objCacheLimit = headers["X-Cache"];
if (objCacheLimit != null && Convert.ToInt32(objCacheLimit) > 0)
{
byte[] response = ExtractContents(stream);
cache.CacheResults(_asyncMessage, _asyncHeaders,
new RemotingResult(response, headers, DateTime.UtcNow + TimeSpan.FromSeconds(Convert.ToInt32(objCacheLimit))), true);
sinkStack.AsyncProcessResponse(headers, new MemoryStream(response));
}
}
catch (Exception) {
sinkStack.AsyncProcessResponse(headers, stream);
}
}
else
{
sinkStack.AsyncProcessResponse(headers, stream);
}
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack,
object state,
ITransportHeaders headers,
Stream stream)
{
Exception ex = GetExceptionIfNecessary(ref headers, ref stream);
if (ex != null)
{
sinkStack.DispatchException(ex);
}
else
{
sinkStack.AsyncProcessResponse(headers, stream);
}
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack,
object state,
ITransportHeaders headers,
Stream stream)
{
// decompress the stream if necessary
String xcompress = (String)headers["X-Compress"];
if (xcompress != null && xcompress == "yes")
{
stream = CompressionHelper.GetUncompressedStreamCopy(stream);
}
// forward the request
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack stack,
object state,
ITransportHeaders headers,
Stream stream
)
{
#region Check response stream hash
string hash = headers[HashHelper.C_HASH_ITEM] as string;
//Debug.WriteLine("Client Side : response stream hash is " + hash);
bool check = HashHelper.CheckHash(ref stream, hash);
if (!check)
{
throw new Exception("Client Side : response stream header checksum error");
}
#endregion
stack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack,
object state,
ITransportHeaders headers,
Stream stream)
{
if (headers["X-Encrypt"] != null && headers["X-Encrypt"].Equals("yes"))
{
byte[] IV =
Convert.FromBase64String((String)headers["X-EncryptIV"]);
stream = EncryptionHelper.ProcessInboundStream(
stream,
_encryptionAlgorithm,
_encryptionKey,
IV);
}
// forward the request
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack_in,
object state_in,
ITransportHeaders headers_in,
Stream stream_in
)
{
#region uncompress...
if (isHeaderCompressed_(headers_in))
{
stream_in
= CompressionHelper.GetUncompressedStreamCopy(
stream_in
);
}
#endregion
sinkStack_in.AsyncProcessResponse(
headers_in,
stream_in
);
}
/// <summary>
/// Verarbeitet eine Antwort-Nachricht asynchron.
/// </summary>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="state">Asynchroner Verarbeitungsstatus</param>
/// <param name="headers">Anfrage-Header-Auflistung</param>
/// <param name="stream">Anfrage-Datenstrom</param>
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// Asychronen Verarbeitungsstatus abrufen
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
lock (_lockObject)
{
//Todo: Was ist hier zu tun?
}
}
finally
{
}
ProcessMessage(asyncState.Message, asyncState.Headers, asyncState.Stream, out headers, out stream);
asyncState.Stream.Close();
// Verarbeitung in der nächsten Kanalsenke fortsetzen
sinkStack.AsyncProcessResponse(headers, stream);
}
/// <summary>
/// Processes an asynchronous response.
/// </summary>
/// <param name="sinkStack">Channel sink stack</param>
/// <param name="state">State data</param>
/// <param name="headers">Transport headers</param>
/// <param name="stream">Response stream</param>
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
stream = OpenEnvelope(stream, headers);
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
stream = Zip.Decompress(stream);
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack_in,
object state_in,
ITransportHeaders headers_in,
Stream stream_in
) {
#region decrypt...
if (isHeaderEncrypted(headers_in)) {
stream_in
= EncryptionHelper.Decrypt(
stream_in,
false,
this.keyspath_,
this.clientid_
);
}
#endregion
sinkStack_in.AsyncProcessResponse(
headers_in,
stream_in
);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
SecureTransaction transactType = (SecureTransaction)Convert.ToInt32((string)headers[CommonHeaders.Transaction]);
switch (transactType)
{
case SecureTransaction.SendingEncryptedResult:
{
lock (_transactionLock)
{
if (asyncState.ID.Equals(_transactID))
{
stream = DecryptResponse(stream, headers);
}
else
{
throw new SecureRemotingException("The key has changed since the message was decrypted.");
}
}
break;
}
case SecureTransaction.UnknownIdentifier:
{
throw new SecureRemotingException("The server sink was unable to identify the client, most likely due to the connection information timing out.");
}
default:
case SecureTransaction.Uninitialized:
{
break;
}
}
}
catch (SecureRemotingException)
{
lock (_transactionLock)
{
if (_provider == null || asyncState.ID.Equals(_transactID))
{
ClearSharedKey();
}
ProcessMessage(asyncState.Message, asyncState.Headers, asyncState.Stream, out headers, out stream);
}
}
finally
{
asyncState.Stream.Close();
}
sinkStack.AsyncProcessResponse(headers, stream);
}
/// <summary>Requests asynchronous processing of a response to a method call on the current sink.</summary>
/// <param name="sinkStack">A stack of sinks that called this sink.</param>
/// <param name="state">Information generated on the request side that is associated with this sink.</param>
/// <param name="headers">The headers retrieved from the server response stream.</param>
/// <param name="stream">The stream coming back from the transport sink.</param>
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// Get the async state we put on the stack
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
// Decrypt the response if possible
SecureTransaction transactType = (SecureTransaction)Convert.ToInt32((string)headers[CommonHeaders.Transaction]);
switch(transactType)
{
// The only valid value; the server is sending results encrypted,
// so we need to decrypt them
case SecureTransaction.SendingEncryptedResult:
lock(_transactionLock)
{
if (asyncState.ID.Equals(_transactID)) stream = DecryptResponse(stream, headers);
else throw new SecureRemotingException("The key has changed since the message was decrypted.");
}
break;
// The server has no record of the client, so error out.
// If this were synchronous, we could try again, first renewing
// the connection information. The best we can do here is null
// out our current connection information so that the next time
// through we'll create a new provider and identifier.
case SecureTransaction.UnknownIdentifier:
throw new SecureRemotingException(
"The server sink was unable to identify the client, " +
"most likely due to the connection information timing out.");
// Something happened and the response is not encrypted, i.e. there
// are no transport headers, or at least no transaction header, or it has
// been explicitly set by the server to Uninitialized.
// Regardless, do nothing.
default:
case SecureTransaction.Uninitialized:
break;
}
}
catch(SecureRemotingException)
{
// We got back a secure remoting exceptionIt would be difficult to retry this as an
// asynchronous call as we need to have the output ready to go before
// we return. Thus, we'll make a synchronous one by calling ProcessMessage()
// just as if we were the previous sink. Luckily, we kept all of the
// necessary information sitting around.
lock(_transactionLock) // This is a big, big lock, as are many locks in this app! Oh well.
{
if (_provider == null || asyncState.ID.Equals(_transactID)) ClearSharedKey();
ProcessMessage(
asyncState.Message, asyncState.Headers, asyncState.Stream,
out headers, out stream);
}
}
finally
{
// Close the old stream just in case it hasn't been closed yet.
asyncState.Stream.Close();
}
// Process through the rest of the sinks.
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
CompressSinkHelper.DecompressStream(headers, stream);
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
if (!stream.CanWrite)
{
try
{
OpenStream(ref stream);
}
catch
{
OpenStream(ref stream,
System.Convert.ToInt32( (string)headers["CompressedSize"]) );
}
}
ProcessResponse(null, headers, ref stream, state);
try
{
sinkStack.AsyncProcessResponse(headers, stream);
}
catch (Exception e)
{
Console.Write(e.Message);
}
}
/// <summary>
/// Verarbeitet eine Antwort-Nachricht asynchron.
/// </summary>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="state">Asynchroner Verarbeitungsstatus</param>
/// <param name="headers">Anfrage-Header-Auflistung</param>
/// <param name="stream">Anfrage-Datenstrom</param>
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// Asychronen Verarbeitungsstatus abrufen
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
lock (_lockObject)
{
//Todo: Was ist hier zu tun?
}
}
finally
{
}
ProcessMessage(asyncState.Message, asyncState.Headers, asyncState.Stream, out headers, out stream);
asyncState.Stream.Close();
// Verarbeitung in der nächsten Kanalsenke fortsetzen
sinkStack.AsyncProcessResponse(headers, stream);
}
/// <summary>
/// Verarbeitet eine Antwort-Nachricht asynchron.
/// </summary>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="state">Asynchroner Verarbeitungsstatus</param>
/// <param name="headers">Anfrage-Header-Auflistung</param>
/// <param name="stream">Anfrage-Datenstrom</param>
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// Asychronen Verarbeitungsstatus abrufen
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
// Aktuellen Verarbeitungsschritt der Sicherheitstransaktion ermitteln
SecureTransactionStage currentStage = (SecureTransactionStage)Convert.ToInt32((string)headers[CommonHeaderNames.SECURE_TRANSACTION_STATE]);
// Verarbeitungsschritt auswerten
switch (currentStage)
{
case SecureTransactionStage.SendingEncryptedResult: // Verschlüsselte Daten vom Server eingtroffen
lock (_lockObject)
{
// Wenn die Antwort auch tatsächlich zur aktuellen Sicherheitstransaktion gehört ...
if (asyncState.SecureTransactionID.Equals(_secureTransactionID))
{
// Datenstrom entschlüsseln
stream = DecryptResponse(stream, headers);
}
// Andernfalls ...
else
{
// Ausnahme werfen
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_KeyChanged);
}
}
break;
case SecureTransactionStage.UnknownTransactionID: // Unbekannte Transaktionskennung
// Ausnahme werfen
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_InvalidTransactionID);
default:
case SecureTransactionStage.Uninitialized: // Keine Sicherheitstransaktion eingerichtet
break;
}
}
catch (CryptoRemotingException)
{
lock (_lockObject)
{
// Wenn die gesendete Transaktionskennung mit der lokalen übereinstimmt ...
if (_provider == null || asyncState.SecureTransactionID.Equals(_secureTransactionID))
{
// Gemeinamen Schlüssel löschen
ClearSharedKey();
}
// Nachricht weiterverarbeiten
ProcessMessage(asyncState.Message, asyncState.Headers, asyncState.Stream, out headers, out stream);
}
}
finally
{
// Datenstrom schließen
asyncState.Stream.Close();
}
// Verarbeitung in der nächsten Kanalsenke fortsetzen
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack,
object state,
ITransportHeaders headers,
Stream stream)
{
// Send the request to the server.
sinkStack.AsyncProcessResponse(headers, stream);
}
/// <summary>
/// Requests asynchronous processing of a response to a method call on the current sink.
/// </summary>
/// <param name="sinkStack">A stack of sinks that called this sink.</param>
/// <param name="state">Information generated on the request side that is associated with this sink.</param>
/// <param name="headers">The headers retrieved from the server response stream.</param>
/// <param name="stream">The stream coming back from the transport sink.</param>
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// Gets the asynchronous processing state
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
SecureTransactionStage currentStage = (SecureTransactionStage)Convert.ToInt32((string)headers[CommonHeaderNames.SECURE_TRANSACTION_STATE]);
switch (currentStage)
{
case SecureTransactionStage.SendingEncryptedResult: // Get the encrypted response from the server
lock (_lockObject)
{
if (asyncState.SecureTransactionID.Equals(_secureTransactionID))
stream = DecryptResponse(stream, headers);
else
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_KeyChanged);
}
break;
case SecureTransactionStage.UnknownTransactionID: // Bad transaction identifier
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_InvalidTransactionID);
default:
case SecureTransactionStage.Uninitialized: // Secure transaction is not yet set up
break;
}
}
catch (CryptoRemotingException)
{
lock (_lockObject)
{
// If remote transaction identifier matches the local secure transaction identifier, reset the shared key
if (_provider == null || asyncState.SecureTransactionID.Equals(_secureTransactionID))
ClearSharedKey();
ProcessMessage(asyncState.Message, asyncState.Headers, asyncState.Stream, out headers, out stream);
}
}
finally
{
// Close the input stream
asyncState.Stream.Close();
}
// Pass on to the next sink to continue processing
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack_in,
object state_in,
ITransportHeaders headers_in,
Stream stream_in
) {
#region uncompress...
if (isHeaderCompressed_(headers_in)) {
stream_in
= CompressionHelper.GetUncompressedStreamCopy(
stream_in
);
}
#endregion
sinkStack_in.AsyncProcessResponse(
headers_in,
stream_in
);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state,
ITransportHeaders headers, Stream stream)
{
// перенаправляем вызов следующему приемнику в стеке
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state,
ITransportHeaders headers, Stream stream)
{
// перенаправляем вызов следующему приемнику в стеке
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// process response como no lo he visto ejecutarse, mas vale prevenir.
if (!stream.CanWrite)
{
try
{
AbrirStream(ref stream);
}
catch
{
AbrirStream(ref stream,
System.Convert.ToInt32( (string)headers["TamañoComprimido"]) );
}
}
ProcessResponse(null, headers, ref stream, state);
try
{
sinkStack.AsyncProcessResponse(headers, stream);
}
catch (Exception e)
{
Console.Write(e.Message);
}
}
/// <summary>Requests asynchronous processing of a response to a method call on the current sink.</summary>
/// <param name="sinkStack">A stack of sinks that called this sink.</param>
/// <param name="state">Information generated on the request side that is associated with this sink.</param>
/// <param name="headers">The headers retrieved from the server response stream.</param>
/// <param name="stream">The stream coming back from the transport sink.</param>
public void AsyncProcessResponse(
IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// Get the async state we put on the stack
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
// Decrypt the response if possible
SecureTransaction transactType = (SecureTransaction)Convert.ToInt32((string)headers[CommonHeaders.Transaction]);
switch (transactType)
{
// The only valid value; the server is sending results encrypted,
// so we need to decrypt them
case SecureTransaction.SendingEncryptedResult:
lock (_transactionLock)
{
if (asyncState.ID.Equals(_transactID))
{
stream = DecryptResponse(stream, headers);
}
else
{
throw new SecureRemotingException("The key has changed since the message was decrypted.");
}
}
break;
// The server has no record of the client, so error out.
// If this were synchronous, we could try again, first renewing
// the connection information. The best we can do here is null
// out our current connection information so that the next time
// through we'll create a new provider and identifier.
case SecureTransaction.UnknownIdentifier:
throw new SecureRemotingException(
"The server sink was unable to identify the client, " +
"most likely due to the connection information timing out.");
// Something happened and the response is not encrypted, i.e. there
// are no transport headers, or at least no transaction header, or it has
// been explicitly set by the server to Uninitialized.
// Regardless, do nothing.
default:
case SecureTransaction.Uninitialized:
break;
}
}
catch (SecureRemotingException)
{
// We got back a secure remoting exceptionIt would be difficult to retry this as an
// asynchronous call as we need to have the output ready to go before
// we return. Thus, we'll make a synchronous one by calling ProcessMessage()
// just as if we were the previous sink. Luckily, we kept all of the
// necessary information sitting around.
lock (_transactionLock) // This is a big, big lock, as are many locks in this app! Oh well.
{
if (_provider == null || asyncState.ID.Equals(_transactID))
{
ClearSharedKey();
}
ProcessMessage(
asyncState.Message, asyncState.Headers, asyncState.Stream,
out headers, out stream);
}
}
finally
{
// Close the old stream just in case it hasn't been closed yet.
asyncState.Stream.Close();
}
// Process through the rest of the sinks.
sinkStack.AsyncProcessResponse(headers, stream);
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
RequestState rs = state as RequestState;
if (rs != null && rs.didCompress) {
bool compressOK = object.Equals(headers[CompressionHelper.CompressKey], CompressionHelper.CompressedFlag);
if (!compressOK) {
serverCanCompress = false;
checkedCompress = true;
// synchronously send the message now
rs.origStream.Position = rs.origPos;
ProcessMessage(rs.msg, rs.headers, rs.origStream, out headers, out stream);
}
else {
// decompress stuff
stream = CompressionHelper.DecompressStream(stream);
serverCanCompress = true;
checkedCompress = true;
}
rs.origStream.Close();
}
// process through the rest of the stacks
sinkStack.AsyncProcessResponse(headers, stream);
}
/// <summary>
/// Verarbeitet eine Antwort-Nachricht asynchron.
/// </summary>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="state">Asynchroner Verarbeitungsstatus</param>
/// <param name="headers">Anfrage-Header-Auflistung</param>
/// <param name="stream">Anfrage-Datenstrom</param>
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
// Asychronen Verarbeitungsstatus abrufen
AsyncProcessingState asyncState = (AsyncProcessingState)state;
try
{
// Aktuellen Verarbeitungsschritt der Sicherheitstransaktion ermitteln
SecureTransactionStage currentStage = (SecureTransactionStage)Convert.ToInt32((string)headers[CommonHeaderNames.SECURE_TRANSACTION_STATE]);
// Verarbeitungsschritt auswerten
switch (currentStage)
{
case SecureTransactionStage.SendingEncryptedResult: // Verschlüsselte Daten vom Server eingtroffen
lock (_lockObject)
{
// Wenn die Antwort auch tatsächlich zur aktuellen Sicherheitstransaktion gehört ...
if (asyncState.SecureTransactionID.Equals(_secureTransactionID))
// Datenstrom entschlüsseln
stream = DecryptResponse(stream, headers);
// Andernfalls ...
else
// Ausnahme werfen
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_KeyChanged);
}
break;
case SecureTransactionStage.UnknownTransactionID: // Unbekannte Transaktionskennung
// Ausnahme werfen
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_InvalidTransactionID);
default:
case SecureTransactionStage.Uninitialized: // Keine Sicherheitstransaktion eingerichtet
break;
}
}
catch (CryptoRemotingException)
{
lock (_lockObject)
{
// Wenn die gesendete Transaktionskennung mit der lokalen übereinstimmt ...
if (_provider == null || asyncState.SecureTransactionID.Equals(_secureTransactionID))
// Gemeinamen Schlüssel löschen
ClearSharedKey();
// Nachricht weiterverarbeiten
ProcessMessage(asyncState.Message, asyncState.Headers, asyncState.Stream, out headers, out stream);
}
}
finally
{
// Datenstrom schließen
asyncState.Stream.Close();
}
// Verarbeitung in der nächsten Kanalsenke fortsetzen
sinkStack.AsyncProcessResponse(headers, stream);
}
