示例#1
0
        private bool SetHeadersAsync(SimpleAsyncResult result, bool setInternalLength)
        {
            if (headersSent)
            {
                return(false);
            }

            string method         = request.Method;
            bool   no_writestream = (method == "GET" || method == "CONNECT" || method == "HEAD" || method == "TRACE");
            bool   webdav         = (method == "PROPFIND" || method == "PROPPATCH" || method == "MKCOL" || method == "COPY" || method == "MOVE" || method == "LOCK" ||
                                     method == "UNLOCK");

            if (setInternalLength && !no_writestream && writeBuffer != null)
            {
                request.InternalContentLength = writeBuffer.Length;
            }

            if (!(sendChunked || request.ContentLength > -1 || no_writestream || webdav))
            {
                return(false);
            }

            headersSent = true;
            headers     = request.GetRequestHeaders();

            var innerResult = cnc.BeginWrite(request, headers, 0, headers.Length, r =>
            {
                try
                {
                    cnc.EndWrite(request, true, r);
                    if (!initRead)
                    {
                        initRead = true;
                        WebConnection.InitRead(cnc);
                    }
                    var cl = request.ContentLength;
                    if (!sendChunked && cl == 0)
                    {
                        requestWritten = true;
                    }
                    result.SetCompleted(false);
                }
                catch (WebException e)
                {
                    result.SetCompleted(false, e);
                }
                catch (Exception e)
                {
                    result.SetCompleted(false, new WebException("Error writing headers", e, WebExceptionStatus.SendFailure));
                }
            }, null);

            return(innerResult != null);
        }
示例#2
0
        public static void Run(SimpleAsyncFunc func, SimpleAsyncCallback callback)
        {
            var result = new SimpleAsyncResult(callback);

            try
            {
                if (!func(result))
                {
                    result.SetCompleted(true);
                }
            }
            catch (Exception ex)
            {
                result.SetCompleted(true, ex);
            }
        }
示例#3
0
        internal bool WriteRequestAsync(SimpleAsyncResult result)
        {
            if (requestWritten)
            {
                return(false);
            }

            requestWritten = true;
            if (sendChunked || !allowBuffering || writeBuffer == null)
            {
                return(false);
            }

            // Keep the call for a potential side-effect of GetBuffer
            var bytes  = writeBuffer.GetBuffer();
            var length = (int)writeBuffer.Length;

            if (request.ContentLength != -1 && request.ContentLength < length)
            {
                nextReadCalled = true;
                cnc.Close(true);
                throw new WebException("Specified Content-Length is less than the number of bytes to write", null, WebExceptionStatus.ServerProtocolViolation, null);
            }

            SetHeadersAsync(true, inner =>
            {
                if (inner.GotException)
                {
                    result.SetCompleted(inner.CompletedSynchronously, inner.Exception);
                    return;
                }

                if (cnc.Data.StatusCode != 0 && cnc.Data.StatusCode != 100)
                {
                    result.SetCompleted(inner.CompletedSynchronously);
                    return;
                }

                if (!initRead)
                {
                    initRead = true;
                    WebConnection.InitRead(cnc);
                }

                if (length == 0)
                {
                    complete_request_written = true;
                    result.SetCompleted(inner.CompletedSynchronously);
                    return;
                }

                cnc.BeginWrite(request, bytes, 0, length, r =>
                {
                    try
                    {
                        complete_request_written = cnc.EndWrite(request, false, r);
                        result.SetCompleted(false);
                    }
                    catch (Exception exc)
                    {
                        result.SetCompleted(false, exc);
                    }
                }, null);
            });

            return(true);
        }