int StartOperation(ref AsyncProtocolRequest nestedRequest, ref BufferOffsetSize internalBuffer, AsyncOperation operation, AsyncProtocolRequest asyncRequest, string name)
        {
            if (Interlocked.CompareExchange(ref nestedRequest, asyncRequest, null) != null)
            {
                throw new InvalidOperationException("Invalid nested call.");
            }

            bool failed = false;

            try {
                internalBuffer.Reset();
                asyncRequest.StartOperation(operation);
                return(asyncRequest.UserResult);
            } catch (Exception e) {
                failed = true;
                if (e is IOException)
                {
                    throw;
                }
                throw new IOException(name + " failed", e);
            } finally {
                if (asyncRequest.UserAsyncResult == null || failed)
                {
                    internalBuffer.Reset();
                    nestedRequest = null;
                }
            }
        }
        int ProcessReadOrWrite(ref AsyncProtocolRequest nestedRequest, ref BufferOffsetSize internalBuffer, AsyncOperation operation, BufferOffsetSize userBuffer, LazyAsyncResult lazyResult)
        {
            if (userBuffer == null || userBuffer.Buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            if (userBuffer.Offset < 0)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (userBuffer.Size < 0 || userBuffer.Offset + userBuffer.Size > userBuffer.Buffer.Length)
            {
                throw new ArgumentOutOfRangeException("count");
            }

            CheckThrow(true);

            var name = internalBuffer == readBuffer ? "read" : "write";

            Debug("ProcessReadOrWrite: {0} {1}", name, userBuffer);

            var asyncRequest = new AsyncProtocolRequest(this, lazyResult, userBuffer);

            return(StartOperation(ref nestedRequest, ref internalBuffer, operation, asyncRequest, name));
        }
        IAsyncResult BeginReadOrWrite(ref AsyncProtocolRequest nestedRequest, ref BufferOffsetSize internalBuffer, AsyncOperation operation, BufferOffsetSize userBuffer, AsyncCallback asyncCallback, object asyncState)
        {
            LazyAsyncResult lazyResult = new LazyAsyncResult(this, asyncState, asyncCallback);

            ProcessReadOrWrite(ref nestedRequest, ref internalBuffer, operation, userBuffer, lazyResult);
            return(lazyResult);
        }
        public MobileAuthenticatedStream(Stream innerStream, bool leaveInnerStreamOpen, MonoTlsSettings settings, AppleTlsProvider provider)
            : base(innerStream, leaveInnerStreamOpen)
        {
            Settings = settings;
            Provider = provider;

            readBuffer  = new BufferOffsetSize(new byte [16384], 0, 0);
            writeBuffer = new BufferOffsetSize(new byte [16384], 0, 0);
        }
Пример #5
0
        int InternalRead(AsyncProtocolRequest asyncRequest, BufferOffsetSize internalBuffer, byte[] buffer, int offset, int size, out bool wantMore)
        {
            if (asyncRequest == null)
            {
                throw new InvalidOperationException();
            }

            Debug("InternalRead: {0} {1} {2}", internalBuffer, offset, size);

            /*
             * One of Apple's native functions wants to read 'size' bytes of data.
             *
             * First, we check whether we already have enough in the internal buffer.
             *
             * If the internal buffer is empty (it will be the first time we're called), we save
             * the amount of bytes that were requested and return 'SslStatus.WouldBlock' to our
             * native caller.  This native function will then return this code to managed code,
             * where we read the requested amount of data into the internal buffer, then call the
             * native function again.
             */
            if (internalBuffer.Size == 0 && !internalBuffer.Complete)
            {
                Debug("InternalRead #1: {0} {1}", internalBuffer.Offset, internalBuffer.TotalBytes);
                internalBuffer.Offset = internalBuffer.Size = 0;
                asyncRequest.RequestRead(size);
                wantMore = true;
                return(0);
            }

            /*
             * The second time we're called, the native buffer will contain the exact amount of data that the
             * previous call requested from us, so we should be able to return it all here.  However, just in
             * case that Apple's native function changed its mind, we can also return less.
             *
             * In either case, if we have any data buffered, then we return as much of it as possible - if the
             * native code isn't satisfied, then it will call us again to request more.
             */
            var len = Math.Min(internalBuffer.Size, size);

            Buffer.BlockCopy(internalBuffer.Buffer, internalBuffer.Offset, buffer, offset, len);
            internalBuffer.Offset += len;
            internalBuffer.Size   -= len;
            wantMore = !internalBuffer.Complete && len < size;
            return(len);
        }
Пример #6
0
 public AsyncProtocolRequest(MobileAuthenticatedStream parent, LazyAsyncResult lazyResult, BufferOffsetSize userBuffer = null)
 {
     Parent          = parent;
     UserAsyncResult = lazyResult;
     UserBuffer      = userBuffer;
 }
        int InternalWrite(AsyncProtocolRequest asyncRequest, BufferOffsetSize internalBuffer, byte[] buffer, int offset, int size, out bool wantMore)
        {
            if (asyncRequest == null)
            {
                /*
                 * The only situation where 'asyncRequest' could possibly be 'null' is when we're called
                 * from within SSLClose() - which might attempt to send the close_notity notification.
                 * Since this notification message is very small, it should definitely fit into our internal
                 * buffer, so we just save it in there and after SSLClose() returns, the final call to
                 * InternalFlush() - just before closing the underlying stream - will send it out.
                 */
                if (lastException != null)
                {
                    wantMore = false;
                    return(-1);
                }

                if (Interlocked.Exchange(ref closeRequested, 1) == 0)
                {
                    internalBuffer.Reset();
                }
                else if (internalBuffer.Remaining == 0)
                {
                    throw new InvalidOperationException();
                }
            }

            /*
             * Normal write - can be either SSLWrite() or SSLHandshake().
             *
             * Copy as much of the data into the internal buffer and only return SslStatus.WouldBlock when
             * it's full.
             *
             */
            if (internalBuffer.Remaining == 0)
            {
                // Internal buffer is full, so we must actually write all the data now.
                asyncRequest.RequestWrite();
                wantMore = true;
                return(0);
            }

            var len = Math.Min(internalBuffer.Remaining, size);

            Buffer.BlockCopy(buffer, offset, internalBuffer.Buffer, internalBuffer.EndOffset, len);
            internalBuffer.Size += len;
            wantMore             = len < size;

            /*
             * Calling 'asyncRequest.RequestWrite()' here ensures that ProcessWrite() is called next
             * time we regain control from native code.
             *
             * During the handshake, the native code won't actually realize (unless if attempts to send
             * so much that the write buffer gets full) that we only buffered the data.
             *
             * However, it doesn't matter because it will either return with a completed handshake
             * (and doesn't care whether the remote actually received the data) or it will expect more
             * data from the remote and request a read.  In either case, we regain control in managed
             * code and can flush out the data.
             *
             * Note that a calling RequestWrite() followed by RequestRead() will first flush the write
             * queue once we return to managed code - before attempting to read anything.
             */
            if (asyncRequest != null)
            {
                asyncRequest.RequestWrite();
            }

            return(len);
        }