// /// <summary> // /// The time when the listening request was received. // /// </summary> // public int Listener_Opened; #endregion #region -- Disposing ----------------------------------------------------------------------- /// <summary> /// Releases resources. /// </summary> /// <param name="reason">The reason of disposing.</param> public override void InternalDispose(Exception reason) { if (this.Socket != null) { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(SocketUtility.CloseSocket), this.Socket, true); this.Socket = null; } lock (this.PhysicalConnectionStateLock) { if (this.SentContent != null) { this.SentContent.Close(); this.SentContent = null; } if (this.MessagesBeingSent != null) { foreach (Message message in this.MessagesBeingSent) { this.XHttpConnection.ITransportContext.IIncomingStreamHandler.DispatchException(message, reason); } } this.MessagesBeingSent.Clear(); } }
/// <summary> /// Fires the event. /// </summary> /// <param name="genuineEventArgs">The event parameters.</param> public void Fire(GenuineEventArgs genuineEventArgs) { // acquire read access and get a list of the event receivers object[] handlers; using (new ReaderAutoLocker(this._handlersLock)) handlers = this._handlers.ToArray(); foreach (IGenuineEventHandler iGenuineEventHandler in handlers) { try { iGenuineEventHandler.OnGenuineEvent(genuineEventArgs); } catch (Exception) { using (new WriterAutoLocker(this._handlersLock)) this._handlers.Remove(iGenuineEventHandler); } } // fire the global event as well if (genuineEventArgs.EventType == GenuineEventType.GTcpConnectionAccepted) { this.FireGlobalEvent(genuineEventArgs); } else { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.FireGlobalEvent), genuineEventArgs, false); } }
/// <summary> /// Closes the socket. /// </summary> public void CloseSocket() { lock (this._accessToLocalMembers) { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(SocketUtility.CloseSocket), this.Socket, false); this.Socket = null; } }
/// <summary> /// Creates and returns a stream containing decrypted data. /// </summary> /// <param name="input">A stream containing encrypted data.</param> /// <returns>A stream with decrypted data.</returns> public override Stream Decrypt(Stream input) { // check on view whether it's session's packet if (input.ReadByte() == 0) { // continue the Security Session establishing Stream outputStream = this.EstablishSession(input, false); if (outputStream != null) { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.SendMessage), outputStream, false); } return(null); } lock (this) { GenuineChunkedStream output = new GenuineChunkedStream(false); byte[] sign = null; int signSize = 0; if (this.KeyedHashAlgorithm != null) { signSize = this.KeyedHashAlgorithm.HashSize / 8; } // decrypt the content and fetch the sign if (this._decryptor != null) { CryptoStream cryptoStream = new CryptoStream(new FinishReadingStream(output), this._decryptor, CryptoStreamMode.Write); sign = GenuineUtility.CopyStreamToStreamExceptSign(input, cryptoStream, signSize); cryptoStream.FlushFinalBlock(); } else { sign = GenuineUtility.CopyStreamToStreamExceptSign(input, output, signSize); } // check the sign if (this.KeyedHashAlgorithm != null) { if (!ZeroProofAuthorizationUtility.CompareBuffers(sign, this.KeyedHashAlgorithm.ComputeHash(output), sign.Length)) { throw GenuineExceptions.Get_Security_WrongSignature(); } output.Position = 0; } output.ReleaseOnReadMode = true; return(output); } }
/// <summary> /// Creates and returns a stream containing decrypted data. /// </summary> /// <param name="input">A stream containing encrypted data.</param> /// <returns>A stream with decrypted data.</returns> public override Stream Decrypt(Stream input) { if (input.ReadByte() == 0) { Stream outputStream = this.EstablishSession(input, false); if (outputStream != null) { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.SendMessage), outputStream, false); } return(null); } return(this.SspiSecurityContext.DecryptMessage(input, this.KeyProvider_SspiServer.RequiredFeatures)); }
/// <summary> /// Removes all recipients and broadcast senders. /// </summary> public void Clear() { using (WriterAutoLocker writer = new WriterAutoLocker(this._readerWriterLock)) { this._cachedReceiversInfoArray = null; // collect all receivers to unregister the sponsor object[] receiverInfoItems = new object[this._receivers.Count]; this._receivers.Values.CopyTo(receiverInfoItems, 0); GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.UnregisterSponsor), receiverInfoItems, true); this._receivers.Clear(); } }
/// <summary> /// Closes the socket. /// </summary> public void Dispose() { try { lock (this._syncRoot) { if (this.socket != null) { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(SocketUtility.CloseSocket), this.socket, true); this.socket = null; } } } catch { } }
/// <summary> /// Initiates establishing Security Session with specific remote host via specified IConnectionManager. /// </summary> /// <param name="securitySessionParameters">Security Session parameters.</param> public void InitiateEstablishingSecuritySession(SecuritySessionParameters securitySessionParameters) { BinaryLogWriter binaryLogWriter = GenuineLoggingServices.BinaryLogWriter; if (binaryLogWriter != null && binaryLogWriter[LogCategory.Security] > 0) { binaryLogWriter.WriteEvent(LogCategory.Security, "SecuritySession.InitiateEstablishingSecuritySession", LogMessageType.SecuritySessionInitiated, null, null, this.Remote, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, this, this.Name, -1, 0, 0, 0, this.GetType().Name, this.Name, null, null, "Security Session establishing is initiated."); } this.Failed.Reset(); this._establishingSecuritySessionParameters = securitySessionParameters; GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.Internal_InitiateEstablishingSecuritySession), securitySessionParameters, false); }
/// <summary> /// Closes expired connections and sends ping via inactive connections. /// </summary> public void TimerCallback() { int now = GenuineUtility.TickCount; int forcePingAfter = GenuineUtility.ConvertToMilliseconds(this.ITransportContext.IParameterProvider[GenuineParameter.PersistentConnectionSendPingAfterInactivity]); lock (this._persistent.SyncRoot) { // by all connections foreach (DictionaryEntry dictionaryEntry in this._persistent) { SharedMemoryConnection sharedMemoryConnection = (SharedMemoryConnection)dictionaryEntry.Value; if (GenuineUtility.IsTimeoutExpired(sharedMemoryConnection.LastTimeAMessageWasSent + forcePingAfter, now)) { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.SendPing), sharedMemoryConnection, false); } } } }
/// <summary> /// Creates and returns a stream containing decrypted data. /// </summary> /// <param name="input">A stream containing encrypted data.</param> /// <returns>A stream with decrypted data.</returns> public override Stream Decrypt(Stream input) { // check on view whether it's session's packet if (input.ReadByte() == 0) { // continue the Security Session establishing Stream outputStream = this.EstablishSession(input, false); if (outputStream != null) { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.SendMessage), outputStream, false); } return(null); } if (this.RijndaelKey == null) { throw GenuineExceptions.Get_Security_ContextWasNotEstablished(this.Name); } lock (this.RijndaelKey) { if (this._decryptor == null) { Rijndael rijndael = Rijndael.Create(); rijndael.Key = this.RijndaelKey; rijndael.Mode = CipherMode.ECB; this._encryptor = rijndael.CreateEncryptor(); this._decryptor = rijndael.CreateDecryptor(); } } lock (this._decryptor) { GenuineChunkedStream output = new GenuineChunkedStream(true); GenuineUtility.CopyStreamToStream(new CryptoStream(new FinishReadingStream(input), this._decryptor, CryptoStreamMode.Read), output); GenuineUtility.CopyStreamToStream(input, Stream.Null); input.Close(); return(output); } }
/// <summary> /// Removes the receiver or the broadcast sender associated with the specified uri. /// Returns false if there is no such receiver found in the list of receivers. /// </summary> /// <param name="uri">The uri of the receiver.</param> public bool Remove(string uri) { if (uri == null || uri.Length <= 0) { return(false); } using (WriterAutoLocker writer = new WriterAutoLocker(this._readerWriterLock)) { // check if it is in the list if (!this._receivers.ContainsKey(uri)) { return(false); } this._cachedReceiversInfoArray = null; ReceiverInfo receiverInfo = (ReceiverInfo)this._receivers[uri]; this._receivers.Remove(uri); // LOG: BinaryLogWriter binaryLogWriter = GenuineLoggingServices.BinaryLogWriter; if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0) { binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "Dispatcher.Remove", LogMessageType.BroadcastRecipientRemoved, null, null, receiverInfo.DbgRemoteHost, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, false, this, null, true, receiverInfo, uri, null, "The broadcast recipient or \"true\" broadcast sender is removed from the list of recipients."); } // Sponsor is being deleted in another thread; otherwise client disconnection // will cause dispatcher to be freezed for lengthy time out GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.DeleteSponsorFromTheObjectAndFireEvent), receiverInfo, false); } return(true); }
/// <summary> /// Fires the GenuineChannelsGlobalEvent event with the specified parameters. /// </summary> /// <param name="e">Event arguments.</param> public void FireGenuineEvent(GenuineEventArgs e) { // LOG: BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; if (binaryLogWriter != null && binaryLogWriter[LogCategory.ChannelEvent] > 0) { binaryLogWriter.WriteEvent(LogCategory.ChannelEvent, "BasicChannelWithSecurity.FireGenuineEvent", LogMessageType.ChannelEvent, e.SourceException, null, e.HostInformation, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, -1, (int)e.EventType, 0, 0, null, null, null, null, "The channel event is raised."); } if (e.EventType == GenuineEventType.GTcpConnectionAccepted || e.EventType == GenuineEventType.GHttpConnectionAccepted) { this.PerformEventSending(e); } else { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.PerformEventSending), e, false); } }
/// <summary> /// Releases expired host structures. /// </summary> public void TimerCallback() { int now = GenuineUtility.TickCount; HostInformation hostInformation = null; // the released host ArrayList hostsToDelete = new ArrayList(); // the entries being deleted ArrayList urisToDelete = new ArrayList(); lock (this.SyncRoot) { // through all registered hosts foreach (DictionaryEntry entry in this._hashtable) { ArrayList hosts = (ArrayList)entry.Value; for (int i = 0; i < hosts.Count;) { hostInformation = (HostInformation)hosts[i]; // if the time has run out if (GenuineUtility.IsTimeoutExpired(hostInformation.ExpireTime, now) || hostInformation.IsDisposed) { // exclude the host hosts.RemoveAt(i); hostsToDelete.Add(hostInformation); // check on entry excluding if (hosts.Count <= 0) { urisToDelete.Add(entry.Key); } continue; } i++; } } // it is very important to remove all references to the host before disposing it foreach (string key in urisToDelete) { this._hashtable.Remove(key); } // dispose all hosts foreach (HostInformation hostInformationExcluded in hostsToDelete) { // LOG: BinaryLogWriter binaryLogWriter = GenuineLoggingServices.BinaryLogWriter; if (binaryLogWriter != null && binaryLogWriter[LogCategory.HostInformation] > 0) { binaryLogWriter.WriteEvent(LogCategory.HostInformation, "KnownHosts.this[string]", LogMessageType.HostInformationReferencesDisassociated, GenuineExceptions.Get_Debugging_GeneralWarning("The association between HostInformation and its URL or URI has been broken."), null, hostInformationExcluded, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, -1, 0, 0, 0, hostInformationExcluded.Uri, hostInformationExcluded.Url, null, null, "The current HostInformation does not refer to \"{0}\" and \"{1}\" any longer.", hostInformationExcluded.Uri == null ? string.Empty : hostInformationExcluded.Uri, hostInformationExcluded.Url == null ? string.Empty : hostInformationExcluded.Url); } GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.ReleaseHostResources), new HostInformationAndReason(hostInformationExcluded, GenuineExceptions.Get_Channel_ClientDidNotReconnectWithinTimeOut(hostInformationExcluded.ToString())), true); } } }
/// <summary> /// Accepts incoming connections. /// </summary> public void AcceptConnections() { BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; byte protocolVersion; GenuineConnectionType genuineConnectionType; try { IParameterProvider parameters = this.ITransportContext.IParameterProvider; string mutexName = GenuineSharedMemoryChannel.ConstructSharedObjectName( "MUTEX" + this.ShareName, parameters); string clientConnected = GenuineSharedMemoryChannel.ConstructSharedObjectName( "CC" + this.ShareName, parameters); string clientAccepted = GenuineSharedMemoryChannel.ConstructSharedObjectName( "CA" + this.ShareName, parameters); this._mutex = WindowsAPI.CreateMutex(mutexName); this._clientConnectedEvent = NamedEvent.CreateNamedEvent(clientConnected, false, false); this._clientAcceptedEvent = NamedEvent.CreateNamedEvent(clientAccepted, false, true); WaitHandle[] handles = new WaitHandle[2] { this._clientConnectedEvent.ManualResetEvent, this.StopListening }; for ( ; ;) { try { // listen WaitHandle.WaitAny(handles); // if shutting down if (this.StopListening.WaitOne(0, false)) { return; } // set timeout int timeout = GenuineUtility.GetTimeout((TimeSpan)this.ITransportContext.IParameterProvider[GenuineParameter.ConnectTimeout]); // client is connecting using (Stream headerStream = this.SharedMemoryConnection.LowLevel_ReadSync(timeout)) { BinaryReader binaryReader = new BinaryReader(headerStream); string connectionId; MessageCoder.DeserializeConnectionHeader(binaryReader, out protocolVersion, out genuineConnectionType, out connectionId); string shareName = binaryReader.ReadString(); this._clientAcceptedEvent.ManualResetEvent.Set(); // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.AcceptingConnection] > 0) { binaryLogWriter.WriteEvent(LogCategory.AcceptingConnection, "SMAcceptConnectionClosure.AcceptConnections", LogMessageType.ConnectionAccepting, null, null, null, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, -1, 0, 0, 0, null, null, null, null, "An inbound Shared Memory connection is being accepted."); } AcceptConnectionInformation acceptConnectionInformation = new AcceptConnectionInformation(); acceptConnectionInformation.ShareName = shareName; acceptConnectionInformation.ProtocolVersion = protocolVersion; GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.AcceptConnection), acceptConnectionInformation, true); } } catch (Exception ex) { // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.AcceptingConnection] > 0) { binaryLogWriter.WriteEvent(LogCategory.AcceptingConnection, "SMAcceptConnectionClosure.AcceptConnections", LogMessageType.ConnectionAccepting, ex, null, null, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, -1, 0, 0, 0, null, null, null, null, "Can't accept a connection."); } } } } catch (Exception ex) { // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.AcceptingConnection] > 0) { binaryLogWriter.WriteEvent(LogCategory.AcceptingConnection, "SMAcceptConnectionClosure.AcceptConnections", LogMessageType.CriticalError, ex, null, null, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, -1, 0, 0, 0, null, null, null, null, "Critical listener failure. No connections will be accepted."); } this.SharedMemoryConnectionManager.ITransportContext.IGenuineEventProvider.Fire(new GenuineEventArgs(GenuineEventType.GeneralListenerFailure, ex, null, this.ShareName)); } finally { this.SharedMemoryConnection.ReleaseUnmanagedResources(); if (this._mutex != null) { this._mutex.Close(); } } }
/// <summary> /// Sends the invocation to all registered receivers. /// </summary> /// <param name="msg">The message to be sent.</param> public void PerformBroadcasting(IMessage msg) { BinaryLogWriter binaryLogWriter = GenuineLoggingServices.BinaryLogWriter; string methodName = null; string invocationTarget = null; // the first stage of the broadcasting try { ArrayList listOfExcludedReceivers = new ArrayList(); this._iMessage = msg; methodName = BinaryLogWriter.ParseInvocationMethod(msg.Properties["__MethodName"] as string, msg.Properties["__TypeName"] as string); BinaryFormatter formatterForLocalRecipients = null; // serialize the message BinaryFormatter binaryFormatter = new BinaryFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Other)); this._messageStream = new GenuineChunkedStream(false); binaryFormatter.Serialize(this._messageStream, msg); // to trace the message if it could reach the server via several channels string callGuidSubstring = null; if (this._dispatcher.IgnoreRecurrentCalls) { callGuidSubstring = Guid.NewGuid().ToString("N"); } // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0) { binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting", LogMessageType.BroadcastInvocationInitiated, null, null, null, binaryLogWriter[LogCategory.BroadcastEngine] > 1 ? (Stream)this._messageStream.Clone() : null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, true, this._dispatcher, this, false, null, methodName, null, "The broadcast invocation is initiated."); } // to prevent firing resultCollector.AllMessagesReceived event this.UnrepliedReceivers[_uniqueReceiverName] = null; object[] listOfReceiverInfo; this._dispatcher.GetListOfReceivers(out listOfReceiverInfo, msg, this); // through all recipients for (int i = 0; i < listOfReceiverInfo.Length; i++) { ReceiverInfo receiverInfo = listOfReceiverInfo[i] as ReceiverInfo; if (receiverInfo == null) { continue; } string mbrUri = (string)receiverInfo.MbrUri; invocationTarget = mbrUri; try { lock (receiverInfo) { if (this._dispatcher.MaximumNumberOfConsecutiveFailsToExcludeReceiverAutomatically != 0 && receiverInfo.NumberOfFails >= this._dispatcher.MaximumNumberOfConsecutiveFailsToExcludeReceiverAutomatically) { // put it to the list containing receivers being excluded listOfExcludedReceivers.Add(mbrUri); continue; } } // think that it'll fail if (!receiverInfo.Local && receiverInfo.GeneralBroadcastSender == null) { lock (this) { this.Failed[mbrUri] = GenuineExceptions.Get_Broadcast_RemoteEndPointDidNotReplyForTimeOut(); } } if (receiverInfo.Local) { // call to local appdomain // ignore recurrent calls if (this._dispatcher.IgnoreRecurrentCalls && UniqueCallTracer.Instance.WasGuidRegistered(mbrUri + callGuidSubstring)) { continue; } // we'll wait for the answer from this receiver this.UnrepliedReceivers[mbrUri] = null; // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0) { binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting", LogMessageType.BroadcastRecipientInvoked, null, null, null, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, false, this._dispatcher, this, false, receiverInfo, null, null, "The local receiver is invoked via LocalPerformer."); } if (formatterForLocalRecipients == null) { formatterForLocalRecipients = new BinaryFormatter(); } // fixed in 2.5.9.6 IMessage iLocalMessage = (IMessage)formatterForLocalRecipients.Deserialize((Stream)this._messageStream.Clone()); // queue task to run the call locally //IMessage iLocalMessage = (IMessage) binaryFormatter.Deserialize( (Stream) this._messageStream.Clone() ); LocalPerformer localPerformer = new LocalPerformer(iLocalMessage, this, receiverInfo.MbrObject); GenuineThreadPool.QueueUserWorkItem(new WaitCallback(localPerformer.Call), null, false); } else if (receiverInfo.GeneralBroadcastSender != null) { // call via true multicast channel Stream messageToBeSent = (Stream)this._messageStream.Clone(); // send via real broadcast sender to the specific court msg.Properties["__Uri"] = string.Empty; Message message = Message.CreateOutcomingMessage(receiverInfo.GeneralBroadcastSender.ITransportContext, msg, new TransportHeaders(), messageToBeSent, false); message.DestinationMarshalByRef = receiverInfo.SerializedObjRef; message.GenuineMessageType = GenuineMessageType.TrueBroadcast; // to ignore recurrent calls on the remote side if (this._dispatcher.IgnoreRecurrentCalls) { message.ITransportHeaders[Message.TransportHeadersBroadcastSendGuid] = callGuidSubstring; } // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0) { message.ITransportHeaders[Message.TransportHeadersInvocationTarget] = invocationTarget; message.ITransportHeaders[Message.TransportHeadersMethodName] = methodName; binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting", LogMessageType.BroadcastRecipientInvoked, null, null, null, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, false, this._dispatcher, this, false, receiverInfo, null, null, "Mulsticast sender is being invoked."); } // register to catch all the answers receiverInfo.GeneralBroadcastSender.ITransportContext.IIncomingStreamHandler.RegisterResponseProcessor(message.MessageId, this); // and send it receiverInfo.GeneralBroadcastSender.SendMessage(message, this); } else { // send the invocation through the usual channel // we'll wait for the reply this.UnrepliedReceivers[mbrUri] = null; // send only if this receiver is not expected to receive message via broadcast channel if (receiverInfo.NeedsBroadcastSimulation) { // each time a new stream is created because sinks change stream position concurrently Stream messageToBeSent = (Stream)this._messageStream.Clone(); TransportHeaders transportHeaders = new TransportHeaders(); // to ignore recurrent calls on the remote side if (this._dispatcher.IgnoreRecurrentCalls) { transportHeaders[Message.TransportHeadersBroadcastSendGuid] = callGuidSubstring; } // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0) { binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting", LogMessageType.BroadcastRecipientInvoked, null, null, receiverInfo.DbgRemoteHost, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, false, this._dispatcher, this, false, receiverInfo, null, null, "The broadcast recipient is being invoked directly."); } // invoke the destination MBR msg.Properties["__Uri"] = receiverInfo.MbrUri; transportHeaders[Message.TransportHeadersBroadcastObjRefOrCourt] = receiverInfo.SerializedObjRef; transportHeaders[Message.TransportHeadersMbrUriName] = receiverInfo.MbrUri; transportHeaders[Message.TransportHeadersGenuineMessageType] = GenuineMessageType.BroadcastEngine; transportHeaders[Message.TransportHeadersInvocationTarget] = invocationTarget; transportHeaders[Message.TransportHeadersMethodName] = methodName; ClientChannelSinkStack clientChannelSinkStack = new ClientChannelSinkStack(this); clientChannelSinkStack.Push(this, null); receiverInfo.IClientChannelSink.AsyncProcessRequest(clientChannelSinkStack, this._iMessage, transportHeaders, messageToBeSent); } } } catch (Exception ex) { this.ParseResult(mbrUri, null, ex); } } // remove set uri from the hash to check wither the invocation finished this.UnrepliedReceivers.Remove(_uniqueReceiverName); if (this.UnrepliedReceivers.Count <= 0) { this.AllMessagesReceived.Set(); } this.StartReceiving(); if (listOfExcludedReceivers.Count > 0) { foreach (string uri in listOfExcludedReceivers) { this._dispatcher.Remove(uri); } } } catch (Exception ex) { // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0) { binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting", LogMessageType.BroadcastInvocationInitiated, ex, null, null, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, false, this._dispatcher, this, false, null, invocationTarget, methodName, "A critical failure occurred during broadcast."); } throw; } }
/// <summary> /// Starts connection establishing. /// </summary> public void StartOperation() { GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.StartConnecting), null, true); }
/// <summary> /// Accepts incoming connections. /// </summary> public void AcceptConnections() { BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; Exception exception = null; int numberOfFailure = 0; try { for ( ; ;) { try { if (this.IAcceptConnectionConsumer.IsDisposed()) { return; } if (this.StopListening.WaitOne(0, false)) { return; } Socket clientSocket = this.Socket.Accept(); GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.AcceptConnection), clientSocket, true); } catch (Exception ex) { numberOfFailure++; // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.AcceptingConnection] > 0) { binaryLogWriter.WriteEvent(LogCategory.AcceptingConnection, "GenuineTcp.AcceptConnectionClosure.AcceptConnections", LogMessageType.ConnectionAccepting, ex, null, null, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, -1, 0, 0, 0, null, null, null, null, "An inbound TCP connection has not been accepted. Number of failure: {0}.", numberOfFailure); } this.ITransportContext.IGenuineEventProvider.Fire(new GenuineEventArgs(GenuineEventType.GeneralListenerFailure, ex, null, ListeningEndPoint)); } } } catch (Exception ex) { exception = ex; // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.AcceptingConnection] > 0) { binaryLogWriter.WriteEvent(LogCategory.AcceptingConnection, "GenuineTcp.AcceptConnectionClosure.AcceptConnections", LogMessageType.ListeningStopped, ex, null, null, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, -1, 0, 0, 0, null, null, null, null, "Fatal Error. The socket does not accept inbound connections any longer."); } this.ITransportContext.IGenuineEventProvider.Fire(new GenuineEventArgs(GenuineEventType.GeneralListenerFailure, ex, null, this.ListeningEndPoint)); } finally { SocketUtility.CloseSocket(this.Socket); } }