| static private ReadLine ( byte buffer, int &start, int max, string &output ) : bool | ||
| buffer | byte | |
| start | int | |
| max | int | |
| output | string | |
| return | bool | |
private WebHeaderCollection ReadHeaders(HttpWebRequest request, Stream stream, out byte[] retBuffer, out int status)
{
retBuffer = null;
status = 200;
byte[] array = new byte[1024];
MemoryStream memoryStream = new MemoryStream();
bool flag = false;
int num2;
WebHeaderCollection webHeaderCollection;
for (;;)
{
int num = stream.Read(array, 0, 1024);
if (num == 0)
{
break;
}
memoryStream.Write(array, 0, num);
num2 = 0;
string text = null;
webHeaderCollection = new WebHeaderCollection();
while (WebConnection.ReadLine(memoryStream.GetBuffer(), ref num2, (int)memoryStream.Length, ref text))
{
if (text == null)
{
goto Block_2;
}
if (flag)
{
webHeaderCollection.Add(text);
}
else
{
int num3 = text.IndexOf(' ');
if (num3 == -1)
{
goto Block_5;
}
status = (int)uint.Parse(text.Substring(num3 + 1, 3));
flag = true;
}
}
}
this.HandleError(WebExceptionStatus.ServerProtocolViolation, null, "ReadHeaders");
return(null);
Block_2:
if (memoryStream.Length - (long)num2 > 0L)
{
retBuffer = new byte[memoryStream.Length - (long)num2];
Buffer.BlockCopy(memoryStream.GetBuffer(), num2, retBuffer, 0, retBuffer.Length);
}
return(webHeaderCollection);
Block_5:
this.HandleError(WebExceptionStatus.ServerProtocolViolation, null, "ReadHeaders2");
return(null);
}
bool GetResponse(BufferOffsetSize buffer, ref int pos, ref ReadState state)
{
string line = null;
bool lineok = false;
bool isContinue = false;
bool emptyFirstLine = false;
do
{
if (state == ReadState.Aborted)
{
throw GetReadException(WebExceptionStatus.RequestCanceled, null, "GetResponse");
}
if (state == ReadState.None)
{
lineok = WebConnection.ReadLine(buffer.Buffer, ref pos, buffer.Offset, ref line);
if (!lineok)
{
return(false);
}
if (line == null)
{
emptyFirstLine = true;
continue;
}
emptyFirstLine = false;
state = ReadState.Status;
string[] parts = line.Split(' ');
if (parts.Length < 2)
{
throw GetReadException(WebExceptionStatus.ServerProtocolViolation, null, "GetResponse");
}
if (String.Compare(parts[0], "HTTP/1.1", true) == 0)
{
Version = HttpVersion.Version11;
ServicePoint.SetVersion(HttpVersion.Version11);
}
else
{
Version = HttpVersion.Version10;
ServicePoint.SetVersion(HttpVersion.Version10);
}
StatusCode = (HttpStatusCode)UInt32.Parse(parts[1]);
if (parts.Length >= 3)
{
StatusDescription = String.Join(" ", parts, 2, parts.Length - 2);
}
else
{
StatusDescription = string.Empty;
}
if (pos >= buffer.Offset)
{
return(true);
}
}
emptyFirstLine = false;
if (state == ReadState.Status)
{
state = ReadState.Headers;
Headers = new WebHeaderCollection();
var headerList = new List <string> ();
bool finished = false;
while (!finished)
{
if (WebConnection.ReadLine(buffer.Buffer, ref pos, buffer.Offset, ref line) == false)
{
break;
}
if (line == null)
{
// Empty line: end of headers
finished = true;
continue;
}
if (line.Length > 0 && (line[0] == ' ' || line[0] == '\t'))
{
int count = headerList.Count - 1;
if (count < 0)
{
break;
}
string prev = headerList[count] + line;
headerList[count] = prev;
}
else
{
headerList.Add(line);
}
}
if (!finished)
{
return(false);
}
// .NET uses ParseHeaders or ParseHeadersStrict which is much better
foreach (string s in headerList)
{
int pos_s = s.IndexOf(':');
if (pos_s == -1)
{
throw new ArgumentException("no colon found", "header");
}
var header = s.Substring(0, pos_s);
var value = s.Substring(pos_s + 1).Trim();
if (WebHeaderCollection.AllowMultiValues(header))
{
Headers.AddInternal(header, value);
}
else
{
Headers.SetInternal(header, value);
}
}
if (StatusCode == HttpStatusCode.Continue)
{
ServicePoint.SendContinue = true;
if (pos >= buffer.Offset)
{
return(true);
}
if (Request.ExpectContinue)
{
Request.DoContinueDelegate((int)StatusCode, Headers);
// Prevent double calls when getting the
// headers in several packets.
Request.ExpectContinue = false;
}
state = ReadState.None;
isContinue = true;
}
else
{
state = ReadState.Content;
return(true);
}
}
} while (emptyFirstLine || isContinue);
throw GetReadException(WebExceptionStatus.ServerProtocolViolation, null, "GetResponse");
}
private int GetResponse(byte[] buffer, int max)
{
int num = 0;
string text = null;
bool flag = false;
bool flag2 = false;
for (;;)
{
if (this.readState != ReadState.None)
{
goto IL_114;
}
if (!WebConnection.ReadLine(buffer, ref num, max, ref text))
{
break;
}
if (text == null)
{
flag2 = true;
}
else
{
flag2 = false;
this.readState = ReadState.Status;
string[] array = text.Split(new char[]
{
' '
});
if (array.Length < 2)
{
return(-1);
}
if (string.Compare(array[0], "HTTP/1.1", true) == 0)
{
this.Data.Version = HttpVersion.Version11;
this.sPoint.SetVersion(HttpVersion.Version11);
}
else
{
this.Data.Version = HttpVersion.Version10;
this.sPoint.SetVersion(HttpVersion.Version10);
}
this.Data.StatusCode = (int)uint.Parse(array[1]);
if (array.Length >= 3)
{
this.Data.StatusDescription = string.Join(" ", array, 2, array.Length - 2);
}
else
{
this.Data.StatusDescription = string.Empty;
}
if (num >= max)
{
return(num);
}
goto IL_114;
}
IL_2CA:
if (!flag2 && !flag)
{
return(-1);
}
continue;
IL_114:
flag2 = false;
if (this.readState != ReadState.Status)
{
goto IL_2CA;
}
this.readState = ReadState.Headers;
this.Data.Headers = new WebHeaderCollection();
ArrayList arrayList = new ArrayList();
bool flag3 = false;
while (!flag3)
{
if (!WebConnection.ReadLine(buffer, ref num, max, ref text))
{
break;
}
if (text == null)
{
flag3 = true;
}
else if (text.Length > 0 && (text[0] == ' ' || text[0] == '\t'))
{
int num2 = arrayList.Count - 1;
if (num2 < 0)
{
break;
}
string value = (string)arrayList[num2] + text;
arrayList[num2] = value;
}
else
{
arrayList.Add(text);
}
}
if (!flag3)
{
return(-1);
}
foreach (object obj in arrayList)
{
string @internal = (string)obj;
this.Data.Headers.SetInternal(@internal);
}
if (this.Data.StatusCode != 100)
{
goto IL_2C1;
}
this.sPoint.SendContinue = true;
if (num >= max)
{
return(num);
}
if (this.Data.request.ExpectContinue)
{
this.Data.request.DoContinueDelegate(this.Data.StatusCode, this.Data.Headers);
this.Data.request.ExpectContinue = false;
}
this.readState = ReadState.None;
flag = true;
goto IL_2CA;
}
return(-1);
IL_2C1:
this.readState = ReadState.Content;
return(num);
}
async Task <(WebHeaderCollection, byte[], int)> ReadHeaders(Stream stream, CancellationToken cancellationToken)
{
byte[] retBuffer = null;
int status = 200;
byte[] buffer = new byte[1024];
MemoryStream ms = new MemoryStream();
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
int n = await stream.ReadAsync(buffer, 0, 1024, cancellationToken).ConfigureAwait(false);
if (n == 0)
{
throw WebConnection.GetException(WebExceptionStatus.ServerProtocolViolation, null);
}
ms.Write(buffer, 0, n);
int start = 0;
string str = null;
bool gotStatus = false;
WebHeaderCollection headers = new WebHeaderCollection();
while (WebConnection.ReadLine(ms.GetBuffer(), ref start, (int)ms.Length, ref str))
{
if (str == null)
{
int contentLen;
var clengthHeader = headers["Content-Length"];
if (string.IsNullOrEmpty(clengthHeader) || !int.TryParse(clengthHeader, out contentLen))
{
contentLen = 0;
}
if (ms.Length - start - contentLen > 0)
{
// we've read more data than the response header and conents,
// give back extra data to the caller
retBuffer = new byte[ms.Length - start - contentLen];
Buffer.BlockCopy(ms.GetBuffer(), start + contentLen, retBuffer, 0, retBuffer.Length);
}
else
{
// haven't read in some or all of the contents for the response, do so now
FlushContents(stream, contentLen - (int)(ms.Length - start));
}
return(headers, retBuffer, status);
}
if (gotStatus)
{
headers.Add(str);
continue;
}
string[] parts = str.Split(' ');
if (parts.Length < 2)
{
throw WebConnection.GetException(WebExceptionStatus.ServerProtocolViolation, null);
}
if (String.Compare(parts[0], "HTTP/1.1", true) == 0)
{
ProxyVersion = HttpVersion.Version11;
}
else if (String.Compare(parts[0], "HTTP/1.0", true) == 0)
{
ProxyVersion = HttpVersion.Version10;
}
else
{
throw WebConnection.GetException(WebExceptionStatus.ServerProtocolViolation, null);
}
status = (int)UInt32.Parse(parts[1]);
if (parts.Length >= 3)
{
StatusDescription = String.Join(" ", parts, 2, parts.Length - 2);
}
gotStatus = true;
}
}
}