internal static void CloseInvalidOutCriticalHandle(CriticalHandle handle) { if (handle != null) { handle.SetHandleAsInvalid(); } }
internal static extern uint HttpSetRequestQueueProperty( CriticalHandle requestQueueHandle, HTTP_SERVER_PROPERTY serverProperty, IntPtr pPropertyInfo, uint propertyInfoLength, uint reserved, IntPtr pReserved);
internal static unsafe void CancelRequest(CriticalHandle requestQueueHandle, ulong requestId) { UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK http_data_chunk; http_data_chunk = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK { DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory, pBuffer = (byte*) &http_data_chunk }; UnsafeNclNativeMethods.HttpApi.HttpSendResponseEntityBody(requestQueueHandle, requestId, 1, 1, &http_data_chunk, null, SafeLocalFree.Zero, 0, null, null); }
[SuppressMessage(FxCop.Category.Security, FxCop.Rule.TransparentMethodsMustNotReferenceCriticalCode)] // we got APTCA approval with no requirement to fix this transparency warning. plus, the callers of this method are not supported in partial trust. internal static void CloseInvalidOutCriticalHandle(CriticalHandle handle) { if (handle != null) { #pragma warning disable 618 Fx.Assert(handle.IsInvalid, "CloseInvalidOutCriticalHandle called with a valid handle!"); #pragma warning restore 618 handle.SetHandleAsInvalid(); } }
internal ConnectionEventArgs(SQLiteConnectionEventType eventType, StateChangeEventArgs eventArgs, IDbTransaction transaction, IDbCommand command, IDataReader dataReader, System.Runtime.InteropServices.CriticalHandle criticalHandle, string text, object data) { this.EventType = eventType; this.EventArgs = eventArgs; this.Transaction = transaction; this.Command = command; this.DataReader = dataReader; this.CriticalHandle = criticalHandle; this.Text = text; this.Data = data; }
/// <summary> /// Starts the server connection. /// </summary> public void Start() { _listener.Start(); // HACK: Get the request queue handle so we can register for disconnect var requestQueueHandleField = typeof(HttpListener).GetField("m_RequestQueueHandle", BindingFlags.Instance | BindingFlags.NonPublic); if (requestQueueHandleField != null) { _requestQueueHandle = (CriticalHandle)requestQueueHandleField.GetValue(_listener); } ReceiveLoop(); }
internal void Initialize() { // Get the request queue handle so we can register for disconnect FieldInfo requestQueueHandleField = typeof(Mono.Net.HttpListener).GetField("m_RequestQueueHandle", BindingFlags.Instance | BindingFlags.NonPublic); // Get the connection id field info from the request object _connectionIdField = typeof(HttpListenerRequest).GetField("m_ConnectionId", BindingFlags.Instance | BindingFlags.NonPublic); if (requestQueueHandleField != null) { _requestQueueHandle = (CriticalHandle)requestQueueHandleField.GetValue(_listener); } }
internal DisconnectHandler(System.Net.HttpListener listener, LoggerFunc logger) { _connectionCancellationTokens = new ConcurrentDictionary<ulong, ConnectionCancellation>(); _listener = listener; _logger = logger; // Get the request queue handle so we can register for disconnect FieldInfo requestQueueHandleField = typeof(System.Net.HttpListener).GetField("m_RequestQueueHandle", BindingFlags.Instance | BindingFlags.NonPublic); // Get the connection id field info from the request object _connectionIdField = typeof(HttpListenerRequest).GetField("m_ConnectionId", BindingFlags.Instance | BindingFlags.NonPublic); if (requestQueueHandleField != null && requestQueueHandleField.FieldType == typeof(CriticalHandle)) { _requestQueueHandle = (CriticalHandle)requestQueueHandleField.GetValue(_listener); } if (_connectionIdField == null || _requestQueueHandle == null) { LogHelper.LogInfo(_logger, "Unable to resolve handles. Disconnect notifications will be ignored."); } }
internal static extern uint HttpRemoveUrl(CriticalHandle requestQueueHandle, string pFullyQualifiedUrl);
public static IntPtr GetCriticalHandle(CriticalHandle criticalHandle) { return(criticalHandle.GetHandleInternal()); }
internal static extern unsafe uint HttpAddUrl(CriticalHandle requestQueueHandle, string pFullyQualifiedUrl, void* pReserved);
internal static extern unsafe uint HttpWaitForDisconnect(CriticalHandle requestQueueHandle, ulong connectionId, NativeOverlapped* pOverlapped);
/// <summary> /// Used in Marshalling code /// Gets the handle of the CriticalHandle /// </summary> public static IntPtr GetHandle(CriticalHandle criticalHandle) { return(InteropExtensions.GetCriticalHandle(criticalHandle)); }
internal static extern uint HttpCancelHttpRequest(CriticalHandle requestQueueHandle, ulong requestId, IntPtr pOverlapped);
internal static extern uint HttpSendHttpResponse(CriticalHandle requestQueueHandle, ulong requestId, uint flags, HTTP_RESPONSE* pHttpResponse, void* pCachePolicy, uint* pBytesSent, SafeLocalFree pRequestBuffer, uint requestBufferLength, NativeOverlapped* pOverlapped, void* pLogData);
internal void CancelLastWrite(CriticalHandle requestQueueHandle) { HttpResponseStreamAsyncResult asyncState = m_LastWrite; if (asyncState != null && !asyncState.IsCompleted) { UnsafeNclNativeMethods.CancelIoEx(requestQueueHandle, asyncState.m_pOverlapped); } }
private void CreateRequestQueueHandle() { uint num = 0; if (Version == UnsafeNclNativeMethods.HttpApi.HTTP_API_VERSION.Version20) { HttpRequestQueueV2Handle pReqQueueHandle = null; num = UnsafeNclNativeMethods.SafeNetHandles.HttpCreateRequestQueue(UnsafeNclNativeMethods.HttpApi.Version, null, null, 0, out pReqQueueHandle); if (num != 0) { throw new HttpListenerException((int) num); } this.m_RequestQueueHandle = pReqQueueHandle; } else { SafeCloseHandle handle2 = null; num = UnsafeNclNativeMethods.SafeNetHandles.HttpCreateHttpHandle(out handle2, 0); if (num != 0) { throw new HttpListenerException((int) num); } this.m_RequestQueueHandle = handle2; } }
// The request is being aborted, but large writes may be in progress. Cancel them. internal void ForceCancelRequest(CriticalHandle requestQueueHandle, ulong requestId) { uint statusCode = UnsafeNclNativeMethods.HttpApi.HttpCancelHttpRequest(requestQueueHandle, requestId, IntPtr.Zero); // Either the connection has already dropped, or the last write is in progress. // The requestId becomes invalid as soon as the last Content-Length write starts. // The only way to cancel now is with CancelIoEx. if (statusCode == UnsafeNclNativeMethods.ErrorCodes.ERROR_CONNECTION_INVALID) { m_Response.CancelLastWrite(requestQueueHandle); } }
internal static void CancelRequest(CriticalHandle requestQueueHandle, ulong requestId) { uint statusCode = UnsafeNclNativeMethods.HttpApi.HttpCancelHttpRequest(requestQueueHandle, requestId, IntPtr.Zero); }
private unsafe void CreateRequestQueueHandle() { uint statusCode = UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS; HttpRequestQueueV2Handle requestQueueHandle = null; statusCode = UnsafeNclNativeMethods.SafeNetHandles.HttpCreateRequestQueue( UnsafeNclNativeMethods.HttpApi.Version, null, null, 0, out requestQueueHandle); if (statusCode != UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS) { throw new HttpListenerException((int)statusCode); } // Disabling callbacks when IO operation completes synchronously (returns ErrorCodes.ERROR_SUCCESS) if (SkipIOCPCallbackOnSuccess && !UnsafeNclNativeMethods.SetFileCompletionNotificationModes( requestQueueHandle, UnsafeNclNativeMethods.FileCompletionNotificationModes.SkipCompletionPortOnSuccess | UnsafeNclNativeMethods.FileCompletionNotificationModes.SkipSetEventOnHandle)) { throw new HttpListenerException(Marshal.GetLastWin32Error()); } m_RequestQueueHandle = requestQueueHandle; }
internal static extern unsafe uint HttpReceiveClientCertificate(CriticalHandle requestQueueHandle, ulong connectionId, uint flags, HTTP_SSL_CLIENT_CERT_INFO* pSslClientCertInfo, uint sslClientCertInfoSize, uint* pBytesReceived, NativeOverlapped* pOverlapped);
internal static extern uint HttpReceiveClientCertificate(CriticalHandle requestQueueHandle, ulong connectionId, uint flags, byte* pSslClientCertInfo, uint sslClientCertInfoSize, uint* pBytesReceived, NativeOverlapped* pOverlapped);
internal static extern uint HttpReceiveHttpRequest(CriticalHandle requestQueueHandle, ulong requestId, uint flags, HTTP_REQUEST* pRequestBuffer, uint requestBufferLength, uint* pBytesReturned, NativeOverlapped* pOverlapped);
/// <summary> /// Used in Marshalling code /// Gets the handle of the CriticalHandle /// </summary> public static IntPtr GetHandle(CriticalHandle criticalHandle) { return(criticalHandle.handle); }
internal static extern uint HttpSendResponseEntityBody(CriticalHandle requestQueueHandle, ulong requestId, uint flags, ushort entityChunkCount, HTTP_DATA_CHUNK* pEntityChunks, uint* pBytesSent, SafeLocalFree pRequestBuffer, uint requestBufferLength, NativeOverlapped* pOverlapped, void* pLogData);
/// <summary> /// Used in Marshalling code /// Sets the handle of the CriticalHandle /// </summary> public static void SetHandle(CriticalHandle criticalHandle, IntPtr handle) { criticalHandle.handle = handle; }
internal static extern uint HttpSendResponseEntityBody2(CriticalHandle requestQueueHandle, ulong requestId, uint flags, ushort entityChunkCount, IntPtr pEntityChunks, out uint pBytesSent, SafeLocalFree pRequestBuffer, uint requestBufferLength, SafeHandle pOverlapped, IntPtr pLogData);
public static IntPtr GetCriticalHandle(CriticalHandle criticalHandle) { throw new NotSupportedException("GetCriticalHandle"); }
/// <summary> /// Used in Marshalling code /// Sets the handle of the CriticalHandle /// </summary> public static void SetHandle(CriticalHandle criticalHandle, IntPtr handle) { InteropExtensions.SetCriticalHandle(criticalHandle, handle); }
internal static unsafe extern uint CancelIoEx(CriticalHandle handle, NativeOverlapped* overlapped);
internal void CancelLastWrite(CriticalHandle requestQueueHandle) { if (m_ResponseStream != null) { m_ResponseStream.CancelLastWrite(requestQueueHandle); } }
internal static unsafe extern bool SetFileCompletionNotificationModes(CriticalHandle handle, FileCompletionNotificationModes modes);
public static void SetCriticalHandle(CriticalHandle criticalHandle, IntPtr handle) { throw new NotSupportedException("SetCriticalHandle"); }
internal static extern uint HttpReceiveRequestEntityBody2(CriticalHandle requestQueueHandle, ulong requestId, uint flags, void* pEntityBuffer, uint entityBufferLength, out uint bytesReturned, [In] SafeHandle pOverlapped);
public static void SetCriticalHandle(CriticalHandle criticalHandle, IntPtr handle) { criticalHandle.SetHandleInternal(handle); }
internal static extern unsafe uint HttpReceiveRequestEntityBody(CriticalHandle requestQueueHandle, ulong requestId, uint flags, void* pEntityBuffer, uint entityBufferLength, uint* pBytesReturned, NativeOverlapped* pOverlapped);