private bool Redirect(StringCollectionEx requestHeader, string[] responseText, ref string method)
{
string location = ResponseHeader.Location;
var e = new HttpRedirectEventArgs(requestHeader.ToArray(), statusCode, ResponseHeader, responseText, method,
false, false);
string resourcePath = GetResourcePath();
OnRedirecting(e);
method = e.Method;
if (e.Handled || StringUtils.IsEmpty(location))
{
return(e.CanRedirect);
}
url.Parse(Url.Url, location);
if (StringUtils.IsEmpty(Url.AbsoluteUri))
{
return(false);
}
method = GetRedirectMethod(StatusCode, method);
if (GetResourcePath().IndexOf(resourcePath) != 0)
{
var fieldList = new HeaderFieldList();
HeaderFieldList.GetHeaderFieldList(0, requestHeader, fieldList);
HeaderFieldList.RemoveHeaderField(requestHeader, fieldList, "Authorization");
}
return(true);
}
public void ParseHeader(IList header)
{
this.BeginUpdate();
try
{
this.Clear();
HeaderFieldList fieldList = new HeaderFieldList();
HeaderFieldList.GetHeaderFieldList(0, header, fieldList);
this.InternalParseHeader(header, fieldList);
StringCollectionEx ex = new StringCollectionEx();
foreach (HeaderField field in fieldList)
{
if (!this.knownFields.Contains(field.Name, true))
{
ex.Add(field.Name + ": " + HeaderFieldList.GetHeaderFieldValue(header, field));
}
}
if (ex.Count > 0)
{
this.ExtraFields = ex.ToArray();
}
}
finally
{
this.EndUpdate();
}
}
private string[] ReadResponseText(StringCollectionEx responseHeader, long extraSize, Stream extraData)
{
var responseBody = new MemoryStream();
ReadResponseBody(responseHeader, extraSize, extraData, responseBody);
responseBody.Position = 0L;
return(StringUtils.GetStringArray(Translator.GetString(responseBody.GetBuffer(), ResponseHeader.CharSet)));
}
private void ReadCookies(StringCollectionEx responseHeader)
{
var cookies = new CookieList();
if (AllowCookies)
{
cookies.GetResponseCookies(responseHeader);
}
OnResponseReceived(new HttpResponseEventArgs(method, Url.Url, responseHeader.ToArray(), cookies));
}
public string[] Put(string url, Stream source)
{
Stream responseBody = new MemoryStream();
Put(url, source, responseBody);
responseBody.Position = 0L;
var ex = new StringCollectionEx();
ex.LoadFromStream(responseBody, ResponseHeader.CharSet);
return(ex.ToArray());
}
public string[] Get(string url)
{
Stream destination = new MemoryStream();
Get(url, destination);
destination.Position = 0L;
var ex = new StringCollectionEx();
ex.LoadFromStream(destination, ResponseHeader.CharSet);
return(ex.ToArray());
}
private void ReadResponseHeader(StringCollectionEx responseHeader, MemoryStream rawData)
{
rawData.SetLength(0L);
rawData.Position = 0L;
int startPos = 0;
statusCode = 0;
int num2 = 0;
responseVersion = HttpVersion;
base.Connection.IsReadUntilClose = false;
do
{
base.Connection.ReadData(rawData);
while (true)
{
num2 = Utils.IndexOfArray(Encoding.ASCII.GetBytes("\r\n\r\n"), rawData.GetBuffer(), startPos,
(int)rawData.Length);
if (num2 <= 0)
{
break;
}
statusCode = ExtractStatusCode(rawData.GetBuffer(), startPos);
responseVersion = ExtractResponseVersion(rawData.GetBuffer(), startPos);
if (statusCode != 100)
{
break;
}
startPos = num2 + "\r\n\r\n".Length;
}
} while ((statusCode == 0) || (statusCode == 100));
rawData.Position = startPos;
responseHeader.Clear();
responseHeader.LoadFromStream(rawData, ((num2 + "\r\n\r\n".Length) - startPos), false, string.Empty);
ResponseHeader.ParseHeader(responseHeader);
}
private void ReadResponseBody(StringCollectionEx responseHeader, long extraSize, Stream extraData,
Stream responseBody)
{
Stream stream = null;
TcpClientConnection connection = base.Connection;
connection.Progress =
(SocketProgressEventHandler)
Delegate.Combine(connection.Progress, new SocketProgressEventHandler(DoDataReceiveProgress));
try
{
Stream destination = responseBody;
if (string.Compare("chunked", ResponseHeader.TransferEncoding, true, CultureInfo.InvariantCulture) == 0)
{
using (var stream3 = new ChunkedStream(destination))
{
if (extraSize > 0L)
{
StreamUtils.Copy(extraData, stream3, extraSize);
}
InitProgress(extraSize, -1L);
if (base.Active)
{
while (!stream3.IsCompleted)
{
base.Connection.ReadData(stream3);
}
}
if (!progressHandled)
{
OnReceiveProgress(new SocketProgressEventArgs(base.Connection.BytesProceed, -1L));
}
goto Label_01AC;
}
}
if (extraSize > 0L)
{
StreamUtils.Copy(extraData, destination, extraSize);
}
long responseLength = GetResponseLength();
long totalBytes = responseLength;
InitProgress(extraSize, totalBytes);
if (responseLength < 0L)
{
if (base.Active)
{
base.Connection.IsReadUntilClose = true;
base.Connection.ReadData(destination);
}
}
else
{
long bytesProceed = base.Connection.BytesProceed;
responseLength -= extraSize;
if (base.Active)
{
while ((base.Connection.BytesProceed - bytesProceed) < responseLength)
{
base.Connection.ReadData(destination);
}
}
}
if (!progressHandled)
{
OnReceiveProgress(new SocketProgressEventArgs(totalBytes, totalBytes));
}
}
finally
{
TcpClientConnection connection2 = base.Connection;
connection2.Progress =
(SocketProgressEventHandler)
Delegate.Remove(connection2.Progress, new SocketProgressEventHandler(DoDataReceiveProgress));
if (stream != null)
{
stream.Close();
}
stream = null;
}
Label_01AC:
ReadCookies(responseHeader);
}
private string[] InternalSendRequest(string method, string[] requestHeader, Stream requestBody,
Stream responseBody)
{
string[] strArray2;
using (var stream = new MemoryStream())
{
var ex = new StringCollectionEx();
if (requestHeader != null)
{
ex.AddRange(requestHeader);
}
var responseHeader = new StringCollectionEx();
this.method = method;
if (requestBody == null)
{
requestBody = Stream.Null;
}
if (responseBody == null)
{
responseBody = Stream.Null;
}
string[] responseText = null;
long position = requestBody.Position;
bool flag = false;
int num2 = 0;
int num3 = 0;
int num4 = 0;
long extraSize = 0L;
HttpTunnelStatus none = HttpTunnelStatus.None;
try
{
while (true)
{
none = GetTunnelStatus();
WriteRequestHeader(none, ex, requestBody);
requestBody.Position = position;
WriteRequestData(requestBody);
OnRequestSent(new HttpRequestEventArgs(this.method, Url.Url, ex.ToArray()));
ReadResponseHeader(responseHeader, stream);
extraSize = stream.Length - stream.Position;
flag = !GetKeepAlive();
if ((((StatusCode / 100) == 3) && (StatusCode != 0x130)) && (StatusCode != 0x131))
{
num2++;
responseText = ReadResponseText(responseHeader, extraSize, stream);
if ((MaxRedirects > 0) && (num2 > MaxRedirects))
{
RaiseHttpError(StatusCode, responseHeader, responseText);
}
string str = this.method;
if (!AllowRedirects || !Redirect(ex, responseText, ref str))
{
RaiseHttpError(StatusCode, responseHeader, responseText);
}
if (string.Compare(str, "GET", true, CultureInfo.InvariantCulture) == 0)
{
requestBody = Stream.Null;
}
this.method = str;
if (IsUseProxy())
{
flag = true;
}
}
else if (StatusCode == 0x191)
{
num3++;
responseText = ReadResponseText(responseHeader, extraSize, stream);
if ((MaxAuthRetries > 0) && (num3 > MaxAuthRetries))
{
RaiseHttpError(StatusCode, responseHeader, responseText);
}
}
else if (StatusCode == 0x197)
{
num4++;
responseText = ReadResponseText(responseHeader, extraSize, stream);
if ((MaxAuthRetries > 0) && (num4 > MaxAuthRetries))
{
RaiseHttpError(StatusCode, responseHeader, responseText);
}
}
else if (StatusCode >= 400)
{
responseText = ReadResponseText(responseHeader, extraSize, stream);
RaiseHttpError(StatusCode, responseHeader, responseText);
}
else
{
ReadResponseBody(responseHeader, extraSize, stream, responseBody);
goto Label_032C;
}
if (flag)
{
base.Close();
}
}
}
finally
{
if (flag && (none != HttpTunnelStatus.Connect))
{
base.Close();
}
}
Label_032C:
strArray2 = responseHeader.ToArray();
}
return(strArray2);
}
