private int StartReading(byte[] buffer, int offset, int count, AsyncProtocolRequest asyncRequest) { int num = 0; Label_0002: if (asyncRequest != null) { asyncRequest.SetNextRequest(buffer, offset, count, _ResumeAsyncReadCallback); } int userResult = this._SslState.CheckEnqueueRead(buffer, offset, count, asyncRequest); switch (userResult) { case 0: return 0; case -1: num = this.StartFrameHeader(buffer, offset, count, asyncRequest); if (num == -1) { goto Label_0002; } return num; } if (asyncRequest != null) { asyncRequest.CompleteUser(userResult); } return userResult; }
private void StartWriting(byte[] buffer, int offset, int count, AsyncProtocolRequest asyncRequest) { if (asyncRequest != null) { asyncRequest.SetNextRequest(buffer, offset, count, _ResumeAsyncWriteCallback); } if (count >= 0) { byte[] outBuffer = null; do { int num2; if (this._SslState.CheckEnqueueWrite(asyncRequest)) { return; } int num = Math.Min(count, this._SslState.MaxDataSize); SecurityStatus errorCode = this._SslState.EncryptData(buffer, offset, num, ref outBuffer, out num2); if (errorCode != SecurityStatus.OK) { ProtocolToken token = new ProtocolToken(null, errorCode); throw new IOException(SR.GetString("net_io_encrypt"), token.GetException()); } if (asyncRequest != null) { asyncRequest.SetNextRequest(buffer, offset + num, count - num, _ResumeAsyncWriteCallback); IAsyncResult asyncResult = this._SslState.InnerStream.BeginWrite(outBuffer, 0, num2, _WriteCallback, asyncRequest); if (!asyncResult.CompletedSynchronously) { return; } this._SslState.InnerStream.EndWrite(asyncResult); } else { this._SslState.InnerStream.Write(outBuffer, 0, num2); } offset += num; count -= num; this._SslState.FinishWrite(); } while (count != 0); } if (asyncRequest != null) { asyncRequest.CompleteUser(); } }
private int StartFrameBody(int readBytes, byte[] buffer, int offset, int count, AsyncProtocolRequest asyncRequest) { if (readBytes == 0) { this.DecrementInternalBufferCount(this.InternalBufferCount); if (asyncRequest != null) { asyncRequest.CompleteUser(0); } return 0; } readBytes = this._SslState.GetRemainingFrameSize(this.InternalBuffer, readBytes); if (readBytes < 0) { throw new IOException(SR.GetString("net_frame_read_size")); } this.EnsureInternalBufferSize(this._SslState.HeaderSize, readBytes); if (asyncRequest != null) { asyncRequest.SetNextRequest(this.InternalBuffer, this._SslState.HeaderSize, readBytes, _ReadFrameCallback); this._Reader.AsyncReadPacket(asyncRequest); if (!asyncRequest.MustCompleteSynchronously) { return 0; } readBytes = asyncRequest.Result; } else { readBytes = this._Reader.ReadPacket(this.InternalBuffer, this._SslState.HeaderSize, readBytes); } return this.ProcessFrameBody(readBytes, buffer, offset, count, asyncRequest); }
private int ProcessReadErrorCode(SecurityStatus errorCode, byte[] buffer, int offset, int count, AsyncProtocolRequest asyncRequest, byte[] extraBuffer) { ProtocolToken token = new ProtocolToken(null, errorCode); if (token.Renegotiate) { this._SslState.ReplyOnReAuthentication(extraBuffer); return -1; } if (!token.CloseConnection) { throw new IOException(SR.GetString("net_io_decrypt"), token.GetException()); } this._SslState.FinishRead(null); if (asyncRequest != null) { asyncRequest.CompleteUser(0); } return 0; }
private int ProcessRead(byte[] buffer, int offset, int count, AsyncProtocolRequest asyncRequest) { int num2; this.ValidateParameters(buffer, offset, count); if (Interlocked.Exchange(ref this._NestedRead, 1) == 1) { throw new NotSupportedException(SR.GetString("net_io_invalidnestedcall", new object[] { (asyncRequest != null) ? "BeginRead" : "Read", "read" })); } bool flag = false; try { if (this.InternalBufferCount != 0) { int num = (this.InternalBufferCount > count) ? count : this.InternalBufferCount; if (num != 0) { Buffer.BlockCopy(this.InternalBuffer, this.InternalOffset, buffer, offset, num); this.DecrementInternalBufferCount(num); } if (asyncRequest != null) { asyncRequest.CompleteUser(num); } return num; } num2 = this.StartReading(buffer, offset, count, asyncRequest); } catch (Exception exception) { this._SslState.FinishRead(null); flag = true; if (exception is IOException) { throw; } throw new IOException(SR.GetString("net_io_read"), exception); } finally { if ((asyncRequest == null) || flag) { this._NestedRead = 0; } } return num2; }
private int ProcessFrameBody(int readBytes, byte[] buffer, int offset, int count, AsyncProtocolRequest asyncRequest) { if (readBytes == 0) { throw new IOException(SR.GetString("net_io_eof")); } readBytes += this._SslState.HeaderSize; int num = 0; SecurityStatus errorCode = this._SslState.DecryptData(this.InternalBuffer, ref num, ref readBytes); if (errorCode != SecurityStatus.OK) { byte[] dst = null; if (readBytes != 0) { dst = new byte[readBytes]; Buffer.BlockCopy(this.InternalBuffer, num, dst, 0, readBytes); } this.DecrementInternalBufferCount(this.InternalBufferCount); return this.ProcessReadErrorCode(errorCode, buffer, offset, count, asyncRequest, dst); } if ((readBytes == 0) && (count != 0)) { this.DecrementInternalBufferCount(this.InternalBufferCount); return -1; } this.EnsureInternalBufferSize(0, num + readBytes); this.DecrementInternalBufferCount(num); if (readBytes > count) { readBytes = count; } Buffer.BlockCopy(this.InternalBuffer, this.InternalOffset, buffer, offset, readBytes); this.DecrementInternalBufferCount(readBytes); this._SslState.FinishRead(null); if (asyncRequest != null) { asyncRequest.CompleteUser(readBytes); } return readBytes; }
private void FinishHandshake(Exception e, AsyncProtocolRequest asyncRequest) { try { lock (this) { if (e != null) { this.SetException(e); } this.FinishHandshakeRead(0); if (Interlocked.CompareExchange(ref this._LockWriteState, 0, 2) == 3) { this._LockWriteState = 1; object state = this._QueuedWriteStateRequest; if (state != null) { this._QueuedWriteStateRequest = null; if (state is LazyAsyncResult) { ((LazyAsyncResult) state).InvokeCallback(); } else { ThreadPool.QueueUserWorkItem(new WaitCallback(this.CompleteRequestWaitCallback), state); } } } } } finally { if (asyncRequest != null) { if (e != null) { asyncRequest.CompleteWithError(e); } else { asyncRequest.CompleteUser(); } } } }