internal unsafe HttpResponseStreamAsyncResult(object asyncObject, object userState, AsyncCallback callback, byte[] buffer, int offset, int size, bool chunked, bool sentHeaders) : base(asyncObject, userState, callback)
        {
            this.m_SentHeaders = sentHeaders;
            Overlapped overlapped = new Overlapped {
                AsyncResult = this
            };

            if (size == 0)
            {
                this.m_DataChunks  = null;
                this.m_pOverlapped = overlapped.Pack(s_IOCallback, null);
            }
            else
            {
                this.m_DataChunks = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK[chunked ? 3 : 1];
                object[] userData = new object[1 + this.m_DataChunks.Length];
                userData[this.m_DataChunks.Length] = this.m_DataChunks;
                int    num = 0;
                byte[] arr = null;
                if (chunked)
                {
                    arr = ConnectStream.GetChunkHeader(size, out num);
                    this.m_DataChunks[0] = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
                    this.m_DataChunks[0].DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
                    this.m_DataChunks[0].BufferLength  = (uint)(arr.Length - num);
                    userData[0]          = arr;
                    this.m_DataChunks[1] = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
                    this.m_DataChunks[1].DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
                    this.m_DataChunks[1].BufferLength  = (uint)size;
                    userData[1]          = buffer;
                    this.m_DataChunks[2] = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
                    this.m_DataChunks[2].DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
                    this.m_DataChunks[2].BufferLength  = (uint)NclConstants.CRLF.Length;
                    userData[2] = NclConstants.CRLF;
                }
                else
                {
                    this.m_DataChunks[0] = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
                    this.m_DataChunks[0].DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
                    this.m_DataChunks[0].BufferLength  = (uint)size;
                    userData[0] = buffer;
                }
                this.m_pOverlapped = overlapped.Pack(s_IOCallback, userData);
                if (chunked)
                {
                    this.m_DataChunks[0].pBuffer = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(arr, num);
                    this.m_DataChunks[1].pBuffer = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset);
                    this.m_DataChunks[2].pBuffer = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(NclConstants.CRLF, 0);
                }
                else
                {
                    this.m_DataChunks[0].pBuffer = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset);
                }
            }
        }
Beispiel #2
0
        internal HttpResponseStreamAsyncResult(object asyncObject, object userState, AsyncCallback callback, byte[] buffer, int offset, int size, bool chunked, bool sentHeaders) : base(asyncObject, userState, callback)
        {
            m_SentHeaders = sentHeaders;
            Overlapped overlapped = new Overlapped();

            overlapped.AsyncResult = this;

            if (size == 0)
            {
                m_DataChunks  = null;
                m_pOverlapped = overlapped.Pack(s_IOCallback, null);
            }
            else
            {
                m_DataChunks = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK[chunked ? 3 : 1];

                GlobalLog.Print("HttpResponseStreamAsyncResult#" + ValidationHelper.HashString(this) + "::.ctor() m_pOverlapped:0x" + ((IntPtr)m_pOverlapped).ToString("x8"));

                object[] objectsToPin = new object[1 + m_DataChunks.Length];
                objectsToPin[m_DataChunks.Length] = m_DataChunks;


                int    chunkHeaderOffset = 0;
                byte[] chunkHeaderBuffer = null;
                if (chunked)
                {
                    chunkHeaderBuffer = ConnectStream.GetChunkHeader(size, out chunkHeaderOffset);

                    m_DataChunks[0] = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
                    m_DataChunks[0].DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
                    m_DataChunks[0].BufferLength  = (uint)(chunkHeaderBuffer.Length - chunkHeaderOffset);

                    objectsToPin[0] = chunkHeaderBuffer;

                    m_DataChunks[1] = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
                    m_DataChunks[1].DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
                    m_DataChunks[1].BufferLength  = (uint)size;

                    objectsToPin[1] = buffer;

                    m_DataChunks[2] = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
                    m_DataChunks[2].DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
                    m_DataChunks[2].BufferLength  = (uint)NclConstants.CRLF.Length;

                    objectsToPin[2] = NclConstants.CRLF;
                }
                else
                {
                    m_DataChunks[0] = new UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK();
                    m_DataChunks[0].DataChunkType = UnsafeNclNativeMethods.HttpApi.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory;
                    m_DataChunks[0].BufferLength  = (uint)size;

                    objectsToPin[0] = buffer;
                }

                // This call will pin needed memory
                m_pOverlapped = overlapped.Pack(s_IOCallback, objectsToPin);

                if (chunked)
                {
                    m_DataChunks[0].pBuffer = (byte *)(Marshal.UnsafeAddrOfPinnedArrayElement(chunkHeaderBuffer, chunkHeaderOffset));
                    m_DataChunks[1].pBuffer = (byte *)(Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset));
                    m_DataChunks[2].pBuffer = (byte *)(Marshal.UnsafeAddrOfPinnedArrayElement(NclConstants.CRLF, 0));
                }
                else
                {
                    m_DataChunks[0].pBuffer = (byte *)(Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset));
                }
            }
        }