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 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"); IMethodCallMessage methodCall = state as IMethodCallMessage; if (methodCall == null) throw new NotSupportedException(); IMethodReturnMessage methodReturn; try { // deserialize response methodReturn = _formatter.DeserializeResponse(methodCall, responseHeaders, responseStream); responseStream.Close(); } catch (Exception ex) { methodReturn = new ReturnMessage(ex, methodCall); } // dispatch response sinkStack.DispatchReplyMessage(methodReturn); }
public void AsyncProcessResponse (IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { throw new NotImplementedException (); }
public void AsyncProcessResponse (IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { Console.WriteLine ("ClientTransport: AsyncProcessResponse"); throw new NotSupportedException(); }
} // AsyncProcessRequest /// <include file='doc\SoapFormatterSinks.uex' path='docs/doc[@for="SoapClientFormatterSink.AsyncProcessResponse"]/*' /> public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, Object state, ITransportHeaders headers, Stream stream) { // previously we stored the outgoing message in state IMethodCallMessage mcm = (IMethodCallMessage)state; IMessage retMsg = DeserializeMessage(mcm, headers, stream); sinkStack.DispatchReplyMessage(retMsg); } // AsyncProcessRequest
/// <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, object state, ITransportHeaders headers, Stream stream) { // Send the request to the server. sinkStack.AsyncProcessResponse(headers, stream); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { IMessage replyMessage = (IMessage)_binaryCore.Deserializer.DeserializeMethodResponse(stream, null, (IMethodCallMessage)state); sinkStack.DispatchReplyMessage(replyMessage); }
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); }
/// <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 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) { IMessage reqMessage = (IMessage) state; IMessage replyMessage = (IMessage) IceChannelUtils.ProtocolReplyToMessage (stream, reqMessage); stream.Close(); sinkStack.DispatchReplyMessage (replyMessage); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { IMessage reqMessage = (IMessage)state; IMessage replyMessage = (IMessage)IceChannelUtils.ProtocolReplyToMessage(stream, reqMessage); stream.Close(); sinkStack.DispatchReplyMessage(replyMessage); }
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) { CallData data = (CallData)state; SoapMessageFormatter soapMsgFormatter = data.Formatter; IMessage replyMessage = (IMessage)DeserializeMessage( stream, headers, (IMethodCallMessage)data.Msg, soapMsgFormatter); sinkStack.DispatchReplyMessage(replyMessage); }
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_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) { 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, object state, ITransportHeaders headers, Stream stream) { // client side formatter is the last sink in the chain accessing the serialised message, therefore this method is called on the return path AsyncProcessingData asyncData = (AsyncProcessingData)state; // retrieve the request msg stored on the channelSinkStack IMessage requestMsg = asyncData.RequestMsg; try { IMessage responseMsg; try { GiopClientConnectionDesc conDesc = (GiopClientConnectionDesc)asyncData.ConDesc; responseMsg = DeserialiseResponse(stream, headers, requestMsg, conDesc); } finally { m_conManager.RequestOnConnectionCompleted(requestMsg); // release the connection, because this interaction is complete } sinkStack.DispatchReplyMessage(responseMsg); // dispatch the result message to the message handling reply sink chain } catch (Exception e) { sinkStack.DispatchException(e); // dispatch the exception to the message handling reply sink chain } }
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 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"); } IMethodCallMessage methodCall = state as IMethodCallMessage; if (methodCall == null) { throw new NotSupportedException(); } IMethodReturnMessage methodReturn; try { // deserialize response methodReturn = _formatter.DeserializeResponse(methodCall, responseHeaders, responseStream); responseStream.Close(); } catch (Exception ex) { methodReturn = new ReturnMessage(ex, methodCall); } // dispatch response sinkStack.DispatchReplyMessage(methodReturn); }
/// <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); }
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); } }
void IClientChannelSink.AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, System.IO.Stream stream) { nextSink.AsyncProcessResponse(sinkStack, state, headers, stream); }
public void AsyncProcessResponse( IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { throw new RemotingException("AsyncProcessRequest is not enabled yet"); }
/// <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) { // Should never be called throw new NotSupportedException (); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, Object state, ITransportHeaders headers, Stream stream) { // We don't have to implement this since we are always last in the chain. throw new NotSupportedException(); } // AsyncProcessRequest
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { // перенаправляем вызов следующему приемнику в стеке 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); }
/// <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); }
/// <summary> /// Not supported. As this sink should be the first in the chain it only implmenets IMessageSink. /// </summary> public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, System.IO.Stream stream) { // Should not be called if first in chain. throw new NotSupportedException(); }
public void AsyncProcessResponse( IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { // Send the request to the server. sinkStack.AsyncProcessResponse(headers, stream); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders responseHeaders, Stream responseStream) { // never called because the client transport sink is always last in the chain throw new NotSupportedException(); }
/// <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); }
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, System.IO.Stream stream) { }
/// <summary> /// Requests asynchronous processing of a response to a method call on the current sink. /// </summary> /// <param name="sinkStack"><see cref="IClientResponseChannelSinkStack"/> to process the response.</param> /// <param name="state">State object.</param> /// <param name="headers"><see cref="ITransportHeaders"/> of the response message.</param> /// <param name="stream"><see cref="Stream"/> with the serialized response message.</param> public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { // we're the last sink in the chain, so we don't have to implement this throw new NotImplementedException(); }
public void AsyncProcessResponse (IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { IMessage replyMessage = (IMessage)_binaryCore.Deserializer.DeserializeMethodResponse (stream, null, (IMethodCallMessage)state); sinkStack.DispatchReplyMessage (replyMessage); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { throw new RemotingException("Wrong sequence in config file - clientProviders"); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { throw new NotSupportedException(); }
/// <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, object state, ITransportHeaders headers, Stream stream) { IMethodCallMessage mcm = (IMethodCallMessage) state; IMessage msg = this.DeserializeMessage(mcm, headers, stream); sinkStack.DispatchReplyMessage(msg); }
void IClientChannelSink.AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, System.IO.Stream stream) { nextSink.AsyncProcessResponse(sinkStack, state, headers, stream); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { throw new WrongConfigSequenceException(); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack , object state , ITransportHeaders headers , Stream stream) { var methodCallMessage = (IMethodCallMessage)state; var responseMessage = DeserializeResponseMessage(methodCallMessage, headers, stream); sinkStack.DispatchReplyMessage(responseMessage); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { stream = Zip.Decompress(stream); sinkStack.AsyncProcessResponse(headers, stream); }
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders responseHeaders, Stream responseStream) { // never called because the client transport sink is always last in the chain throw new NotSupportedException(); }
/// <summary> /// Not supported. As this sink should be the first in the chain it only implmenets IMessageSink. /// </summary> public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, System.IO.Stream stream) { // Should not be called if first in chain. throw new NotSupportedException(); }
void IClientChannelSink.AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { throw new NotSupportedException(); }
public void AsyncProcessResponse (IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { CallData data = (CallData) state; SoapMessageFormatter soapMsgFormatter = data.Formatter; IMessage replyMessage = (IMessage) DeserializeMessage ( stream, headers, (IMethodCallMessage) data.Msg, soapMsgFormatter); sinkStack.DispatchReplyMessage (replyMessage); }
/// <summary></summary> public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream) { throw new RemotingException("Wrong sequence in config file - clientProviders"); }
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); }
} // ProcessResponseException public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, Object state, ITransportHeaders headers, Stream stream) { // We don't have to implement this since we are always last in the chain. } // AsyncProcessRequest
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) { // previously we stored the outgoing message in state IMethodCallMessage mcm = (IMethodCallMessage)state; IMessage retMsg = DeserializeMessage(mcm, headers, stream); sinkStack.DispatchReplyMessage(retMsg); } // AsyncProcessRequest
public void AsyncProcessResponse(IClientResponseChannelSinkStack myClientChannelSinkStack, Object state, ITransportHeaders headers, Stream stream) { }