| static private InitRead ( object state ) : void | ||
| state | object | |
| Résultat | void | |
void WriteAsyncCB(IAsyncResult r)
{
WebAsyncResult result = (WebAsyncResult)r.AsyncState;
result.InnerAsyncResult = null;
try {
cnc.EndWrite(request, true, r);
result.SetCompleted(false, 0);
if (!initRead)
{
initRead = true;
cnc.InitRead();
}
} catch (Exception e) {
KillBuffer();
nextReadCalled = true;
cnc.Close(true);
if (e is System.Net.Sockets.SocketException)
{
e = new IOException("Error writing request", e);
}
result.SetCompleted(false, e);
}
if (allowBuffering && !sendChunked && request.ContentLength > 0 && totalWritten == request.ContentLength)
{
complete_request_written = true;
}
result.DoCallback();
}
public override void Close()
{
if (sendChunked)
{
if (disposed)
{
return;
}
disposed = true;
pending.WaitOne();
byte [] chunk = Encoding.ASCII.GetBytes("0\r\n\r\n");
string err_msg = null;
cnc.Write(request, chunk, 0, chunk.Length, ref err_msg);
return;
}
if (isRead)
{
if (!nextReadCalled)
{
CheckComplete();
// If we have not read all the contents
if (!nextReadCalled)
{
nextReadCalled = true;
cnc.Close(true);
}
}
return;
}
else if (!allowBuffering)
{
complete_request_written = true;
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
return;
}
if (disposed || requestWritten)
{
return;
}
long length = request.ContentLength;
if (!sendChunked && length != -1 && totalWritten != length)
{
IOException io = new IOException("Cannot close the stream until all bytes are written");
nextReadCalled = true;
cnc.Close(true);
throw new WebException("Request was cancelled.", io, WebExceptionStatus.RequestCanceled);
}
// Commented out the next line to fix xamarin bug #1512
//WriteRequest ();
disposed = true;
}
private void WriteRequestAsyncCB(IAsyncResult r)
{
WebAsyncResult webAsyncResult = (WebAsyncResult)r.AsyncState;
try
{
this.cnc.EndWrite2(this.request, r);
webAsyncResult.SetCompleted(false, 0);
if (!this.initRead)
{
this.initRead = true;
WebConnection.InitRead(this.cnc);
}
}
catch (Exception ex)
{
this.KillBuffer();
this.nextReadCalled = true;
this.cnc.Close(true);
if (ex is System.Net.Sockets.SocketException)
{
ex = new IOException("Error writing request", ex);
}
webAsyncResult.SetCompleted(false, ex);
}
this.complete_request_written = true;
webAsyncResult.DoCallback();
}
private void WriteRequestAsyncCB(IAsyncResult r)
{
WebAsyncResult webAsyncResult = (WebAsyncResult)r.AsyncState;
try
{
cnc.EndWrite2(request, r);
webAsyncResult.SetCompleted(synch: false, 0);
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
}
catch (Exception ex)
{
Exception ex2 = ex;
KillBuffer();
nextReadCalled = true;
cnc.Close(sendNext: true);
if (ex2 is SocketException)
{
ex2 = new IOException("Error writing request", ex2);
}
webAsyncResult.SetCompleted(synch: false, ex2);
}
complete_request_written = true;
webAsyncResult.DoCallback();
}
internal void SetHeaders(byte [] buffer, int offset, int size)
{
if (headersSent)
{
return;
}
if (!allowBuffering || sendChunked)
{
headersSent = true;
if (!cnc.Connected)
{
throw new WebException("Not connected", null, WebExceptionStatus.SendFailure, null);
}
if (!cnc.Write(buffer, offset, size))
{
throw new WebException("Error writing request.", null, WebExceptionStatus.SendFailure, null);
}
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
}
else
{
headers = new byte [size];
Buffer.BlockCopy(buffer, offset, headers, 0, size);
}
}
internal void SetHeaders(byte[] buffer)
{
if (this.headersSent)
{
return;
}
this.headers = buffer;
long num = this.request.ContentLength;
string method = this.request.Method;
bool flag = method == "GET" || method == "CONNECT" || method == "HEAD" || method == "TRACE" || method == "DELETE";
if (this.sendChunked || num > -1L || flag)
{
this.WriteHeaders();
if (!this.initRead)
{
this.initRead = true;
WebConnection.InitRead(this.cnc);
}
if (!this.sendChunked && num == 0L)
{
this.requestWritten = true;
}
}
}
internal void SetHeaders(byte [] buffer)
{
if (headersSent)
{
return;
}
headers = buffer;
long cl = request.ContentLength;
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 (sendChunked || cl > -1 || no_writestream || webdav)
{
WriteHeaders();
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
if (!sendChunked && cl == 0)
{
requestWritten = true;
}
}
}
void WriteRequestAsyncCB(IAsyncResult r)
{
WebAsyncResult result = (WebAsyncResult)r.AsyncState;
try {
cnc.EndWrite2(request, r);
result.SetCompleted(false, 0);
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
} catch (Exception e) {
KillBuffer();
nextReadCalled = true;
cnc.Close(true);
if (e is System.Net.Sockets.SocketException)
{
e = new IOException("Error writing request", e);
}
result.SetCompleted(false, e);
}
complete_request_written = true;
result.DoCallback();
}
internal void SetHeaders(byte [] buffer)
{
if (headersSent)
{
return;
}
headers = buffer;
long cl = request.ContentLength;
string method = request.Method;
bool no_writestream = (method == "GET" || method == "CONNECT" || method == "HEAD" ||
method == "TRACE" || method == "DELETE");
if (sendChunked || cl > -1 || no_writestream)
{
WriteHeaders();
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
if (!sendChunked && cl == 0)
{
requestWritten = true;
}
}
}
void SetHeadersCB(IAsyncResult r)
{
WebAsyncResult result = (WebAsyncResult)r.AsyncState;
result.InnerAsyncResult = null;
try {
cnc.EndWrite(request, true, r);
result.SetCompleted(false, 0);
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
long cl = request.ContentLength;
if (!sendChunked && cl == 0)
{
requestWritten = true;
}
} catch (WebException e) {
result.SetCompleted(false, e);
} catch (Exception e) {
result.SetCompleted(false, new WebException("Error writing headers", e, WebExceptionStatus.SendFailure));
}
result.DoCallback();
}
internal void WriteRequest()
{
if (this.requestWritten)
{
return;
}
this.requestWritten = true;
if (this.sendChunked)
{
return;
}
if (!this.allowBuffering || this.writeBuffer == null)
{
return;
}
byte[] buffer = this.writeBuffer.GetBuffer();
int num = (int)this.writeBuffer.Length;
if (this.request.ContentLength != -1L && this.request.ContentLength < (long)num)
{
this.nextReadCalled = true;
this.cnc.Close(true);
throw new WebException("Specified Content-Length is less than the number of bytes to write", null, WebExceptionStatus.ServerProtocolViolation, null);
}
if (!this.headersSent)
{
string method = this.request.Method;
if (!(method == "GET") && !(method == "CONNECT") && !(method == "HEAD") && !(method == "TRACE") && !(method == "DELETE"))
{
this.request.InternalContentLength = (long)num;
}
this.request.SendRequestHeaders(true);
}
this.WriteHeaders();
if (this.cnc.Data.StatusCode != 0 && this.cnc.Data.StatusCode != 100)
{
return;
}
IAsyncResult result = null;
if (num > 0)
{
result = this.cnc.BeginWrite(this.request, buffer, 0, num, null, null);
}
if (!this.initRead)
{
this.initRead = true;
WebConnection.InitRead(this.cnc);
}
if (num > 0)
{
this.complete_request_written = this.cnc.EndWrite(this.request, result);
}
else
{
this.complete_request_written = true;
}
}
public override void Close()
{
if (this.sendChunked)
{
if (this.disposed)
{
return;
}
this.disposed = true;
this.pending.WaitOne();
byte[] bytes = Encoding.ASCII.GetBytes("0\r\n\r\n");
string text = null;
this.cnc.Write(this.request, bytes, 0, bytes.Length, ref text);
return;
}
else
{
if (this.isRead)
{
if (!this.nextReadCalled)
{
this.CheckComplete();
if (!this.nextReadCalled)
{
this.nextReadCalled = true;
this.cnc.Close(true);
}
}
return;
}
if (!this.allowBuffering)
{
this.complete_request_written = true;
if (!this.initRead)
{
this.initRead = true;
WebConnection.InitRead(this.cnc);
}
return;
}
if (this.disposed || this.requestWritten)
{
return;
}
long num = this.request.ContentLength;
if (!this.sendChunked && num != -1L && this.totalWritten != num)
{
IOException innerException = new IOException("Cannot close the stream until all bytes are written");
this.nextReadCalled = true;
this.cnc.Close(true);
throw new WebException("Request was cancelled.", innerException, WebExceptionStatus.RequestCanceled);
}
this.WriteRequest();
this.disposed = true;
return;
}
}
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;
}
bool has_content = !no_writestream && (writeBuffer == null || request.ContentLength > -1);
if (!(sendChunked || has_content || 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);
}
public override void Close()
{
if (sendChunked)
{
pending.WaitOne();
byte [] chunk = Encoding.ASCII.GetBytes("0\r\n\r\n");
cnc.Write(chunk, 0, chunk.Length);
return;
}
if (isRead)
{
if (!nextReadCalled)
{
CheckComplete();
// If we have not read all the contents
if (!nextReadCalled)
{
nextReadCalled = true;
cnc.Close(true);
}
}
return;
}
else if (!allowBuffering)
{
complete_request_written = true;
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
return;
}
if (disposed)
{
return;
}
long length = request.ContentLength;
if (length != -1 && length > writeBuffer.Length)
{
throw new IOException("Cannot close the stream until all bytes are written");
}
WriteRequest();
disposed = true;
}
public override void Close()
{
if (sendChunked)
{
if (!disposed)
{
disposed = true;
pending.WaitOne();
byte[] bytes = Encoding.ASCII.GetBytes("0\r\n\r\n");
string err_msg = null;
cnc.Write(request, bytes, 0, bytes.Length, ref err_msg);
}
}
else if (isRead)
{
if (!nextReadCalled)
{
CheckComplete();
if (!nextReadCalled)
{
nextReadCalled = true;
cnc.Close(sendNext: true);
}
}
}
else if (!allowBuffering)
{
complete_request_written = true;
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
}
else if (!disposed && !requestWritten)
{
long num = request.ContentLength;
if (!sendChunked && num != -1 && totalWritten != num)
{
IOException innerException = new IOException("Cannot close the stream until all bytes are written");
nextReadCalled = true;
cnc.Close(sendNext: true);
throw new WebException("Request was cancelled.", innerException, WebExceptionStatus.RequestCanceled);
}
WriteRequest();
disposed = true;
}
}
void WriteRequestAsyncCB(IAsyncResult ar)
{
var result = (WebAsyncResult)ar;
var innerResult = (WebAsyncResult)result.InnerAsyncResult;
result.InnerAsyncResult = null;
if (innerResult != null && innerResult.GotException)
{
result.SetCompleted(false, innerResult.Exception);
result.DoCallback();
return;
}
if (cnc.Data.StatusCode != 0 && cnc.Data.StatusCode != 100)
{
result.SetCompleted(false, 0);
result.DoCallback();
return;
}
byte[] bytes = writeBuffer.GetBuffer();
int length = (int)writeBuffer.Length;
if (length > 0)
{
result.InnerAsyncResult = cnc.BeginWrite(request, bytes, 0, length, WriteRequestAsyncCB2, result);
}
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
if (length == 0)
{
result.SetCompleted(false, 0);
result.DoCallback();
complete_request_written = true;
}
}
internal void SetHeaders(byte[] buffer)
{
if (headersSent)
{
return;
}
headers = buffer;
long num = request.ContentLength;
string method = request.Method;
int num2;
switch (method)
{
default:
num2 = ((method == "DELETE") ? 1 : 0);
break;
case "GET":
case "CONNECT":
case "HEAD":
case "TRACE":
num2 = 1;
break;
}
bool flag = (byte)num2 != 0;
if (sendChunked || num > -1 || flag)
{
WriteHeaders();
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
if (!sendChunked && num == 0L)
{
requestWritten = true;
}
}
}
internal void WriteRequest()
{
if (requestWritten)
{
return;
}
requestWritten = true;
if (sendChunked)
{
return;
}
if (!allowBuffering || writeBuffer == null)
{
return;
}
byte [] bytes = writeBuffer.GetBuffer();
int 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);
}
if (!headersSent)
{
string method = request.Method;
bool no_writestream = (method == "GET" || method == "CONNECT" || method == "HEAD" ||
method == "TRACE");
if (!no_writestream)
{
request.InternalContentLength = length;
}
byte[] requestHeaders = request.GetRequestHeaders();
WebAsyncResult ar = new WebAsyncResult(null, null);
SetHeadersAsync(requestHeaders, ar);
ar.AsyncWaitHandle.WaitOne();
if (ar.Exception != null)
{
throw ar.Exception;
}
}
if (cnc.Data.StatusCode != 0 && cnc.Data.StatusCode != 100)
{
return;
}
IAsyncResult result = null;
if (length > 0)
{
result = cnc.BeginWrite(request, bytes, 0, length, null, null);
}
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
if (length > 0)
{
complete_request_written = cnc.EndWrite(request, false, result);
}
else
{
complete_request_written = true;
}
}
internal void WriteRequest()
{
if (requestWritten)
{
return;
}
if (sendChunked)
{
request.SendRequestHeaders();
requestWritten = true;
return;
}
if (!allowBuffering || writeBuffer == null)
{
return;
}
byte [] bytes = writeBuffer.GetBuffer();
int length = (int)writeBuffer.Length;
if (request.ContentLength != -1 && request.ContentLength < length)
{
throw new WebException("Specified Content-Length is less than the number of bytes to write", null,
WebExceptionStatus.ServerProtocolViolation, null);
}
request.InternalContentLength = length;
request.SendRequestHeaders();
requestWritten = true;
if (!cnc.Write(headers, 0, headers.Length))
{
throw new WebException("Error writing request.", null, WebExceptionStatus.SendFailure, null);
}
headersSent = true;
if (cnc.Data.StatusCode != 0 && cnc.Data.StatusCode != 100)
{
return;
}
IAsyncResult result = null;
if (length > 0)
{
result = cnc.BeginWrite(bytes, 0, length, null, null);
}
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
if (length > 0)
{
complete_request_written = cnc.EndWrite(result);
}
else
{
complete_request_written = true;
}
}
private static void ReadDone(IAsyncResult result)
{
WebConnection webConnection = (WebConnection)result.AsyncState;
WebConnectionData data = webConnection.Data;
Stream stream = webConnection.nstream;
if (stream == null)
{
webConnection.Close(true);
return;
}
int num = -1;
try
{
num = stream.EndRead(result);
}
catch (Exception e)
{
webConnection.HandleError(WebExceptionStatus.ReceiveFailure, e, "ReadDone1");
return;
}
if (num == 0)
{
webConnection.HandleError(WebExceptionStatus.ReceiveFailure, null, "ReadDone2");
return;
}
if (num < 0)
{
webConnection.HandleError(WebExceptionStatus.ServerProtocolViolation, null, "ReadDone3");
return;
}
int num2 = -1;
num += webConnection.position;
if (webConnection.readState == ReadState.None)
{
Exception ex = null;
try
{
num2 = webConnection.GetResponse(webConnection.buffer, num);
}
catch (Exception ex2)
{
ex = ex2;
}
if (ex != null)
{
webConnection.HandleError(WebExceptionStatus.ServerProtocolViolation, ex, "ReadDone4");
return;
}
}
if (webConnection.readState != ReadState.Content)
{
int num3 = num * 2;
int num4 = (num3 >= webConnection.buffer.Length) ? num3 : webConnection.buffer.Length;
byte[] dst = new byte[num4];
Buffer.BlockCopy(webConnection.buffer, 0, dst, 0, num);
webConnection.buffer = dst;
webConnection.position = num;
webConnection.readState = ReadState.None;
WebConnection.InitRead(webConnection);
return;
}
webConnection.position = 0;
WebConnectionStream webConnectionStream = new WebConnectionStream(webConnection);
string text = data.Headers["Transfer-Encoding"];
webConnection.chunkedRead = (text != null && text.ToLower().IndexOf("chunked") != -1);
if (!webConnection.chunkedRead)
{
webConnectionStream.ReadBuffer = webConnection.buffer;
webConnectionStream.ReadBufferOffset = num2;
webConnectionStream.ReadBufferSize = num;
webConnectionStream.CheckResponseInBuffer();
}
else if (webConnection.chunkStream == null)
{
try
{
webConnection.chunkStream = new ChunkStream(webConnection.buffer, num2, num, data.Headers);
}
catch (Exception e2)
{
webConnection.HandleError(WebExceptionStatus.ServerProtocolViolation, e2, "ReadDone5");
return;
}
}
else
{
webConnection.chunkStream.ResetBuffer();
try
{
webConnection.chunkStream.Write(webConnection.buffer, num2, num);
}
catch (Exception e3)
{
webConnection.HandleError(WebExceptionStatus.ServerProtocolViolation, e3, "ReadDone6");
return;
}
}
data.stream = webConnectionStream;
if (!WebConnection.ExpectContent(data.StatusCode) || data.request.Method == "HEAD")
{
webConnectionStream.ForceCompletion();
}
data.request.SetResponseData(data);
}
bool SetHeadersAsync(SimpleAsyncResult result, bool setInternalLength)
{
if (headersSent)
{
return(false);
}
bool webdav = false;
bool writestream = false;
switch (request.Method)
{
case "PROPFIND":
case "PROPPATCH":
case "MKCOL":
case "COPY":
case "MOVE":
case "LOCK":
case "UNLOCK":
webdav = true;
break;
case "POST":
case "PUT":
writestream = true;
break;
}
if (setInternalLength && writestream && writeBuffer != null)
{
request.InternalContentLength = writeBuffer.Length;
}
if (!(sendChunked || request.ContentLength > -1 || !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);
}
internal void WriteRequest()
{
if (requestWritten)
{
return;
}
requestWritten = true;
if (sendChunked || !allowBuffering || writeBuffer == null)
{
return;
}
byte[] buffer = writeBuffer.GetBuffer();
int num = (int)writeBuffer.Length;
if (request.ContentLength != -1 && request.ContentLength < num)
{
nextReadCalled = true;
cnc.Close(sendNext: true);
throw new WebException("Specified Content-Length is less than the number of bytes to write", null, WebExceptionStatus.ServerProtocolViolation, null);
}
if (!headersSent)
{
string method = request.Method;
int num2;
switch (method)
{
default:
num2 = ((method == "DELETE") ? 1 : 0);
break;
case "GET":
case "CONNECT":
case "HEAD":
case "TRACE":
num2 = 1;
break;
}
if (num2 == 0)
{
request.InternalContentLength = num;
}
request.SendRequestHeaders(propagate_error: true);
}
WriteHeaders();
if (cnc.Data.StatusCode == 0 || cnc.Data.StatusCode == 100)
{
IAsyncResult result = null;
if (num > 0)
{
result = cnc.BeginWrite(request, buffer, 0, num, null, null);
}
if (!initRead)
{
initRead = true;
WebConnection.InitRead(cnc);
}
if (num > 0)
{
complete_request_written = cnc.EndWrite(request, result);
}
else
{
complete_request_written = true;
}
}
}
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);
}
