public StreamByteCounter(Stream src)
{
AsyncCallback onEndRead = null;
onEndRead = delegate(IAsyncResult ar) {
int c = src.EndRead(ar);
if (c != 0) {
lock(this) { pendingReads++; }
//
// For each read, we must allocate a new buffer.
//
byte[] nb = new byte[CHUNK_SIZE];
src.BeginRead(nb, 0, nb.Length, onEndRead, nb);
//
// The buffer of the current read is passed through the
// IAsyncResult.AsyncState property.
//
byte[] cb = (byte[])ar.AsyncState;
//
// Increment occurrence counters.
//
lock(this) {
for (int i = 0; i < c; i++) {
counters[cb[i]]++;
}
}
}
//
// The data of the current read processed; so, decrement
// the pending counter, and if the counter reaches zero,
// signal the "done" event.
//
lock(this) {
if (--pendingReads == 0) {
done.Set();
}
}
};
//
// Allocate the buffer for the first read, and issue it.
//
byte[] fb = new byte[CHUNK_SIZE];
pendingReads = 1;
src.BeginRead(fb, 0, fb.Length, onEndRead, fb);
}
private bool EndReading(IAsyncResult result)
{
try
{
int bytesRead = netStream?.EndRead(result) ?? 0;
return(ProcessReadBytes(bytesRead));
}
catch (Exception ex)
{
RecordConnectionFailed(ConnectionFailureType.InternalFailure, ex);
return(false);
}
}
public static bool ReadBeyondEndTest(Stream s)
{
Console.WriteLine("Read Beyond End test on "+s.GetType().Name);
byte[] bytes = new byte[10];
for(int i=0; i<bytes.Length; i++)
bytes[i] = (byte) i;
s.Seek(5, SeekOrigin.End);
if (s.Position != s.Length + 5)
{
iCountErrors++;
throw new Exception("Position is incorrect! Seek(5, SeekOrigin.End) should leave us at s.Length + 5, but got: "+s.Position);
}
int numRead = s.Read(bytes, 0, bytes.Length);
if (numRead != 0)
{
iCountErrors++ ;
throw new Exception("Reading from past end of stream is broken! Expected 0, got: "+numRead);
}
for(int i=0; i<bytes.Length; i++)
{
if (bytes[i] != (byte) i)
{
iCountErrors++ ;
throw new Exception("Error in byte[] - Read overwrote it! pos: "+i+" got: "+bytes[i]);
}
}
numRead = s.ReadByte();
if (numRead != -1)
{
iCountErrors++ ;
throw new Exception("ReadByte didn't return -1! got: "+numRead);
}
IAsyncResult ar = s.BeginRead(bytes, 0, bytes.Length, null, null);
numRead = s.EndRead(ar);
if (numRead != 0)
{
iCountErrors++ ;
throw new Exception("Reading from past end of stream with BeginRead is broken! Expected 0, got: "+numRead);
}
for(int i=0; i<bytes.Length; i++)
if (bytes[i] != (byte) i)
{
iCountErrors++ ;
throw new Exception("Error in byte[] - BeginRead overwrote it! pos: "+i+" got: "+bytes[i]);
}
return true;
}
private void OnReadInternal(IAsyncResult ares)
{
_timer.Change(Timeout.Infinite, Timeout.Infinite);
int nread = -1;
try
{
nread = _stream.EndRead(ares);
_memoryStream !.Write(_buffer !, 0, nread);
if (_memoryStream.Length > 32768)
{
SendError(HttpStatusDescription.Get(400), 400);
Close(true);
return;
}
}
catch
{
if (_memoryStream != null && _memoryStream.Length > 0)
{
SendError();
}
if (_socket != null)
{
CloseSocket();
Unbind();
}
return;
}
if (nread == 0)
{
CloseSocket();
Unbind();
return;
}
if (ProcessInput(_memoryStream))
{
if (!_context.HaveError)
{
_context.Request.FinishInitialization();
}
if (_context.HaveError)
{
SendError();
Close(true);
return;
}
if (!_epl.BindContext(_context))
{
const int NotFoundErrorCode = 404;
SendError(HttpStatusDescription.Get(NotFoundErrorCode), NotFoundErrorCode);
Close(true);
return;
}
HttpListener listener = _context._listener !;
if (_lastListener != listener)
{
RemoveConnection();
listener.AddConnection(this);
_lastListener = listener;
}
_contextBound = true;
listener.RegisterContext(_context);
return;
}
_stream.BeginRead(_buffer !, 0, BufferSize, s_onreadCallback, this);
}
/// <summary>
/// Waits for the pending asynchronous read to complete.
/// </summary>
/// <param name="asyncResult">
/// The reference to the pending asynchronous request to finish.
/// </param>
/// <returns>
/// The number of bytes read from the stream, between zero (0)
/// and the number of bytes you requested. Streams only return
/// zero (0) at the end of the stream, otherwise, they should
/// block until at least one byte is available.
/// </returns>
public override int EndRead(IAsyncResult asyncResult)
{
CheckClosed();
return(stream.EndRead(asyncResult));
}
public override int EndRead(IAsyncResult asyncResult)
{
return(_underlyingStream.EndRead(asyncResult));
}
public override int EndRead(IAsyncResult asyncResult)
{
return(_innerStream.EndRead(asyncResult));
}
public override int EndRead(IAsyncResult asyncResult)
{
return(mBaseStream.EndRead(asyncResult));
}
/// <exception cref="BadRequestException"><c>BadRequestException</c>.</exception>
private void OnReceive(IAsyncResult ar)
{
try
{
int bytesRead = Stream.EndRead(ar);
if (bytesRead == 0)
{
Disconnect(SocketError.ConnectionReset);
return;
}
_bytesLeft += bytesRead;
if (_bytesLeft > _buffer.Length)
{
#if DEBUG
throw new BadRequestException("Too large HTTP header: " + Encoding.UTF8.GetString(_buffer, 0, bytesRead));
#else
throw new BadRequestException("Too large HTTP header: " + _bytesLeft);
#endif
}
#if DEBUG
#pragma warning disable 219
string temp = Encoding.ASCII.GetString(_buffer, 0, _bytesLeft);
LogWriter.Write(this, LogPrio.Trace, "Received: " + temp);
#pragma warning restore 219
#endif
int offset = _parser.Parse(_buffer, 0, _bytesLeft);
if (Stream == null)
{
return; // "Connection: Close" in effect.
}
// try again to see if we can parse another message (check parser to see if it is looking for a new message)
int oldOffset = offset;
while (_parser.CurrentState == RequestParserState.FirstLine && offset != 0 && _bytesLeft - offset > 0)
{
#if DEBUG
temp = Encoding.ASCII.GetString(_buffer, offset, _bytesLeft - offset);
LogWriter.Write(this, LogPrio.Trace, "Processing: " + temp);
#endif
offset = _parser.Parse(_buffer, offset, _bytesLeft - offset);
if (Stream == null)
{
return; // "Connection: Close" in effect.
}
}
// need to be able to move prev bytes, so restore offset.
if (offset == 0)
{
offset = oldOffset;
}
// workaround until the source of the bug can be identified.
if (_bytesLeft < offset)
{
_log.Write(this, LogPrio.Error, "Have a bug where _bytesLeft is less then offset, trying to fix. BytsLeft: " + _bytesLeft + ", offset: " + offset);
_bytesLeft = offset;
}
// copy unused bytes to the beginning of the array
if (offset > 0 && _bytesLeft != offset)
{
Buffer.BlockCopy(_buffer, offset, _buffer, 0, _bytesLeft - offset);
}
_bytesLeft -= offset;
if (Stream != null && Stream.CanRead)
{
Stream.BeginRead(_buffer, _bytesLeft, _buffer.Length - _bytesLeft, OnReceive, null);
}
else
{
_log.Write(this, LogPrio.Warning, "Could not read any more from the socket.");
Disconnect(SocketError.Success);
}
}
catch (BadRequestException err)
{
LogWriter.Write(this, LogPrio.Warning, "Bad request, responding with it. Error: " + err);
try
{
Respond("HTTP/1.0", HttpStatusCode.BadRequest, err.Message);
}
catch (Exception err2)
{
LogWriter.Write(this, LogPrio.Fatal, "Failed to reply to a bad request. " + err2);
}
Disconnect(SocketError.NoRecovery);
}
catch (IOException err)
{
LogWriter.Write(this, LogPrio.Debug, "Failed to end receive: " + err.Message);
if (err.InnerException is SocketException)
{
Disconnect((SocketError)((SocketException)err.InnerException).ErrorCode);
}
else
{
Disconnect(SocketError.ConnectionReset);
}
}
catch (ObjectDisposedException err)
{
LogWriter.Write(this, LogPrio.Debug, "Failed to end receive : " + err.Message);
Disconnect(SocketError.NotSocket);
}
catch (NullReferenceException err)
{
LogWriter.Write(this, LogPrio.Debug, "Failed to end receive : NullRef: " + err.Message);
Disconnect(SocketError.NoRecovery);
}
}
/// <inheritdoc/>
public override int EndRead(IAsyncResult asyncResult)
{
ThrowIfDisposed();
return(_stream.EndRead(asyncResult));
}
public static bool CanPropertiesTest(Stream s)
{
Console.WriteLine(" (06) Can-Properties Test on "+s.GetType( ).Name);
byte[] bytes = new byte[1];
int bytesTransferred;
IAsyncResult asyncResult;
if(s.CanRead)
{ // Ensure all Read methods work, if CanRead is true.
int n = s.ReadByte( );
if(n==-1)
throw new Exception("On a readable stream, ReadByte returned -1...");
bytesTransferred=s.Read(bytes,0,1);
if(bytesTransferred!=1)
throw new Exception("Read(byte[],0,1) should have returned 1! got: "+bytesTransferred);
asyncResult=s.BeginRead(bytes,0,1,null,null); /* BeginRead */
bytesTransferred=s.EndRead(asyncResult); /* EndRead */
if(bytesTransferred!=1)
throw new Exception("BeginRead(byte[],0,1) should have returned 1! got: "
+bytesTransferred);
} // End of (s.CanRead) Block
else
{ // Begin of (!s.CanRead) Block
try
{
s.ReadByte( );
throw new Exception("ReadByte on an unreadable stream should have thrown!");
}
catch(NotSupportedException) { }
try
{
s.Read(bytes,0,1);
throw new Exception("Read(bytes,0,1) on an unreadable stream should have thrown!");
}
catch(NotSupportedException) { }
try
{
s.BeginRead(bytes,0,1,null,null); /* BeginRead */
throw new Exception("BeginRead on an unreadable stream should have thrown!");
}
catch(NotSupportedException) { }
} // End of (!s.CanRead) Block
if(s.CanWrite)
{ // Ensure write methods work if CanWrite returns true.
s.WriteByte(0);
s.Write(bytes,0,1);
asyncResult = s.BeginWrite(bytes,0,1,null,null); /* BeginWrite */
s.EndWrite(asyncResult); /* EndWrite */
} // End of (s.CanWrite) Block
else
{ // Begin of (!s.CanWrite) Block
try
{
s.WriteByte(2);
throw new Exception("WriteByte on an unreadable stream should have thrown!");
}
catch(NotSupportedException) { }
try
{
s.Write(bytes,0,1);
throw new Exception("Write(bytes,0,1) on an unreadable stream should have thrown!");
}
catch(NotSupportedException) { }
try
{
s.BeginWrite(bytes,0,1,null,null); /* BeginWrite */
throw new Exception("BeginWrite on an unreadable stream should have thrown!");
}
catch(NotSupportedException) { }
} // End of (!s.CanWrite) Block
if(s.CanSeek)
{ // Ensure length-related methods work if CanSeek returns true
long n = s.Length;
n=s.Position;
if(s.Position>s.Length)
throw new Exception("Position is beyond the length of the stream!");
s.Position=0;
s.Position=s.Length;
if(s.Position!=s.Seek(0,SeekOrigin.Current))
throw new Exception("s.Position!=s.Seek(0,SeekOrigin.Current)");
if(s.CanWrite) // Verify you can set the length, if it's writable.
s.SetLength(s.Length);
} // End of (s.CanSeek) Block
else
{ // Begin of (!s.CanSeek) Block
try
{
s.Position=5;
throw new Exception("set_Position should throw on a non-seekable stream!");
}
catch(NotSupportedException) { }
try
{
long n = s.Position;
throw new Exception("get_Position should throw on a non-seekable stream!");
}
catch(NotSupportedException) { }
try
{
long n = s.Length;
throw new Exception("get_Length should throw on a non-seekable stream!");
}
catch(NotSupportedException) { }
try
{
s.SetLength(1);
throw new Exception("SetLength should throw on a non-seekable stream!");
}
catch(NotSupportedException) { }
try
{
s.Seek(0,SeekOrigin.Current);
throw new Exception("Seek should throw on a non-seekable stream!");
}
catch(NotSupportedException) { }
} // End of (!s.CanSeek) Block
return true;
}
//
// File copy using APM performs asynchronous reads and asynchronous
// write operations.
//
static long ApmFileCopy2(Stream src, Stream dst)
{
var done = new ManualResetEventSlim(false);
long fileSize = 0;
IOException ioex = null;
int pendingWrites = 1; // Account for the last read of 0 bytes.
AsyncCallback onReadCompleted = null, onWriteCompleted = null;
onReadCompleted = delegate (IAsyncResult ar) {
int bytesRead = 0;
byte[] _rbuffer = (byte[])ar.AsyncState;
try {
bytesRead = src.EndRead(ar);
} catch (IOException _ioex) {
src.Close();
dst.Close();
ioex = _ioex;
done.Set();
return;
}
if (bytesRead != 0) {
//
// Allocate a buffer for the next read, and start write the current
// read buffer.
//
var writeFrom = (byte[])ar.AsyncState;
//
// Increment the pending writes counter and start writing
// the current read block.
//
Interlocked.Increment(ref pendingWrites);
dst.BeginWrite(writeFrom, 0, bytesRead, onWriteCompleted, bytesRead);
//
// After the write is taking place, start a new read.
// We ensure that the read block are written with the proper order.
//
var readTo = new byte[BUFFER_SIZE];
src.BeginRead(readTo, 0, readTo.Length, onReadCompleted, readTo);
} else {
// End of source file.
src.Close();
//
// Decrement the pending writes count and terminate copy if
// all writes are done.
//
if (Interlocked.Decrement(ref pendingWrites) == 0) {
//
// No writes are pending, close the destination file and
// set the *done* event.
//
dst.Close();
done.Set();
}
}
};
onWriteCompleted = delegate (IAsyncResult ar) {
int bytesWritten = (int)ar.AsyncState;
try {
dst.EndWrite(ar);
fileSize += bytesWritten;
} catch (IOException _ioex) {
dst.Close();
src.Close();
ioex = _ioex;
done.Set();
return;
}
//
// Decrement the pending writes count and terminate copy if
// all writes are done.
//
if (Interlocked.Decrement(ref pendingWrites) == 0) {
//
// No writes are pending, close the destination file and
// set the *done* event.
//
dst.Close();
done.Set();
}
};
//
// Start the copy process, issuing the first asynchronous read.
//
var firstBuf = new byte[BUFFER_SIZE];
src.BeginRead(firstBuf, 0, firstBuf.Length, onReadCompleted, firstBuf);
// Wait until completion.
done.Wait();
if (ioex != null) {
throw ioex;
}
return fileSize;
}
/// <exception cref="BadRequestException"><c>BadRequestException</c>.</exception>
private void OnReceive(IAsyncResult ar)
{
try
{
lock (_syncRoot)
{
int bytesRead = 0;
if (Stream != null)
{
bytesRead = Stream.EndRead(ar);
}
if (bytesRead == 0)
{
Disconnect(SocketError.ConnectionReset);
return;
}
_bytesLeft += bytesRead;
if (_bytesLeft > _buffer.Length)
{
#if DEBUG
throw new BadRequestException("Too large HTTP header: " + Encoding.UTF8.GetString(_buffer, 0, bytesRead));
#else
throw new BadRequestException("Too large HTTP header: " + _bytesLeft);
#endif
}
LogWriter.Write(this, LogPrio.Trace, "Received " + _bytesLeft + " bytes");
int offset = _parser.Parse(_buffer, 0, _bytesLeft);
if (Stream == null)
{
return; // "Connection: Close" in effect.
}
// try again to see if we can parse another message (check parser to see if it is looking for a new message)
int oldOffset = offset;
while (_parser.CurrentState == RequestParserState.FirstLine && offset != 0 && _bytesLeft - offset > 0)
{
offset = _parser.Parse(_buffer, offset, _bytesLeft - offset);
if (Stream == null)
{
return; // "Connection: Close" in effect.
}
}
// need to be able to move prev bytes, so restore offset.
if (offset == 0)
{
offset = oldOffset;
}
if (_bytesLeft - offset >= 0)
{
// copy unused bytes to the beginning of the array
if (offset > 0 && _bytesLeft != offset)
{
Buffer.BlockCopy(_buffer, offset, _buffer, 0, _bytesLeft - offset);
}
_bytesLeft -= offset;
}
else
{
_log.Write(this, LogPrio.Warning, "Cannot copy bytes, _bytesLeft=" + _bytesLeft + ", offset=" + offset);
}
if (Stream != null && Stream.CanRead)
{
Stream.BeginRead(_buffer, _bytesLeft, _buffer.Length - _bytesLeft, OnReceive, null);
}
else
{
_log.Write(this, LogPrio.Warning, "Could not read any more from the socket.");
Disconnect(SocketError.Success);
}
}
}
catch (BadRequestException err)
{
LogWriter.Write(this, LogPrio.Warning, "Bad request, responding with it. Error: " + err);
try
{
Respond(HttpHelper.HTTP10, HttpStatusCode.BadRequest, err.Message);
}
catch (Exception err2)
{
LogWriter.Write(this, LogPrio.Fatal, "Failed to reply to a bad request. " + err2);
}
Disconnect(SocketError.NoRecovery);
}
catch (IOException err)
{
LogWriter.Write(this, LogPrio.Debug, "Failed to end receive: " + err.Message);
if (err.InnerException is SocketException)
{
Disconnect((SocketError)((SocketException)err.InnerException).ErrorCode);
}
else
{
Disconnect(SocketError.ConnectionReset);
}
}
catch (ObjectDisposedException err)
{
LogWriter.Write(this, LogPrio.Debug, "Failed to end receive : " + err.Message);
Disconnect(SocketError.NotSocket);
}
}
private void readPacket(Stream st, CancellationToken token)
{
byte[] buf = new byte[0x40];
int offset = 0, buf_length = 0;
MemoryStream st_page = new MemoryStream(buf, 4, 32, false);
BinaryReader reader = new BinaryReader(st_page);
const int packet_length = 38;
bool read_next = true;
while (read_next)
{
bool reading = true;
if (offset > 0)
{
Array.Copy(buf, offset, buf, 0, buf_length -= offset);
}
st.BeginRead(buf, buf_length, packet_length - buf_length, result =>
{
try
{
int additional = st.EndRead(result);
if (additional == 0)
{
read_next = false;
}
buf_length += additional;
}
catch (Exception ex)
{
if (ex is IOException || ex is ObjectDisposedException)
{
read_next = false;
}
else
{
throw;
}
}
reading = false;
}, null);
while (reading)
{
token.ThrowIfCancellationRequested();
}
if (buf_length < packet_length)
{
continue;
}
offset = 0;
if (buf[0] != Sylphide_Protocol.header0)
{
offset = 1;
continue;
}
if (buf[1] != Sylphide_Protocol.header1)
{
offset = 2;
continue;
}
// buf[2..3] sequence number, not necessary
// buf[36..37] cheksum, not necessary
st_page.Position = 0;
readOnePage(reader); // update by using page information
buf_length = 0;
}
}
private void ReceivedData(IAsyncResult ar)
{
RequestState rs = (RequestState)ar.AsyncState;
HttpWebRequest req = rs.Req;
Stream resStream = rs.ResStream;
string url = rs.Url;
UrlType urltype = rs.WebUrlType;
string html = null;
int index = rs.Index;
int read = 0;
string HttpStatus;
try
{
read = resStream.EndRead(ar);
if (_stop)
{
rs.ResStream.Close();
req.Abort();
return;
}
if (read > 0)
{
MemoryStream ms = new MemoryStream(rs.Data, 0, read);
StreamReader reader = new StreamReader(ms, _encoding);
string str = reader.ReadToEnd();
rs.Html.Append(str);
var result = resStream.BeginRead(rs.Data, 0, rs.BufferSize,
new AsyncCallback(ReceivedData), rs);
return;
}
html = rs.Html.ToString();
SgmlReader sgmlRreader = new SgmlReader();
sgmlRreader.DocType = "HTML";
sgmlRreader.InputStream = new StringReader(html);
StringWriter sw = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(sw);
writer.Formatting = Formatting.Indented;
while (sgmlRreader.Read())
{
if (sgmlRreader.NodeType != XmlNodeType.Whitespace)
{
writer.WriteNode(sgmlRreader, true);
}
}
SaveContents(sw.ToString(), url, urltype);
HttpStatus = WebExceptionStatus.Success.ToString();
}
catch (WebException we)
{
_log.Error("ReceivedData: url = {0}, HttpStatus = {1}, Exception:{2}.", url, we.Status, we.Message);
_log.Error(we.StackTrace);
HttpStatus = we.Status.ToString();
}
catch (Exception e)
{
_log.Error("ReceivedData: url = {0}, Exception:{1}.", url, e.Message);
_log.Error(e.StackTrace);
HttpStatus = e.Message;
}
UrlInfo urlInfo = new UrlInfo(url, HttpStatus);
_dbm.write_to_db(urlInfo);
if (ContentsSaved != null)
{
ContentsSaved(HttpStatus, url);
}
_reqsBusy[index] = false;
RequestResource(index);
}
private void ReadCallback(IAsyncResult iar)
{
byte[] input = null;
try {
input = (byte[])iar.AsyncState;
usb_fs.EndRead(iar);
} catch (Exception ex) {
System.Console.WriteLine("EndRead exception:");
System.Console.WriteLine(ex);
}
try {
/* Data received, as bytes
*/
if (this.verbose_mode > 0)
{
System.Console.WriteLine("");
System.Console.WriteLine("IN BYTES:");
for (int i = 0; i < input.Length; i++)
{
if (i > 0 && i % 16 == 0)
{
System.Console.WriteLine("");
}
System.Console.Write("{0:x} ", input[i]);
}
System.Console.WriteLine("");
System.Console.WriteLine("");
}
if (input.Length > 3 && input[2] == 0x6) // ACK 0x1 0x1 0x6
{
last_message = null;
System.Console.WriteLine("ACK : DEVICE");
}
else if (input.Length > 3 && input[2] == 0x15) // NACK 0x1 0x1 0x15
{
System.Console.WriteLine("NACK : DEVICE");
// resend message?
}
else if (read_continues && input.Length > 0)
{
for (int i = 2; i < input[1] + 2; i++)
{
long_buffer.Add(input[i]);
}
if (long_buffer[long_buffer.Count - 2] == 0x3)
{
read_continues = false;
SendAck();
byte[] sliced = new byte[long_buffer.Count];
long_buffer.CopyTo(sliced);
long_buffer.Clear();
HandleMessageFromDevice(sliced);
}
}
else if (input.Length > 3 && input[1] + 2 <= usb_report_size && input[input[1]] == 0x3 && input[2] == 0x2)
{
// single report message
// 0x1 {message_length_byte} {message_data_bytes}
System.Console.WriteLine("ACK : POS");
SendAck();
byte[] sliced = new byte[input.Length - 2];
Array.Copy(input, 2, sliced, 0, sliced.Length);
HandleMessageFromDevice(sliced);
}
else if (input.Length > 3 && input[1] == 30)
{
// long message begins
read_continues = true;
long_buffer.Clear();
for (int i = 2; i < input[1] + 2; i++)
{
long_buffer.Add(input[i]);
}
}
else
{
SendNack();
System.Console.WriteLine("unknown message");
}
} catch (Exception ex) {
System.Console.WriteLine("Message data exception:");
System.Console.WriteLine(ex);
}
AsyncRead();
}
public override int EndRead(IAsyncResult asyncResult)
{
resetFileStream();
return(_fileStream.EndRead(asyncResult));
}
public static bool ErrorTest(Stream s)
{
Console.WriteLine(" (09) Error test on stream: "+s.GetType( ).Name);
// Test EndRead & EndWrite's Type safety
byte[] bytes = new byte[0];
IAsyncResult asyncResult;
BogusIAsyncResult bogus = new BogusIAsyncResult( );
if(s.CanRead)
{
asyncResult = s.BeginRead(bytes,0,0,null,null); /* BeginRead */
try
{
s.EndWrite(asyncResult); /* EndWrite */
throw new Exception("EndWrite with an asyncResult from BeginRead should have thrown!");
}
catch(ArgumentException) { }
}
if(s.CanWrite)
{
asyncResult=s.BeginWrite(bytes,0,0,null,null); /* BeginWrite */
try
{
s.EndRead(asyncResult); /* EndRead */
throw new Exception("EndRead with an asyncResult from BeginWrite should have thrown!");
}
catch(ArgumentException) { }
// Verify EndWrite doesn't allow using the same asyncResult twice.
s.EndWrite(asyncResult); /* EndWrite */
try
{
s.EndWrite(asyncResult); /* EndWrite */
throw new Exception("Exception EndWrite was called twice w/ same IAsyncResult from "
+s.GetType( ).Name+", but didn't throw!");
}
catch(InvalidOperationException) { }
}
try
{
s.EndRead(bogus); /* EndRead */
throw new Exception("EndRead with a bogus IAsyncResult object should have thrown!");
}
catch(ArgumentException) { }
try
{
s.EndWrite(bogus); /* EndWrite */
throw new Exception("EndWrite with a bogus IAsyncResult object should have thrown!");
}
catch(ArgumentException) { }
return true;
}
public override int EndRead(IAsyncResult asyncResult) => _stream.EndRead(asyncResult);
public override int EndRead(IAsyncResult asyncResult)
{
return(_requestStream.EndRead(asyncResult));
}
private void receiveData(IAsyncResult ar)
{
withExceptionHandling(() =>
{
var bytesRead = _socketStream.EndRead(ar);
if (bytesRead == 0)
{
_client.OnEndConnection();
return;
}
_currentFrameBufferCount += bytesRead;
if (_currentFrameBufferCount < 6)
{
goto readMore;
}
// Frames coming from a client must be masked.
if ((_currentFrameBuffer[1] & 0x80) == 0)
{
end();
return;
}
var payloadLenRaw = _currentFrameBuffer[1] & 0x7f;
if (payloadLenRaw == 126 && _currentFrameBufferCount < 8)
{
goto readMore;
}
if (payloadLenRaw == 127 && _currentFrameBufferCount < 14)
{
goto readMore;
}
var payloadLen =
payloadLenRaw == 126 ? (int)Ut.BytesToUShort(_currentFrameBuffer, 2, true) :
payloadLenRaw == 127 ? (int)Ut.BytesToULong(_currentFrameBuffer, 2, true) :
payloadLenRaw;
var i =
payloadLenRaw == 126 ? 4 :
payloadLenRaw == 127 ? 10 : 2;
var maskingKeyIndex = i;
i += 4;
if (_currentFrameBufferCount < i + payloadLen)
{
goto readMore;
}
var payloadIndex = i;
// The frame is complete. Unmask the payload data...
for (var j = 0; i < _currentFrameBufferCount; i++, j++)
{
_currentFrameBuffer[i] ^= _currentFrameBuffer[maskingKeyIndex + (j % 4)];
}
// ... and then append the payload data to the current message.
int dest;
if (_currentMessage == null)
{
_currentMessage = new byte[payloadLen];
_currentMessageOpcode = (byte)(_currentFrameBuffer[0] & 0xf);
dest = 0;
}
else
{
dest = _currentMessage.Length;
Array.Resize(ref _currentMessage, _currentMessage.Length + payloadLen);
}
Buffer.BlockCopy(_currentFrameBuffer, payloadIndex, _currentMessage, dest, payloadLen);
// Check if the message is complete
if ((_currentFrameBuffer[0] & 0x80) == 0x80)
{
if (processMessage())
{
return;
}
_currentMessage = null;
}
// We’ve used the frame buffer, reinitialize it
_currentFrameBufferCount = 0;
if (_currentFrameBuffer.Length > 256)
{
_currentFrameBuffer = new byte[256];
}
readMore:
beginRead();
});
}
private void EndReadHeader(IAsyncResult r)
{
var bytesRead = m_stream.EndRead(r);
if (bytesRead <= 0)
{
return;
}
m_streamBytesRead += bytesRead;
if (OnReadHeader != null)
{
OnReadHeader(m_streamBytesRead, m_streamReadBuffer);
}
if (m_streamBytesRead < m_streamBytesNeeded)
{
BeginReadHeader();
return;
}
switch (m_streamReadState)
{
case StreamReadState.Response:
if (Convert.ToChar(m_streamReadBuffer[0]) == '+')
{
m_streamReadState = StreamReadState.Size;
m_streamBytesNeeded = SizeLen;
}
else
{
m_nextFileCompleteEventArgs.Result = DownloadResult.FileNotFound;
m_streamReadState = StreamReadState.Id;
m_streamBytesNeeded = IdLen;
}
break;
case StreamReadState.Size:
m_nextFileCompleteEventArgs.Size = Util.ReadUInt64(m_streamReadBuffer, 0);
m_streamReadState = StreamReadState.Id;
m_streamBytesNeeded = IdLen;
break;
case StreamReadState.Id:
m_mutex.WaitOne();
var next = m_downloadQueue.Peek();
m_mutex.ReleaseMutex();
m_nextFileCompleteEventArgs.DownloadItem = next;
var match =
Util.ByteArraysAreEqual(next.Id.guid, 0, m_streamReadBuffer, 0, GuidLen) &&
Util.ByteArraysAreEqual(next.Id.hash, 0, m_streamReadBuffer, GuidLen, HashLen);
if (!match)
{
Close();
throw new InvalidDataException();
}
if (m_nextFileCompleteEventArgs.Result == DownloadResult.FileNotFound)
{
OnDownloadFinished(m_nextFileCompleteEventArgs);
}
else
{
var size = m_nextFileCompleteEventArgs.Size;
m_nextWriteStream = next.GetWriteStream(size);
m_streamBytesNeeded = (int)size;
m_streamBytesRead = 0;
BeginReadData();
}
return;
default:
throw new ArgumentOutOfRangeException();
}
m_streamBytesRead = 0;
BeginReadHeader();
}
internal static void WriteToSync <T>(this Stream stream, Stream toStream, long?copyLength, long?maxLength, ChecksumRequested calculateChecksum, bool syncRead, ExecutionState <T> executionState, StreamDescriptor streamCopyState)
{
if (copyLength.HasValue && maxLength.HasValue)
{
throw new ArgumentException(SR.StreamLengthMismatch);
}
if (stream.CanSeek && maxLength.HasValue && stream.Length - stream.Position > maxLength)
{
throw new InvalidOperationException(SR.StreamLengthError);
}
if (stream.CanSeek && copyLength.HasValue && stream.Length - stream.Position < copyLength)
{
throw new ArgumentOutOfRangeException("copyLength", SR.StreamLengthShortError);
}
byte[] buffer = new byte[GetBufferSize(stream)];
if (streamCopyState != null && calculateChecksum.HasAny && streamCopyState.ChecksumWrapper == null)
{
streamCopyState.ChecksumWrapper = new ChecksumWrapper(calculateChecksum.MD5, calculateChecksum.CRC64);
}
RegisteredWaitHandle waitHandle = null;
ManualResetEvent completedEvent = null;
if (!syncRead && executionState.OperationExpiryTime.HasValue)
{
completedEvent = new ManualResetEvent(false);
waitHandle = ThreadPool.RegisterWaitForSingleObject(
completedEvent,
StreamExtensions.MaximumCopyTimeCallback <T>,
executionState,
executionState.RemainingTimeout,
true);
}
try
{
long?bytesRemaining = copyLength;
int readCount;
do
{
if (executionState.OperationExpiryTime.HasValue && DateTime.Now.CompareTo(executionState.OperationExpiryTime.Value) > 0)
{
throw Exceptions.GenerateTimeoutException(executionState.Cmd != null ? executionState.Cmd.CurrentResult : null, null);
}
// Determine how many bytes to read this time so that no more than copyLength bytes are read
int bytesToRead = MinBytesToRead(bytesRemaining, buffer.Length);
if (bytesToRead == 0)
{
break;
}
// Read synchronously or asynchronously
readCount = syncRead
? stream.Read(buffer, 0, bytesToRead)
: stream.EndRead(stream.BeginRead(buffer, 0, bytesToRead, null /* Callback */, null /* State */));
// Decrement bytes to write from bytes read
if (bytesRemaining.HasValue)
{
bytesRemaining -= readCount;
}
// Write
if (readCount > 0)
{
toStream.Write(buffer, 0, readCount);
// Update the StreamDescriptor after the bytes are successfully committed to the output stream
if (streamCopyState != null)
{
streamCopyState.Length += readCount;
if (maxLength.HasValue && streamCopyState.Length > maxLength.Value)
{
throw new InvalidOperationException(SR.StreamLengthError);
}
if (streamCopyState.ChecksumWrapper != null)
{
streamCopyState.ChecksumWrapper.UpdateHash(buffer, 0, readCount);
}
}
}
}while (readCount != 0);
if (bytesRemaining.HasValue && bytesRemaining != 0)
{
throw new ArgumentOutOfRangeException("copyLength", SR.StreamLengthShortError);
}
}
catch (Exception)
{
if (executionState.OperationExpiryTime.HasValue && DateTime.Now.CompareTo(executionState.OperationExpiryTime.Value) > 0)
{
throw Exceptions.GenerateTimeoutException(executionState.Cmd != null ? executionState.Cmd.CurrentResult : null, null);
}
else
{
throw;
}
}
finally
{
if (waitHandle != null)
{
waitHandle.Unregister(null);
}
if (completedEvent != null)
{
completedEvent.Close();
}
}
if (streamCopyState != null && streamCopyState.ChecksumWrapper != null)
{
if (streamCopyState.ChecksumWrapper.CRC64 != null)
{
streamCopyState.Crc64 = streamCopyState.ChecksumWrapper.CRC64.ComputeHash();
}
if (streamCopyState.ChecksumWrapper.MD5 != null)
{
streamCopyState.Md5 = streamCopyState.ChecksumWrapper.MD5.ComputeHash();
}
streamCopyState.ChecksumWrapper = null;
}
}
private Boolean StreamTest(Stream stream, Boolean fSuppress)
{
if (!fSuppress)
{
Console.WriteLine("Testing " + stream.GetType() + " for read/write tests");
}
String strValue;
Int32 iValue;
Int32 iLength = 1 << 10;
stream.Seek(0, SeekOrigin.Begin);
for (int i = 0; i < iLength; i++)
{
stream.WriteByte((Byte)i);
}
Byte[] btArr = new Byte[iLength];
for (int i = 0; i < iLength; i++)
{
btArr[i] = (Byte)i;
}
stream.Write(btArr, 0, iLength);
BinaryWriter bw1 = new BinaryWriter(stream);
bw1.Write(false);
bw1.Write(true);
for (int i = 0; i < 10; i++)
{
bw1.Write((Byte)i);
bw1.Write((SByte)i);
bw1.Write((Int16)i);
bw1.Write((Char)i);
bw1.Write((UInt16)i);
bw1.Write(i);
bw1.Write((UInt32)i);
bw1.Write((Int64)i);
bw1.Write((UInt64)i);
bw1.Write((Single)i);
bw1.Write((Double)i);
}
Char[] chArr = new Char[iLength];
for (int i = 0; i < iLength; i++)
{
chArr[i] = (Char)i;
}
bw1.Write(chArr);
bw1.Write(chArr, 512, 512);
bw1.Write(new String(chArr));
bw1.Write(new String(chArr));
stream.Seek(0, SeekOrigin.Begin);
for (int i = 0; i < iLength; i++)
{
if (stream.ReadByte() != i % 256)
{
return(false);
}
}
btArr = new Byte[iLength];
stream.Read(btArr, 0, iLength);
for (int i = 0; i < iLength; i++)
{
if (btArr[i] != (Byte)i)
{
Console.WriteLine(i + " " + btArr[i] + " " + (Byte)i);
return(false);
}
}
BinaryReader br1 = new BinaryReader(stream);
if (br1.ReadBoolean())
{
return(false);
}
if (!br1.ReadBoolean())
{
return(false);
}
for (int i = 0; i < 10; i++)
{
if (br1.ReadByte() != (Byte)i)
{
return(false);
}
if (br1.ReadSByte() != (SByte)i)
{
return(false);
}
if (br1.ReadInt16() != (Int16)i)
{
return(false);
}
if (br1.ReadChar() != (Char)i)
{
return(false);
}
if (br1.ReadUInt16() != (UInt16)i)
{
return(false);
}
if (br1.ReadInt32() != i)
{
return(false);
}
if (br1.ReadUInt32() != (UInt32)i)
{
return(false);
}
if (br1.ReadInt64() != (Int64)i)
{
return(false);
}
if (br1.ReadUInt64() != (UInt64)i)
{
return(false);
}
if (br1.ReadSingle() != (Single)i)
{
return(false);
}
if (br1.ReadDouble() != (Double)i)
{
return(false);
}
}
chArr = br1.ReadChars(iLength);
for (int i = 0; i < iLength; i++)
{
if (chArr[i] != (Char)i)
{
return(false);
}
}
chArr = new Char[512];
chArr = br1.ReadChars(iLength / 2);
for (int i = 0; i < iLength / 2; i++)
{
if (chArr[i] != (Char)(iLength / 2 + i))
{
return(false);
}
}
chArr = new Char[iLength];
for (int i = 0; i < iLength; i++)
{
chArr[i] = (Char)i;
}
strValue = br1.ReadString();
if (!strValue.Equals(new String(chArr)))
{
return(false);
}
strValue = br1.ReadString();
if (!strValue.Equals(new String(chArr)))
{
return(false);
}
try{
stream.Seek(1, SeekOrigin.Current);
return(true);
}catch (Exception) {
}
stream.Position = 0;
btArr = new Byte[iLength];
for (int i = 0; i < iLength; i++)
{
btArr[i] = (Byte)(i + 5);
}
AsyncCallback acb1 = new AsyncCallback(new Co3965StreamMethods().AsyncTestCB);
IAsyncResult isync1 = stream.BeginWrite(btArr, 0, btArr.Length, acb1, stream.GetType().ToString());
stream.EndWrite(isync1);
stream.Position = 0;
for (int i = 0; i < iLength; i++)
{
if (stream.ReadByte() != (Byte)(i + 5))
{
return(false);
}
}
stream.Position = 0;
AsyncCallback acb2 = new AsyncCallback(new Co3965StreamMethods().AsyncTestCB);
Byte[] btArr1 = new Byte[iLength];
IAsyncResult isync2 = stream.BeginRead(btArr1, 0, btArr1.Length, acb2, stream.GetType().ToString());
iValue = stream.EndRead(isync2);
if (iValue != btArr.Length)
{
return(false);
}
for (int i = 0; i < iLength; i++)
{
if (btArr[i] != btArr1[i])
{
return(false);
}
}
return(true);
}
public static int ReadEx(this Stream stream, byte[] buffer, int offset, int count, CancellationToken cancellation = default(CancellationToken))
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (offset < 0 || offset > buffer.Length)
{
throw new ArgumentOutOfRangeException("offset");
}
if (count <= 0 || count > buffer.Length)
{
throw new ArgumentOutOfRangeException("count"); //Disallow 0 as a debugging aid.
}
if (offset > buffer.Length - count)
{
throw new ArgumentOutOfRangeException("count");
}
int totalReadCount = 0;
while (totalReadCount < count)
{
cancellation.ThrowIfCancellationRequested();
int currentReadCount;
//Big performance problem with BeginRead for other stream types than NetworkStream.
//Only take the slow path if cancellation is possible.
if (stream is NetworkStream && cancellation.CanBeCanceled)
{
var ar = stream.BeginRead(buffer, offset + totalReadCount, count - totalReadCount, null, null);
if (!ar.CompletedSynchronously)
{
WaitHandle.WaitAny(new WaitHandle[] { ar.AsyncWaitHandle, cancellation.WaitHandle }, -1);
}
//EndRead might block, so we need to test cancellation before calling it.
//This also is a bug because calling EndRead after BeginRead is contractually required.
//A potential fix is to use the ReadAsync API. Another fix is to register a callback with BeginRead that calls EndRead in all cases.
cancellation.ThrowIfCancellationRequested();
currentReadCount = stream.EndRead(ar);
}
else
{
//IO interruption not supported in this path.
currentReadCount = stream.Read(buffer, offset + totalReadCount, count - totalReadCount);
}
if (currentReadCount == 0)
{
return(0);
}
totalReadCount += currentReadCount;
}
return(totalReadCount);
}
void OnReadInternal(IAsyncResult ares)
{
int nread = -1;
try
{
nread = stream.EndRead(ares);
ms.Write(buffer, 0, nread);
if (ms.Length > 32768)
{
SendError("Bad request", 400);
Close(true);
return;
}
}
catch
{
if (ms != null && ms.Length > 0)
{
SendError();
}
if (sock != null)
{
CloseSocket();
Unbind();
}
return;
}
if (nread == 0)
{
//if (ms.Length > 0)
// SendError (); // Why bother?
CloseSocket();
Unbind();
return;
}
if (ProcessInput(ms))
{
if (!context.HaveError)
{
context.Request.FinishInitialization();
}
if (context.HaveError)
{
SendError();
Close(true);
return;
}
if (!epl.BindContext(context))
{
SendError("Invalid host", 400);
Close(true);
return;
}
HttpListener listener = context.Listener;
if (last_listener != listener)
{
RemoveConnection();
listener.AddConnection(this);
last_listener = listener;
}
context_bound = true;
listener.RegisterContext(context);
return;
}
#if !ASYNCREAD
stream.BeginRead(buffer, 0, BufferSize, onread_cb, this);
#else
ReadLibuv();
//BeginReadRequest();
#endif
}
private void InternalReadCallback(IAsyncResult asyncResult)
{
if (disposed)
{
return;
}
InternalAsyncResult internalAsyncResult = (InternalAsyncResult)asyncResult.AsyncState;
bool haveDataToReturn = false;
try
{
int bytesRead = 0;
try
{
bytesRead = innerStream.EndRead(asyncResult);
}
catch (Exception ex)
{
// Set the exception into the internal async result
internalAsyncResult.SetComplete(ex);
}
if (bytesRead <= 0)
{
// Zero byte read most likely indicates connection closed (if it's a network stream)
internalAsyncResult.SetComplete(0);
throw new IOException("Connection was closed by the remote endpoint");
}
else
{
// Copy encrypted data into the SSL read_bio
read_bio.Write(read_buffer, bytesRead);
if (handShakeState == HandshakeState.InProcess ||
handShakeState == HandshakeState.RenegotiateInProcess)
{
// We are in the handshake, complete the async operation to fire the async
// handshake callback for processing
internalAsyncResult.SetComplete(bytesRead);
return;
}
uint nBytesPending = read_bio.BytesPending;
byte[] decrypted_buf = new byte[SSL3_RT_MAX_PACKET_SIZE];
while (nBytesPending > 0)
{
int decryptedBytesRead = ssl.Read(decrypted_buf, decrypted_buf.Length);
if (decryptedBytesRead <= 0)
{
SslError lastError = ssl.GetError(decryptedBytesRead);
if (lastError == SslError.SSL_ERROR_WANT_READ)
{
// if we have bytes pending in the write bio.
// the client has requested a renegotiation
if (write_bio.BytesPending > 0)
{
// Start the renegotiation by writing the write_bio data, and use the RenegotiationWriteCallback
// to handle the rest of the renegotiation
ArraySegment <byte> buf = write_bio.ReadBytes((int)write_bio.BytesPending);
innerStream.BeginWrite(buf.Array, 0, buf.Count,
new AsyncCallback(RenegotiationWriteCallback),
internalAsyncResult);
return;
}
// no data in the out bio, we just need more data to complete the record
//break;
}
else if (lastError == SslError.SSL_ERROR_WANT_WRITE)
{
// unexpected error!
//!!TODO debug log
}
else if (lastError == SslError.SSL_ERROR_ZERO_RETURN)
{
// Shutdown alert
SendShutdownAlert();
break;
}
else
{
//throw new OpenSslException();
}
}
if (decryptedBytesRead > 0)
{
// Write decrypted data to memory stream
long pos = decrypted_data_stream.Position;
decrypted_data_stream.Seek(0, SeekOrigin.End);
decrypted_data_stream.Write(decrypted_buf, 0, decryptedBytesRead);
decrypted_data_stream.Seek(pos, SeekOrigin.Begin);
haveDataToReturn = true;
}
// See if we have more data to process
nBytesPending = read_bio.BytesPending;
}
// Check to see if we have data to return, if not, fire the async read again
if (!haveDataToReturn)
{
innerStream.BeginRead(read_buffer, 0, read_buffer.Length, new AsyncCallback(InternalReadCallback),
internalAsyncResult);
}
else
{
int bytesReadIntoUserBuffer = 0;
// Read the data into the buffer provided by the user (now hosted in the InternalAsyncResult)
bytesReadIntoUserBuffer = decrypted_data_stream.Read(internalAsyncResult.Buffer,
internalAsyncResult.Offset,
internalAsyncResult.Count);
internalAsyncResult.SetComplete(bytesReadIntoUserBuffer);
}
}
}
//catch (IOException)
//{
//Connection lost
// Close();
//}
catch (Exception ex)
{
internalAsyncResult.SetComplete(ex);
}
}
public static Task <int> ReadAsync(this Stream stream, byte[] buffer)
{
#if NET_4_6 || UNITY_WSA
return(stream.ReadAsync(buffer, 0, buffer.Length));
#else
return(FromAsync(cb => stream.BeginRead(buffer, 0, buffer.Length, cb, null), ar => stream.EndRead(ar)));
#endif
}
// 读取http返回数据流（回调）
private void OnReadCallback(IAsyncResult asyncResult)
{
Stream responseStream = (Stream)asyncResult.AsyncState;
try
{
int readCount = responseStream.EndRead(asyncResult);
if (readCount > 0)
{
mCurrentDownloadByte += readCount;
// write to file
if (mFileStream == null)
{
mFileStream = new FileStream(mTmpFile, FileMode.Create);
}
mFileStream.Write(m_Buffer, 0, readCount);
UpdateTimeOut();
// 进度回调
lock (mEvent)
{
for (int i = mEvent.Count - 1; i >= 0; i--)
{
if (mEvent[i] == DownloadEvent.Progress)
{
mEvent.RemoveAt(i);
}
}
mEvent.Add(DownloadEvent.Progress);
}
// 继续读取
responseStream.BeginRead(m_Buffer, 0, BUFFER_SIZE, new AsyncCallback(OnReadCallback), responseStream);
}
else // 已经读完
{
responseStream.Close();
mFileStream.Close();
if (File.Exists(m_SaveFile))
{
File.Delete(m_SaveFile);
}
File.Move(mTmpFile, m_SaveFile);
Log.I("Finished!! fileLength:" + mFileLength + ",Download byte:" + mCurrentDownloadByte);
// 进度回调
lock (mEvent)
{
mEvent.Clear();
mEvent.Add(DownloadEvent.Finish);
}
}
}
catch (Exception exception)
{
HandleError(exception.Message);
}
}
void Read(IAsyncResult ar)
{
Stream stm = (Stream)ar.AsyncState;
bytesRead = stm.EndRead(ar);
}
public override int EndRead(IAsyncResult async_result)
{
return(base_stream.EndRead(async_result));
}
private Boolean StreamTest(Stream stream, Boolean fSuppress){
if(!fSuppress)
Console.WriteLine("Testing " + stream.GetType() + " for read/write tests");
String strValue;
Int32 iValue;
Int32 iLength = 1 << 10;
stream.Seek(0, SeekOrigin.Begin);
for(int i=0; i<iLength; i++)
stream.WriteByte((Byte)i);
Byte[] btArr = new Byte[iLength];
for(int i=0; i<iLength; i++)
btArr[i] = (Byte)i;
stream.Write(btArr, 0, iLength);
BinaryWriter bw1 = new BinaryWriter(stream);
bw1.Write(false);
bw1.Write(true);
for(int i=0; i<10; i++){
bw1.Write((Byte)i);
bw1.Write((SByte)i);
bw1.Write((Int16)i);
bw1.Write((Char)i);
bw1.Write((UInt16)i);
bw1.Write(i);
bw1.Write((UInt32)i);
bw1.Write((Int64)i);
bw1.Write((UInt64)i);
bw1.Write((Single)i);
bw1.Write((Double)i);
}
Char[] chArr = new Char[iLength];
for(int i=0; i<iLength;i++)
chArr[i] = (Char)i;
bw1.Write(chArr);
bw1.Write(chArr, 512, 512);
bw1.Write(new String(chArr));
bw1.Write(new String(chArr));
stream.Seek(0, SeekOrigin.Begin);
for(int i=0; i<iLength; i++){
if(stream.ReadByte() != i%256){
return false;
}
}
btArr = new Byte[iLength];
stream.Read(btArr, 0, iLength);
for(int i=0; i<iLength; i++){
if(btArr[i] != (Byte)i){
Console.WriteLine(i + " " + btArr[i] + " " + (Byte)i);
return false;
}
}
BinaryReader br1 = new BinaryReader(stream);
if(br1.ReadBoolean())
return false;
if(!br1.ReadBoolean())
return false;
for(int i=0; i<10; i++){
if(br1.ReadByte() != (Byte)i)
return false;
if(br1.ReadSByte() != (SByte)i)
return false;
if(br1.ReadInt16() != (Int16)i)
return false;
if(br1.ReadChar() != (Char)i)
return false;
if(br1.ReadUInt16() != (UInt16)i)
return false;
if(br1.ReadInt32() != i)
return false;
if(br1.ReadUInt32() != (UInt32)i)
return false;
if(br1.ReadInt64() != (Int64)i)
return false;
if(br1.ReadUInt64() != (UInt64)i)
return false;
if(br1.ReadSingle() != (Single)i)
return false;
if(br1.ReadDouble() != (Double)i)
return false;
}
chArr = br1.ReadChars(iLength);
for(int i=0; i<iLength;i++){
if(chArr[i] != (Char)i)
return false;
}
chArr = new Char[512];
chArr = br1.ReadChars(iLength/2);
for(int i=0; i<iLength/2;i++){
if(chArr[i] != (Char)(iLength/2+i))
return false;
}
chArr = new Char[iLength];
for(int i=0; i<iLength;i++)
chArr[i] = (Char)i;
strValue = br1.ReadString();
if(!strValue.Equals(new String(chArr)))
return false;
strValue = br1.ReadString();
if(!strValue.Equals(new String(chArr))){
return false;
}
try{
stream.Seek(1, SeekOrigin.Current);
return true;
}catch(Exception){
}
stream.Position = 0;
btArr = new Byte[iLength];
for(int i=0; i<iLength; i++)
btArr[i] = (Byte)(i + 5);
AsyncCallback acb1 = new AsyncCallback(new Co3965StreamMethods().AsyncTestCB);
IAsyncResult isync1 = stream.BeginWrite(btArr, 0, btArr.Length, acb1, stream.GetType().ToString());
stream.EndWrite(isync1);
stream.Position = 0;
for(int i=0; i<iLength; i++){
if(stream.ReadByte() != (Byte)(i+5))
return false;
}
stream.Position = 0;
AsyncCallback acb2 = new AsyncCallback(new Co3965StreamMethods().AsyncTestCB);
Byte[] btArr1 = new Byte[iLength];
IAsyncResult isync2 = stream.BeginRead(btArr1, 0, btArr1.Length, acb2, stream.GetType().ToString());
iValue = stream.EndRead(isync2);
if(iValue!=btArr.Length)
return false;
for(int i=0; i<iLength; i++){
if(btArr[i] != btArr1[i])
return false;
}
return true;
}
public int EndReceive(IAsyncResult asyncResult)
{
return(stream.EndRead(asyncResult, Error.Raise));
}
public override int EndRead(IAsyncResult result)
{
return(m_stream.EndRead(result));
}
internal int EndRead(HttpWebRequest request, IAsyncResult result)
{
Stream s = null;
lock (this) {
if (Data.request != request)
{
throw new ObjectDisposedException(typeof(NetworkStream).FullName);
}
if (nstream == null)
{
throw new ObjectDisposedException(typeof(NetworkStream).FullName);
}
s = nstream;
}
int nbytes = 0;
bool done = false;
WebAsyncResult wr = null;
IAsyncResult nsAsync = ((WebAsyncResult)result).InnerAsyncResult;
if (chunkedRead && (nsAsync is WebAsyncResult))
{
wr = (WebAsyncResult)nsAsync;
IAsyncResult inner = wr.InnerAsyncResult;
if (inner != null && !(inner is WebAsyncResult))
{
nbytes = s.EndRead(inner);
done = nbytes == 0;
}
}
else if (!(nsAsync is WebAsyncResult))
{
nbytes = s.EndRead(nsAsync);
wr = (WebAsyncResult)result;
done = nbytes == 0;
}
if (chunkedRead)
{
try {
chunkStream.WriteAndReadBack(wr.Buffer, wr.Offset, wr.Size, ref nbytes);
if (!done && nbytes == 0 && chunkStream.WantMore)
{
nbytes = EnsureRead(wr.Buffer, wr.Offset, wr.Size);
}
} catch (Exception e) {
if (e is WebException)
{
throw e;
}
throw new WebException("Invalid chunked data.", e,
WebExceptionStatus.ServerProtocolViolation, null);
}
if ((done || nbytes == 0) && chunkStream.ChunkLeft != 0)
{
HandleError(WebExceptionStatus.ReceiveFailure, null, "chunked EndRead");
throw new WebException("Read error", null, WebExceptionStatus.ReceiveFailure, null);
}
}
return((nbytes != 0) ? nbytes : -1);
}
public static bool AsyncTest(Stream s)
{
byte[] bigArr = new byte[80000];
byte[] smArr = new byte[128];
int numBytes;
AsyncCallback cb;
IAsyncResult asyncResult;
DateTime startWait;
TimeSpan thirtySecs = new TimeSpan(0,0,30);
bool firstTime;
TimeSpan diff;
if(s.GetType( )==typeof(IsolatedStorageFileStream))
{
Console.WriteLine("AsyncTest won't run on an IsolatedStorageFileStream "
+"since it doesn't support async operations.");
return true;
}
Console.WriteLine(" (08) Async test on "+s.GetType( ).Name);
if(s.Position!=0)
throw new Exception("AsyncTest assumes stream's position will be 0 when starting.");
for(int i=0;i<smArr.Length;i++) smArr[i] = (byte)i;
// Try writing something more than 64KB so we have a chance of doing an async write.
for(int i=0;i<bigArr.Length;i++) bigArr[i] = (byte)((i%26)+(byte)'A');
// Ensure that we do run our async callback at some point.
didAsyncCallbackRun=false;
cb = new AsyncCallback(AsyncTestCallback);
asyncResult=s.BeginWrite(smArr,0,smArr.Length,cb,String.Empty); /* BeginWrite */
s.EndWrite(asyncResult); /* EndWrite */
if(s.Position!=smArr.Length)
throw new Exception("After first BeginWrite call, (s.Position!=smArr.Length) got: "
+s.Position);
asyncResult=s.BeginWrite(bigArr,0,bigArr.Length,null,String.Empty);
s.EndWrite(asyncResult);
if(s.Position!=bigArr.Length+smArr.Length)
throw new Exception("After second BeginWrite call, s.Position wasn't right! expected: "
+(bigArr.Length+smArr.Length)+" got: "+s.Position);
// And to be sure things work, test write with an offset.
asyncResult=s.BeginWrite(smArr,smArr.Length/2,smArr.Length/2,null,null); /* BeginWrite */
s.EndWrite(asyncResult); /* EndWrite */
if(s.Position!=(smArr.Length/2+bigArr.Length+smArr.Length))
throw new Exception("After third BeginWrite call, s.Position wasn't correct! expected: "
+(smArr.Length/2+bigArr.Length+smArr.Length)
+" got: "+s.Position);
startWait=DateTime.Now;
firstTime=true;
while(!didAsyncCallbackRun)
{
if(firstTime)
{
Console.WriteLine("Waiting for async callback to be run from first BeginWrite call.");
firstTime=false;
}
else
Console.Write(".");
Thread.Sleep(20);
diff=DateTime.Now-startWait;
if(diff>thirtySecs)
throw new Exception("Async callback didn't run yet after 2 BeginWRITE calls and "
+"30 seconds of blocking! "
+"This could be a bug in a particular stream class, "
+"or an extremely pathetic race condition in this test.");
}
didAsyncCallbackRun=false;
s.Position=0;
byte[] input = new byte[(int)s.Length];
// Retest running the async callback here.
asyncResult=s.BeginRead(input,0,smArr.Length,cb,String.Empty); /* BeginRead */
numBytes=s.EndRead(asyncResult); /* BeginRead */
if(numBytes!=smArr.Length)
throw new Exception("After first BeginRead call, (numBytes!=smArr.Length) got: "
+numBytes);
if(s.Position!=smArr.Length)
throw new Exception("After first BeginRead call, (s.Position!=smArr.Length) got: "
+s.Position);
asyncResult=s.BeginRead(input,smArr.Length,bigArr.Length,null,String.Empty); /* BeginRead */
numBytes=s.EndRead(asyncResult); /* EndRead */
if(numBytes!=bigArr.Length)
throw new Exception("After second BeginRead call, (numBytes!=bigArr.Length) got: "
+numBytes);
if(s.Position!=bigArr.Length+smArr.Length)
throw new Exception("After second BeginRead call, s.Position wasn't right! expected: "
+(bigArr.Length+smArr.Length)+" got: "+s.Position);
asyncResult=s.BeginRead(input,smArr.Length+bigArr.Length,smArr.Length/2,null,null); /* BeginRead */
numBytes=s.EndRead(asyncResult); /* EndRead */
if(numBytes!=smArr.Length/2)
throw new Exception("After third BeginRead call, (numBytes!=smArr.Length/2) got: "
+numBytes);
if(s.Position!=(smArr.Length/2+bigArr.Length+smArr.Length))
throw new Exception("After third BeginRead call, s.Position wasn't correct! expected: "
+(smArr.Length/2+bigArr.Length+smArr.Length)
+" got: "+s.Position);
for(int i=0;i<smArr.Length;i++)
if (smArr[i]!=input[i])
throw new Exception("When reading first smArr copy, position "
+i+" was wrong! got: "
+input[i]+" expected: "+smArr[i]);
int offset = smArr.Length;
for(int i=0;i<bigArr.Length;i++)
if (bigArr[i]!=input[i+offset])
throw new Exception("When reading bigArr copy, position "
+(i+offset)+" was wrong! i: "+i+" got: "
+input[i+offset]+" expected: "+bigArr[i]);
offset=smArr.Length+bigArr.Length;
for(int i=0;i<smArr.Length/2;i++)
if (smArr[i+smArr.Length/2]!=input[i+offset])
throw new Exception("When reading second smArr copy, position "
+(i+offset)+" was wrong! i: "+i+" got: "
+input[i+offset]+" expected: "
+smArr[i+smArr.Length/2]);
startWait=DateTime.Now;
firstTime=true;
while(!didAsyncCallbackRun)
{
if (firstTime)
{
Console.WriteLine("Waiting for async callback to be run from "
+"first BeginRead call.");
firstTime=false;
}
else
Console.Write(".");
Thread.Sleep(20);
diff=DateTime.Now-startWait;
if(diff>thirtySecs)
throw new Exception("Async callback didn't run yet after 2 BeginREAD "
+"calls and 30 seconds of blocking! "
+"This could be a bug in a particular stream "
+"class, or an extremely pathetic race "
+"condition in this test.");
}
didAsyncCallbackRun=false;
return true;
}
static void ReadDone(IAsyncResult result)
{
WebConnection cnc = (WebConnection)result.AsyncState;
WebConnectionData data = cnc.Data;
Stream ns = cnc.nstream;
if (ns == null)
{
cnc.Close(true);
return;
}
int nread = -1;
try {
nread = ns.EndRead(result);
} catch (ObjectDisposedException) {
return;
} catch (Exception e) {
if (e.InnerException is ObjectDisposedException)
{
return;
}
cnc.HandleError(WebExceptionStatus.ReceiveFailure, e, "ReadDone1");
return;
}
if (nread == 0)
{
cnc.HandleError(WebExceptionStatus.ReceiveFailure, null, "ReadDone2");
return;
}
if (nread < 0)
{
cnc.HandleError(WebExceptionStatus.ServerProtocolViolation, null, "ReadDone3");
return;
}
int pos = -1;
nread += cnc.position;
if (data.ReadState == ReadState.None)
{
Exception exc = null;
try {
pos = GetResponse(data, cnc.sPoint, cnc.buffer, nread);
} catch (Exception e) {
exc = e;
}
if (exc != null || pos == -1)
{
cnc.HandleError(WebExceptionStatus.ServerProtocolViolation, exc, "ReadDone4");
return;
}
}
if (data.ReadState == ReadState.Aborted)
{
cnc.HandleError(WebExceptionStatus.RequestCanceled, null, "ReadDone");
return;
}
if (data.ReadState != ReadState.Content)
{
int est = nread * 2;
int max = (est < cnc.buffer.Length) ? cnc.buffer.Length : est;
byte [] newBuffer = new byte [max];
Buffer.BlockCopy(cnc.buffer, 0, newBuffer, 0, nread);
cnc.buffer = newBuffer;
cnc.position = nread;
data.ReadState = ReadState.None;
InitRead(cnc);
return;
}
cnc.position = 0;
WebConnectionStream stream = new WebConnectionStream(cnc, data);
bool expect_content = ExpectContent(data.StatusCode, data.request.Method);
string tencoding = null;
if (expect_content)
{
tencoding = data.Headers ["Transfer-Encoding"];
}
cnc.chunkedRead = (tencoding != null && tencoding.IndexOf("chunked", StringComparison.OrdinalIgnoreCase) != -1);
if (!cnc.chunkedRead)
{
stream.ReadBuffer = cnc.buffer;
stream.ReadBufferOffset = pos;
stream.ReadBufferSize = nread;
try {
stream.CheckResponseInBuffer();
} catch (Exception e) {
cnc.HandleError(WebExceptionStatus.ReceiveFailure, e, "ReadDone7");
}
}
else if (cnc.chunkStream == null)
{
try {
cnc.chunkStream = new ChunkStream(cnc.buffer, pos, nread, data.Headers);
} catch (Exception e) {
cnc.HandleError(WebExceptionStatus.ServerProtocolViolation, e, "ReadDone5");
return;
}
}
else
{
cnc.chunkStream.ResetBuffer();
try {
cnc.chunkStream.Write(cnc.buffer, pos, nread);
} catch (Exception e) {
cnc.HandleError(WebExceptionStatus.ServerProtocolViolation, e, "ReadDone6");
return;
}
}
data.stream = stream;
if (!expect_content)
{
stream.ForceCompletion();
}
data.request.SetResponseData(data);
}
public static bool SetLengthTest(Stream s)
{
Console.WriteLine(" (10) SetLengthTest on "+s.GetType( ).Name);
if(!s.CanSeek)
{
Console.WriteLine("SetLengthTest shouldn't run on non-seekable stream "+s.GetType( ).Name);
try
{
s.SetLength(0);
throw new Exception("SetLength to 0 on a non-seekable stream should have failed!");
}
catch(NotSupportedException) { }
return true;
}
if(!s.CanWrite)
{
Console.WriteLine("SetLengthTest shouldn't run on non-writable stream "+s.GetType( ).Name);
try
{
s.SetLength(0);
throw new Exception("SetLength to 0 on a non-writable stream should have failed! "
+"s.Length: "+s.Length);
}
catch(NotSupportedException) { }
return true;
}
s.SetLength(0);
if(s.Length!=0)
throw new Exception("SetLength to 0, but Length is: "+s.Length);
if(s.Position!=0)
throw new Exception("Set length to 0. Position should be zero too: "+s.Position);
s.SetLength(10);
if(s.Length!=10)
throw new Exception("SetLength to 10, but Length is: "+s.Length);
if(s.Position!=0)
throw new Exception("Set length to 10, yet Position should be zero still: "+s.Position);
if(s.CanRead)
{
byte[] bytes = new byte[500];
IAsyncResult asyncResult = s.BeginRead(bytes,0,500,null,null);
int numBytes = s.EndRead(asyncResult);
if(numBytes!=10)
throw new Exception("Number of bytes got back from EndRead was wrong! "
+"should have been 10, but got: "+numBytes);
if(s.Position!=10)
throw new Exception("After async read, position should be 10, but was: "+s.Position);
}
return true;
}
//
// File copy using APM asynchronous read and synchronous write operations.
//
static long ApmFileCopy(Stream src, Stream dst)
{
var done = new ManualResetEventSlim(false);
long fileSize = 0;
IOException ioex = null;
AsyncCallback onReadCompleted = null;
onReadCompleted = delegate(IAsyncResult iar) {
int bytesRead = 0;
try {
bytesRead = src.EndRead(iar);
} catch (IOException _ioex) {
src.Close();
dst.Close();
ioex = _ioex;
done.Set();
return;
}
if (bytesRead != 0) {
//
// The read buffer is passed through IasyncResult.AsyncState.
// Allocate a new buffer for the next read and issue an synchronous write.
//
// The lock ensures that we can't process the completion of the new read
// completion before terminate the current write.
//
var writeFrom = (byte[])iar.AsyncState;
var readTo = new byte[BUFFER_SIZE];
lock(dst) {
src.BeginRead(readTo, 0, readTo.Length, onReadCompleted, readTo);
dst.Write(writeFrom, 0, bytesRead);
fileSize += bytesRead;
}
} else {
//
// We reach the EOF on the source stream.
// We must ensure that the write of the last block is done,
// before close the destination stream and set the event.
//
src.Close();
lock(dst) {}
dst.Close();
done.Set();
return;
}
};
//
// Start the copy process, issuingthe first asynchronous read.
//
var firstBuf = new byte[BUFFER_SIZE];
src.BeginRead(firstBuf, 0, firstBuf.Length, onReadCompleted, firstBuf);
// Wait until completion.
done.Wait();
if (ioex != null) {
throw ioex;
}
return fileSize;
}
