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);
}
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);
}
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);
}
