/// <summary> /// Operates with failed sockets. /// </summary> /// <param name="exception">The source exception.</param> /// <param name="xHttpConnection">The failed logical connection.</param> /// <param name="xHttpPhysicalConnection">The failed physical connection.</param> private void ConnectionFailed(Exception exception, XHttpConnection xHttpConnection, XHttpPhysicalConnection xHttpPhysicalConnection) { BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; try { if (xHttpPhysicalConnection == null && xHttpConnection == null) { // LOG: if ( binaryLogWriter != null ) { binaryLogWriter.WriteImplementationWarningEvent("XHttpConnectionManager.ConnectionFailed", LogMessageType.ConnectionFailed, exception, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, "The connection has not been specified while invoking XHttpConnectionManager.ConnectionFailed."); } return ; } OperationException operationException = exception as OperationException; bool conflict409Received = false; if (operationException != null) conflict409Received = operationException.OperationErrorMessage.ErrorIdentifier.IndexOf("ConflictOfConnections") >= 0; // if it's a server, just close the connection // if it's a client sender, re-send it again // if it's a client listener, re-send the request again with the same seq no bool tryToReestablish = ! ConnectionManager.IsExceptionCritical(exception as OperationException); HostInformation remote = null; if (xHttpConnection != null) remote = xHttpConnection.Remote; // LOG: if ( binaryLogWriter != null && binaryLogWriter[LogCategory.Connection] > 0 ) { binaryLogWriter.WriteEvent(LogCategory.Connection, "XHttpConnectionManager.ConnectionFailed", LogMessageType.ConnectionFailed, exception, null, remote, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, xHttpConnection == null ? -1 : xHttpConnection.DbgConnectionId, 0, 0, 0, null, null, null, null, "XHTTP connection has failed."); } using (new ReaderAutoLocker(this._disposeLock)) { if (this._disposed) tryToReestablish = false; } // close the socket if (xHttpPhysicalConnection != null) GenuineThreadPool.QueueUserWorkItem(new WaitCallback(SocketUtility.CloseSocket), xHttpPhysicalConnection.Socket, true); switch (xHttpConnection.GenuineConnectionType) { case GenuineConnectionType.Persistent: // ignore connections causing conflict if (conflict409Received) break; lock (remote.PersistentConnectionEstablishingLock) { using (new ReaderAutoLocker(this._disposeLock)) { if (! tryToReestablish || xHttpConnection.IsDisposed) { this._persistent.Remove(remote.PrimaryUri, xHttpConnection.ConnectionName); // release all resources this.ITransportContext.KnownHosts.ReleaseHostResources(xHttpConnection.Remote, exception); xHttpConnection.Dispose(exception); xHttpConnection.SignalState(GenuineEventType.GeneralConnectionClosed, exception, null); if (exception is OperationException && ((OperationException) exception).OperationErrorMessage.ErrorIdentifier == "GenuineChannels.Exception.Receive.ServerHasBeenRestarted") xHttpConnection.SignalState(GenuineEventType.GeneralServerRestartDetected, exception, null); break; } xHttpConnection.SignalState(GenuineEventType.GeneralConnectionReestablishing, exception, null); // start reestablishing if (remote.GenuinePersistentConnectionState == GenuinePersistentConnectionState.Opened) { // start the reestablishing, if possible if (xHttpPhysicalConnection != null && xHttpPhysicalConnection.Reestablish_ObtainStatus()) GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.ReestablishConnection), xHttpPhysicalConnection, true); } } // using (new ReaderAutoLocker(this._disposeLock)) } // lock (remote.PersistentConnectionEstablishingLock) break; case GenuineConnectionType.Invocation: break; } } catch(Exception ex) { // LOG: if ( binaryLogWriter != null ) binaryLogWriter.WriteImplementationWarningEvent("XHttpConnectionManager.ConnectionFailed", LogMessageType.Warning, ex, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, "An unexpected exception is raised inside XHttpConnectionManager.ConnectionFailed method. Most likely, something must be fixed."); } }
/// <summary> /// Initiates sending through the physical asynchronously. /// </summary> /// <param name="xHttpPhysicalConnection">The physical connection.</param> /// <returns>True if the sending was initiated. False if the specified physical connection contains no data to send.</returns> private bool LowLevel_InitiateAsyncSending(XHttpPhysicalConnection xHttpPhysicalConnection) { // initiate the sending xHttpPhysicalConnection.AsyncSendBufferCurrentPosition = 0; xHttpPhysicalConnection.AsyncSendBufferSizeOfValidContent = GenuineUtility.TryToReadFromStream(xHttpPhysicalConnection.AsyncSendStream, xHttpPhysicalConnection.AsyncSendBuffer, 0, xHttpPhysicalConnection.AsyncSendBuffer.Length); if (xHttpPhysicalConnection.AsyncSendBufferSizeOfValidContent == 0) return false; xHttpPhysicalConnection.AsyncSendBufferIsLastPacket = xHttpPhysicalConnection.AsyncSendBufferSizeOfValidContent < xHttpPhysicalConnection.AsyncSendBuffer.Length; // LOG: BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; if ( binaryLogWriter != null && binaryLogWriter[LogCategory.Transport] > 0 ) binaryLogWriter.WriteEvent(LogCategory.Transport, "XHttpConnectionManager.LowLevel_InitiateAsyncSending", LogMessageType.AsynchronousSendingStarted, null, null, xHttpPhysicalConnection.Remote, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, xHttpPhysicalConnection.XHttpConnection.DbgConnectionId, 0, 0, 0, null, null, null, null, "The connection has been obtained and the stream is being sent asynchronously."); AsyncThreadStarter.QueueTask(new Async_InitiateSocketSending(xHttpPhysicalConnection.Socket, xHttpPhysicalConnection.AsyncSendBuffer, xHttpPhysicalConnection.AsyncSendBufferCurrentPosition, xHttpPhysicalConnection.AsyncSendBufferSizeOfValidContent - xHttpPhysicalConnection.AsyncSendBufferCurrentPosition, this._AsyncSending_onEndSending, xHttpPhysicalConnection)); return true; }
/// <summary> /// Constructs an instance of the PhysicalConnectionAndSocket class. /// </summary> /// <param name="xHttpPhysicalConnection">The connection.</param> /// <param name="socket">The socket.</param> public PhysicalConnectionAndSocket(XHttpPhysicalConnection xHttpPhysicalConnection, Socket socket) { this.Socket = socket; this.XHttpPhysicalConnection = xHttpPhysicalConnection; }
/// <summary> /// Initiates receiving of the message's header. /// </summary> /// <param name="xHttpPhysicalConnection">The physical connection.</param> internal void LowLevel_HalfSync_Client_StartReceiving(XHttpPhysicalConnection xHttpPhysicalConnection) { // LOG: BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; if ( binaryLogWriter != null && binaryLogWriter[LogCategory.Transport] > 0 ) { binaryLogWriter.WriteEvent(LogCategory.Transport, "XHttpConnectionManager.LowLevel_HalfSync_Client_StartReceiving", LogMessageType.ReceivingStarted, null, null, xHttpPhysicalConnection.Remote, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, xHttpPhysicalConnection.ConnectionLevelSecurity, xHttpPhysicalConnection.ConnectionLevelSecurity == null ? null : xHttpPhysicalConnection.ConnectionLevelSecurity.Name, xHttpPhysicalConnection.XHttpConnection.DbgConnectionId, 0, 0, 0, null, null, null, null, "The asynchronous receiving is initiated."); } // check the connection xHttpPhysicalConnection.CheckConnectionStatus(); // and initiate receiving AsyncThreadStarter.QueueTask(new Async_InitiateSocketReceiving(xHttpPhysicalConnection.Socket, this._unusedBuffer, 0, 1, _HalfSync_Client_onEndReceiving, xHttpPhysicalConnection)); }
/// <summary> /// Processes the listening request on the server side. /// </summary> /// <param name="xHttpConnection">The connection.</param> /// <param name="xHttpPhysicalConnection">The physical connection.</param> private void Pool_Server_ProcessListenerRequest(XHttpConnection xHttpConnection, XHttpPhysicalConnection xHttpPhysicalConnection) { lock (xHttpConnection.Listener.PhysicalConnectionStateLock) { try { Message message = xHttpConnection.MessageContainer.GetMessage(); if (message == null) { // no data is available, postpone the request // xHttpPhysicalConnection.Listener_Opened = GenuineUtility.TickCount; xHttpPhysicalConnection.MarkAsAvailable(); return; } // some data is available, gather the stream and send it this.LowLevel_SendHttpContent(GenuineUtility.GetTimeout(xHttpConnection.CloseConnectionAfterInactivity), message, null, null, xHttpConnection.MessageContainer, xHttpPhysicalConnection, xHttpConnection.GenuineConnectionType, HttpPacketType.Usual, false, true, true, true); } catch(Exception ex) { // LOG: BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; if ( binaryLogWriter != null && binaryLogWriter[LogCategory.Connection] > 0 ) { binaryLogWriter.WriteEvent(LogCategory.Connection, "XHttpConnectionManager.Pool_Server_ProcessListenerRequest", LogMessageType.AsynchronousSendingStarted, ex, null, xHttpPhysicalConnection.Remote, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, xHttpConnection.DbgConnectionId, 0, 0, 0, null, null, null, null, "Error occurred while sending HTTP Listener Request. Sequence No: {0}.", xHttpPhysicalConnection.SequenceNo); } } } }
/// <summary> /// Processes the sending request on the server side. /// </summary> /// <param name="xHttpConnection">The connection.</param> /// <param name="xHttpPhysicalConnection">The physical connection.</param> /// <param name="inputStream">The connection.</param> private void Pool_Server_ProcessSenderRequest(XHttpConnection xHttpConnection, XHttpPhysicalConnection xHttpPhysicalConnection, Stream inputStream) { Exception gotException = null; try { this.LowLevel_ParseLabelledStream(inputStream, xHttpPhysicalConnection); inputStream.Close(); } catch(Exception ex) { gotException = ex; // LOG: BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; if ( binaryLogWriter != null && binaryLogWriter[LogCategory.Connection] > 0 ) { binaryLogWriter.WriteEvent(LogCategory.Connection, "XHttpConnectionManager.Pool_Server_ProcessSenderRequest", LogMessageType.ReceivingFinished, ex, null, xHttpConnection.Remote, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, xHttpConnection.DbgConnectionId, 0, 0, 0, null, null, null, null, "Error occurred while parsing HTTP Sender Request. Sequence No: {0}.", xHttpPhysicalConnection.SequenceNo); } } if (gotException != null) { gotException = OperationException.WrapException(gotException); GenuineChunkedStream outputStream = new GenuineChunkedStream(false); BinaryFormatter binaryFormatter = new BinaryFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Other)); binaryFormatter.Serialize(outputStream, gotException); this.LowLevel_SendHttpContent(GenuineUtility.GetTimeout(xHttpConnection.CloseConnectionAfterInactivity), null, null, gotException, null, xHttpPhysicalConnection, GenuineConnectionType.Persistent, HttpPacketType.SenderError, false, true, true, false); } else { // serialize and send the OK response this.LowLevel_SendHttpContent(GenuineUtility.GetTimeout(xHttpConnection.CloseConnectionAfterInactivity), null, null, null, null, xHttpPhysicalConnection, GenuineConnectionType.Persistent, HttpPacketType.SenderResponse, false, true, true, false); } }
/// <summary> /// Starts sending a message if one is available. Marks the connection is available if there are no messages at the moment. /// Does not process exceptions. /// </summary> /// <param name="xHttpPhysicalConnection">The sending connection.</param> private void Pool_Sender_HandleClientConnection(XHttpPhysicalConnection xHttpPhysicalConnection) { lock (xHttpPhysicalConnection.PhysicalConnectionStateLock) { Message message = xHttpPhysicalConnection.XHttpConnection.MessageContainer.GetMessage(); if (message == null) { xHttpPhysicalConnection.MarkAsAvailable(); return ; } this.LowLevel_SendHttpContent(GenuineUtility.GetTimeout(xHttpPhysicalConnection.XHttpConnection.CloseConnectionAfterInactivity), message, null, null, xHttpPhysicalConnection.XHttpConnection.MessageContainer, xHttpPhysicalConnection, GenuineConnectionType.Persistent, HttpPacketType.Usual, false, true, true, true); } }
/// <summary> /// Starts sending a message if one is available. Marks the connection is available if there are no messages at the moment. /// Does not process exceptions. /// </summary> /// <param name="xHttpPhysicalConnection">The sending connection.</param> private void Pool_Listener_HandleClientConnection(XHttpPhysicalConnection xHttpPhysicalConnection) { this.LowLevel_SendHttpContent(GenuineUtility.GetTimeout(xHttpPhysicalConnection.XHttpConnection.CloseConnectionAfterInactivity), null, null, null, null, xHttpPhysicalConnection, GenuineConnectionType.Persistent, HttpPacketType.Listening, false, true, true, true); }
/// <summary> /// Sends a request to the server according to the type of the connection provided. /// Does not process exceptions. /// </summary> /// <param name="xHttpPhysicalConnection"></param> private void Pool_HandleClientConnection(XHttpPhysicalConnection xHttpPhysicalConnection) { // client & sender - start sending a message or mark the connection as available // client & listener - send the next request if (xHttpPhysicalConnection.IsSender) Pool_Sender_HandleClientConnection(xHttpPhysicalConnection); else Pool_Listener_HandleClientConnection(xHttpPhysicalConnection); }
/// <summary> /// Sends HTTP content to the remote host. /// Does not process exceptions. /// Automatically initiates asynchronous receiving. /// Automatically manages stream seqNo for clients' connections. /// </summary> /// <param name="timeout">Operation timeout.</param> /// <param name="message">The message.</param> /// <param name="content">The content sent instead of the message.</param> /// <param name="exceptionToBeSent">The exception being sent in the response.</param> /// <param name="messageContainer">The message container.</param> /// <param name="xHttpPhysicalConnection">The physical connection.</param> /// <param name="genuineConnectionType">The type of the connection.</param> /// <param name="httpPacketType">The type of the HTTP packet.</param> /// <param name="repeatSending">Whether the content was already packed.</param> /// <param name="synchronous">Whether to send content synchronously.</param> /// <param name="startAutomaticReceiving">Indicates whether to start automatic receiving of the response/request if the type of the sending is synchronous.</param> /// <param name="applyClss">A boolean value indicating whether the CLSS should be applied.</param> private void LowLevel_SendHttpContent(int timeout, Message message, GenuineChunkedStream content, Exception exceptionToBeSent, MessageContainer messageContainer, XHttpPhysicalConnection xHttpPhysicalConnection, GenuineConnectionType genuineConnectionType, HttpPacketType httpPacketType, bool repeatSending, bool synchronous, bool startAutomaticReceiving, bool applyClss ) { BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; // check whether the connection is valid and available xHttpPhysicalConnection.CheckConnectionStatus(); // prevent the ping if (! xHttpPhysicalConnection.IsSender) xHttpPhysicalConnection.XHttpConnection.LastTimeContentWasSent = GenuineUtility.TickCount; // valid copies Socket socket; Stream sentContent; // to prevent from changing sequence information or disposing sent content during its encryption lock (xHttpPhysicalConnection.PhysicalConnectionStateLock) { if (! repeatSending) { if (xHttpPhysicalConnection.XHttpConnection.IsClient) xHttpPhysicalConnection.SequenceNo ++; if (message != null || (message == null && content == null && exceptionToBeSent == null)) { GenuineChunkedStream packedMessages = new GenuineChunkedStream(false); MessageCoder.FillInLabelledStream(message, messageContainer, xHttpPhysicalConnection.MessagesBeingSent, packedMessages, xHttpPhysicalConnection.AsyncSendBuffer, (int) this.ITransportContext.IParameterProvider[GenuineParameter.HttpRecommendedPacketSize]); // LOG: if ( binaryLogWriter != null && binaryLogWriter[LogCategory.Transport] > 0 ) { for ( int i = 0; i < xHttpPhysicalConnection.MessagesBeingSent.Count; i++) { Message nextMessage = (Message) xHttpPhysicalConnection.MessagesBeingSent[i]; binaryLogWriter.WriteEvent(LogCategory.Transport, "XHttpConnectionManager.LowLevel_SendHttpContent", LogMessageType.MessageIsSentAsynchronously, null, nextMessage, xHttpPhysicalConnection.Remote, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, xHttpPhysicalConnection.ConnectionLevelSecurity, null, xHttpPhysicalConnection.XHttpConnection.DbgConnectionId, xHttpPhysicalConnection.SequenceNo, 0, 0, null, null, null, null, "The message will be sent in the {0} stream N: {1}.", xHttpPhysicalConnection == xHttpPhysicalConnection.XHttpConnection.Sender ? "SENDER" : "LISTENER", xHttpPhysicalConnection.SequenceNo); } } xHttpPhysicalConnection.SentContent = packedMessages; } else if (content != null) { xHttpPhysicalConnection.MessagesBeingSent.Clear(); xHttpPhysicalConnection.SentContent = content; } else //if (exceptionToBeSent != null) { #if DEBUG Debug.Assert(httpPacketType == HttpPacketType.SenderError); #endif Exception exception = OperationException.WrapException(exceptionToBeSent); GenuineChunkedStream output = new GenuineChunkedStream(false); BinaryFormatter binaryFormatter = new BinaryFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Other)); binaryFormatter.Serialize(output, exception); xHttpPhysicalConnection.MessagesBeingSent.Clear(); xHttpPhysicalConnection.SentContent = output; } // client applies CLSSE only to the actual content if (applyClss && xHttpPhysicalConnection.XHttpConnection.IsClient && xHttpPhysicalConnection.ConnectionLevelSecurity != null) { GenuineChunkedStream encryptedContent = new GenuineChunkedStream(false); xHttpPhysicalConnection.ConnectionLevelSecurity.Encrypt(xHttpPhysicalConnection.SentContent, encryptedContent); xHttpPhysicalConnection.SentContent = encryptedContent; } // write the binary header GenuineChunkedStream resultStream = new GenuineChunkedStream(false); BinaryWriter binaryWriter = new BinaryWriter(resultStream); if (xHttpPhysicalConnection.XHttpConnection.IsClient) HttpMessageCoder.WriteRequestHeader(binaryWriter, MessageCoder.PROTOCOL_VERSION, genuineConnectionType, xHttpPhysicalConnection.XHttpConnection.HostId, httpPacketType, xHttpPhysicalConnection.SequenceNo, xHttpPhysicalConnection.XHttpConnection.ConnectionName, xHttpPhysicalConnection.XHttpConnection.Remote.LocalHostUniqueIdentifier); else HttpMessageCoder.WriteResponseHeader(binaryWriter, xHttpPhysicalConnection.XHttpConnection.Remote.ProtocolVersion, this.ITransportContext.ConnectionManager.Local.Uri, xHttpPhysicalConnection.SequenceNo, httpPacketType, xHttpPhysicalConnection.XHttpConnection.Remote.LocalHostUniqueIdentifier); resultStream.WriteStream(xHttpPhysicalConnection.SentContent); xHttpPhysicalConnection.SentContent = resultStream; // while server applies CLSSE to the entire response (except HTTP stuff, of course) if (applyClss && ! xHttpPhysicalConnection.XHttpConnection.IsClient && xHttpPhysicalConnection.ConnectionLevelSecurity != null) { GenuineChunkedStream encryptedContent = new GenuineChunkedStream(false); xHttpPhysicalConnection.ConnectionLevelSecurity.Encrypt(xHttpPhysicalConnection.SentContent, encryptedContent); xHttpPhysicalConnection.SentContent = encryptedContent; } // generally it's impossible to have xHttpPhysicalConnection.SentContent without available length in the current implementation // nevertheless, it's necessary to calculate the final length of the content if it's unknown if (! xHttpPhysicalConnection.SentContent.CanSeek) { GenuineChunkedStream actualContent = new GenuineChunkedStream(false); GenuineUtility.CopyStreamToStream(xHttpPhysicalConnection.SentContent, actualContent, xHttpPhysicalConnection.AsyncSendBuffer); xHttpPhysicalConnection.SentContent = actualContent; } // write the header and compose final content resultStream = new GenuineChunkedStream(false); StreamWriter streamWriter = new StreamWriter(new NonClosableStream(resultStream), Encoding.ASCII, 3500); if (xHttpPhysicalConnection.XHttpConnection.IsClient) streamWriter.Write("POST /{0} HTTP/1.1\r\nAccept: */*\r\nContent-Type: application/octet-stream\r\nContent-Length: {1}\r\nUser-Agent: {2}\r\nHost: {3}\r\nConnection: Keep-Alive\r\nPragma: no-cache\r\n\r\n", xHttpPhysicalConnection.EntryUri, xHttpPhysicalConnection.SentContent.Length, xHttpPhysicalConnection.XHttpConnection.UserAgent, xHttpPhysicalConnection.LocalEndPoint); else { string now = DateTime.Now.ToString("r"); streamWriter.Write("HTTP/1.1 200 OK\r\nServer: GXHTTP\r\nDate: {0}\r\nX-Powered-By: Genuine Channels\r\nCache-Control: private\r\nContent-Type: application/octet-stream\r\nContent-Length: {1}\r\n\r\n", now, xHttpPhysicalConnection.SentContent.Length); } streamWriter.Flush(); streamWriter.Close(); resultStream.WriteStream(xHttpPhysicalConnection.SentContent); xHttpPhysicalConnection.SentContent = resultStream; } else { xHttpPhysicalConnection.SentContent.Position = 0; } socket = xHttpPhysicalConnection.Socket; sentContent = xHttpPhysicalConnection.SentContent; } // lock (xHttpPhysicalConnection.PhysicalConnectionStateLock) if (synchronous) { // send the content SyncSocketWritingStream syncSocketWritingStream = new SyncSocketWritingStream(this, socket, timeout, xHttpPhysicalConnection.XHttpConnection.DbgConnectionId, xHttpPhysicalConnection.Remote); GenuineUtility.CopyStreamToStreamPhysically(sentContent, syncSocketWritingStream, xHttpPhysicalConnection.AsyncSendBuffer); // automatically start receiving the response/request if (startAutomaticReceiving) { if (xHttpPhysicalConnection.XHttpConnection.IsClient) this.LowLevel_HalfSync_Client_StartReceiving(xHttpPhysicalConnection); else this.LowLevel_HalfSync_Server_StartReceiving(xHttpPhysicalConnection.Socket); } } else { xHttpPhysicalConnection.AsyncSendBufferCurrentPosition = 0; xHttpPhysicalConnection.AsyncSendBufferIsLastPacket = false; xHttpPhysicalConnection.AsyncSendBufferSizeOfValidContent = 0; xHttpPhysicalConnection.AsyncSendStream = sentContent; this.LowLevel_InitiateAsyncSending(xHttpPhysicalConnection); } }
/// <summary> /// Reads messages from the stream and processes them. /// </summary> /// <param name="stream">The source stream.</param> /// <param name="xHttpPhysicalConnection">The connection.</param> private void LowLevel_ParseLabelledStream(Stream stream, XHttpPhysicalConnection xHttpPhysicalConnection) { BinaryReader binaryReader = new BinaryReader(stream); while ( binaryReader.ReadByte() == 0 ) { using (LabelledStream labelledStream = new LabelledStream(this.ITransportContext, stream, xHttpPhysicalConnection.AsyncReceiveBuffer)) { GenuineChunkedStream receivedContent = new GenuineChunkedStream(true); GenuineUtility.CopyStreamToStream(labelledStream, receivedContent); this.ITransportContext.IIncomingStreamHandler.HandleMessage(receivedContent, xHttpPhysicalConnection.Remote, xHttpPhysicalConnection.XHttpConnection.GenuineConnectionType, xHttpPhysicalConnection.XHttpConnection.ConnectionName, xHttpPhysicalConnection.XHttpConnection.DbgConnectionId, false, null, xHttpPhysicalConnection.ConnectionLevelSecurity, null); } } }