private IConnection BuildDuplicatedNamedPipeConnection(NamedPipeDuplicateContext duplicateContext, int connectionBufferSize) { if (DiagnosticUtility.ShouldTraceVerbose) { TraceUtility.TraceEvent(TraceEventType.Verbose, 0xa0002, System.ServiceModel.SR.GetString("TraceCodePortSharingDuplicatedPipe")); } PipeHandle pipe = new PipeHandle(duplicateContext.Handle); PipeConnection innerConnection = new PipeConnection(pipe, connectionBufferSize, false, true); return(new NamedPipeValidatingConnection(new PreReadConnection(innerConnection, duplicateContext.ReadData), this)); }
private IConnection TryConnect(Uri remoteUri, string resolvedAddress, BackoffTimeoutHelper backoffHelper) { bool flag = backoffHelper.IsExpired(); int dwFlagsAndAttributes = 0x40000000; if (this.includeSecurityIdentity) { dwFlagsAndAttributes |= 0x110000; } PipeHandle handle = UnsafeNativeMethods.CreateFile(resolvedAddress, -1073741824, 0, IntPtr.Zero, 3, dwFlagsAndAttributes, IntPtr.Zero); int errorCode = Marshal.GetLastWin32Error(); if (handle.IsInvalid) { handle.SetHandleAsInvalid(); } else { int mode = 2; if (UnsafeNativeMethods.SetNamedPipeHandleState(handle, ref mode, IntPtr.Zero, IntPtr.Zero) == 0) { errorCode = Marshal.GetLastWin32Error(); handle.Close(); PipeException exception = new PipeException(System.ServiceModel.SR.GetString("PipeModeChangeFailed", new object[] { PipeError.GetErrorString(errorCode) }), errorCode); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.CreateConnectFailedException(remoteUri, exception)); } return(new PipeConnection(handle, this.bufferSize, false, true)); } if ((errorCode == 2) || (errorCode == 0xe7)) { TimeoutException exception3; if (!flag) { return(null); } Exception exception2 = new PipeException(System.ServiceModel.SR.GetString("PipeConnectAddressFailed", new object[] { resolvedAddress, PipeError.GetErrorString(errorCode) }), errorCode); string absoluteUri = remoteUri.AbsoluteUri; if (errorCode == 0xe7) { exception3 = new TimeoutException(System.ServiceModel.SR.GetString("PipeConnectTimedOutServerTooBusy", new object[] { absoluteUri, backoffHelper.OriginalTimeout }), exception2); } else { exception3 = new TimeoutException(System.ServiceModel.SR.GetString("PipeConnectTimedOut", new object[] { absoluteUri, backoffHelper.OriginalTimeout }), exception2); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception3); } PipeException innerException = new PipeException(System.ServiceModel.SR.GetString("PipeConnectAddressFailed", new object[] { resolvedAddress, PipeError.GetErrorString(errorCode) }), errorCode); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.CreateConnectFailedException(remoteUri, innerException)); }
public IConnection EndAccept(IAsyncResult result) { PendingAccept accept = result as PendingAccept; if (accept == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("result", System.ServiceModel.SR.GetString("InvalidAsyncResult")); } PipeHandle pipe = accept.End(); if (pipe == null) { return(null); } return(new PipeConnection(pipe, this.bufferSize, accept.IsBoundToCompletionPort, accept.IsBoundToCompletionPort)); }
public PipeConnection(PipeHandle pipe, int connectionBufferSize, bool isBoundToCompletionPort, bool autoBindToCompletionPort) { if (pipe == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("pipe"); if (pipe.IsInvalid) throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("pipe"); this.closeState = CloseState.Open; this.exceptionEventType = TraceEventType.Error; this.isBoundToCompletionPort = isBoundToCompletionPort; this.autoBindToCompletionPort = autoBindToCompletionPort; this.pipe = pipe; this.readBufferSize = connectionBufferSize; this.writeBufferSize = connectionBufferSize; this.readOverlapped = new OverlappedContext(); this.asyncReadBuffer = DiagnosticUtility.Utility.AllocateByteArray(connectionBufferSize); this.writeOverlapped = new OverlappedContext(); this.atEOFEvent = new ManualResetEvent(false); this.onAsyncReadComplete = new OverlappedIOCompleteCallback(OnAsyncReadComplete); this.onAsyncWriteComplete = new OverlappedIOCompleteCallback(OnAsyncWriteComplete); }
public PendingAccept(PipeConnectionListener listener, PipeHandle pipeHandle, bool isBoundToCompletionPort, AsyncCallback callback, object state) : base(callback, state) { this.pipeHandle = pipeHandle; this.result = pipeHandle; this.listener = listener; this.onAcceptComplete = new OverlappedIOCompleteCallback(this.OnAcceptComplete); this.overlapped = new OverlappedContext(); this.isBoundToCompletionPort = isBoundToCompletionPort; if (!Thread.CurrentThread.IsThreadPoolThread) { if (onStartAccept == null) { onStartAccept = new Action <object>(PipeConnectionListener.PendingAccept.OnStartAccept); } ActionItem.Schedule(onStartAccept, this); } else { this.StartAccept(true); } }
public IAsyncResult BeginAccept(AsyncCallback callback, object state) { lock (this.ThisLock) { if (this.isDisposed) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException("", System.ServiceModel.SR.GetString("PipeListenerDisposed"))); } if (!this.isListening) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("PipeListenerNotListening"))); } PipeHandle pipeHandle = this.CreatePipe(); PendingAccept item = new PendingAccept(this, pipeHandle, this.useCompletionPort, callback, state); if (!item.CompletedSynchronously) { this.pendingAccepts.Add(item); } return(item); } }
internal static extern unsafe int ConnectNamedPipe(PipeHandle handle, NativeOverlapped *lpOverlapped);
internal static extern int SetNamedPipeHandleState(PipeHandle handle, ref int mode, IntPtr collectionCount, IntPtr collectionDataTimeout);
public static unsafe PipeException GetOverlappedReadException(PipeHandle pipe, NativeOverlapped* nativeOverlapped, out int bytesRead) { if (UnsafeNativeMethods.GetOverlappedResult(pipe.DangerousGetHandle(), nativeOverlapped, out bytesRead, 0) == 0) { int error = Marshal.GetLastWin32Error(); if (error == UnsafeNativeMethods.ERROR_MORE_DATA) { return null; } else { return Exceptions.CreateReadException(error); } } else { return null; } }
internal static extern int SetNamedPipeHandleState ( PipeHandle handle, ref int mode, IntPtr collectionCount, IntPtr collectionDataTimeout );
public unsafe PendingAccept(PipeConnectionListener listener, PipeHandle pipeHandle, bool isBoundToCompletionPort, AsyncCallback callback, object state) : base(callback, state) { this.pipeHandle = pipeHandle; this.result = pipeHandle; this.listener = listener; onAcceptComplete = new OverlappedIOCompleteCallback(OnAcceptComplete); overlapped = new OverlappedContext(); this.isBoundToCompletionPort = isBoundToCompletionPort; if (TD.PipeConnectionAcceptStartIsEnabled()) { this.eventTraceActivity = new EventTraceActivity(); TD.PipeConnectionAcceptStart(this.eventTraceActivity, this.listener.pipeUri != null ? this.listener.pipeUri.ToString() : string.Empty); } if (!Thread.CurrentThread.IsThreadPoolThread) { if (onStartAccept == null) { onStartAccept = new Action<object>(OnStartAccept); } ActionItem.Schedule(onStartAccept, this); } else { StartAccept(true); } }
internal unsafe static extern int ConnectNamedPipe ( PipeHandle handle, NativeOverlapped* lpOverlapped );
internal static extern bool DuplicateHandle( IntPtr hSourceProcessHandle, PipeHandle hSourceHandle, SafeCloseHandle hTargetProcessHandle, out IntPtr lpTargetHandle, int dwDesiredAccess, bool bInheritHandle, int dwOptions );
public PendingAccept(PipeConnectionListener listener, PipeHandle pipeHandle, bool isBoundToCompletionPort, AsyncCallback callback, object state) : base(callback, state) { this.pipeHandle = pipeHandle; this.result = pipeHandle; this.listener = listener; this.onAcceptComplete = new OverlappedIOCompleteCallback(this.OnAcceptComplete); this.overlapped = new OverlappedContext(); this.isBoundToCompletionPort = isBoundToCompletionPort; if (!Thread.CurrentThread.IsThreadPoolThread) { if (onStartAccept == null) { onStartAccept = new Action<object>(PipeConnectionListener.PendingAccept.OnStartAccept); } ActionItem.Schedule(onStartAccept, this); } else { this.StartAccept(true); } }
public void Abort() { this.result = null; this.pipeHandle.Close(); }
public static unsafe PipeException GetOverlappedWriteException(PipeHandle pipe, NativeOverlapped* nativeOverlapped, out int bytesWritten) { if (UnsafeNativeMethods.GetOverlappedResult(pipe.DangerousGetHandle(), nativeOverlapped, out bytesWritten, 0) == 0) { return CreateWriteException(Marshal.GetLastWin32Error()); } return null; }
public static unsafe PipeException GetOverlappedReadException(PipeHandle pipe, NativeOverlapped* nativeOverlapped, out int bytesRead) { if (UnsafeNativeMethods.GetOverlappedResult(pipe.DangerousGetHandle(), nativeOverlapped, out bytesRead, 0) != 0) { return null; } int error = Marshal.GetLastWin32Error(); if (error == 0xea) { return null; } return CreateReadException(error); }
// Must be called in PipeConnectionListener's lock. public void Abort() { this.result = null; // we need to return null after an abort pipeHandle.Close(); }
internal static extern int DisconnectNamedPipe(PipeHandle handle);
internal static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, PipeHandle hSourceHandle, SafeCloseHandle hTargetProcessHandle, out IntPtr lpTargetHandle, int dwDesiredAccess, bool bInheritHandle, int dwOptions);
public void Abort() { this.result = null; this.pipeHandle.Close(); }
internal static extern bool GetNamedPipeClientProcessId(PipeHandle handle, out int id);
internal unsafe static extern int DisconnectNamedPipe ( PipeHandle handle );
internal static extern bool GetNamedPipeServerProcessId(PipeHandle handle, out int id);
unsafe internal static extern int GetOverlappedResult ( PipeHandle handle, NativeOverlapped* overlapped, out int bytesTransferred, int wait );
internal static extern unsafe int GetOverlappedResult(PipeHandle handle, NativeOverlapped *overlapped, out int bytesTransferred, int wait);
internal static unsafe extern bool GetNamedPipeServerProcessId(PipeHandle handle, out int id);
private IConnection BuildDuplicatedNamedPipeConnection(NamedPipeDuplicateContext duplicateContext, int connectionBufferSize) { if (DiagnosticUtility.ShouldTraceVerbose) { TraceUtility.TraceEvent(TraceEventType.Verbose, 0xa0002, System.ServiceModel.SR.GetString("TraceCodePortSharingDuplicatedPipe")); } PipeHandle pipe = new PipeHandle(duplicateContext.Handle); PipeConnection innerConnection = new PipeConnection(pipe, connectionBufferSize, false, true); return new NamedPipeValidatingConnection(new PreReadConnection(innerConnection, duplicateContext.ReadData), this); }