//
private bool TunnelThroughProxy(Uri proxy, HttpWebRequest originalRequest, bool async) {
GlobalLog.Enter("Connection#" + ValidationHelper.HashString(this) + "::TunnelThroughProxy", "proxy="+proxy+", async="+async+", originalRequest #"+ValidationHelper.HashString(originalRequest));
bool result = false;
HttpWebRequest connectRequest = null;
HttpWebResponse connectResponse = null;
try {
(new WebPermission(NetworkAccess.Connect, proxy)).Assert();
try {
connectRequest = new HttpWebRequest(
proxy,
originalRequest.Address,
// new Uri("https://" + originalRequest.Address.GetParts(UriComponents.HostAndPort, UriFormat.UriEscaped)),
originalRequest
);
}
finally {
WebPermission.RevertAssert();
}
connectRequest.Credentials = originalRequest.InternalProxy == null ? null : originalRequest.InternalProxy.Credentials;
connectRequest.InternalProxy = null;
connectRequest.PreAuthenticate = true;
if(async){
TunnelStateObject o = new TunnelStateObject(originalRequest, this);
IAsyncResult asyncResult = connectRequest.BeginGetResponse(m_TunnelCallback, o);
if(!asyncResult.CompletedSynchronously){
GlobalLog.Leave("Connection#" + ValidationHelper.HashString(this) + "::TunnelThroughProxy completed asynchronously", true);
return true;
}
connectResponse = (HttpWebResponse)connectRequest.EndGetResponse(asyncResult);
}
else{
connectResponse = (HttpWebResponse)connectRequest.GetResponse();
}
ConnectStream connectStream = (ConnectStream)connectResponse.GetResponseStream();
// this stream will be used as the real stream for TlsStream
NetworkStream = new NetworkStream(connectStream.Connection.NetworkStream, true);
// This will orphan the original connect stream now owned by tunnelStream
connectStream.Connection.NetworkStream.ConvertToNotSocketOwner();
result = true;
}
catch (Exception exception) {
if (m_InnerException == null)
m_InnerException = exception;
GlobalLog.Print("Connection#" + ValidationHelper.HashString(this) + "::TunnelThroughProxy() exception occurred: " + exception);
}
GlobalLog.Leave("Connection#" + ValidationHelper.HashString(this) + "::TunnelThroughProxy", result);
return result;
}
private bool TunnelThroughProxy(Uri proxy, HttpWebRequest originalRequest, bool async)
{
bool flag = false;
HttpWebRequest request = null;
HttpWebResponse response = null;
try
{
new WebPermission(NetworkAccess.Connect, proxy).Assert();
try
{
request = new HttpWebRequest(proxy, originalRequest.Address, originalRequest);
}
finally
{
CodeAccessPermission.RevertAssert();
}
request.Credentials = (originalRequest.InternalProxy == null) ? null : originalRequest.InternalProxy.Credentials;
request.InternalProxy = null;
request.PreAuthenticate = true;
if (async)
{
TunnelStateObject state = new TunnelStateObject(originalRequest, this);
IAsyncResult asyncResult = request.BeginGetResponse(m_TunnelCallback, state);
if (!asyncResult.CompletedSynchronously)
{
return true;
}
response = (HttpWebResponse) request.EndGetResponse(asyncResult);
}
else
{
response = (HttpWebResponse) request.GetResponse();
}
ConnectStream responseStream = (ConnectStream) response.GetResponseStream();
base.NetworkStream = new NetworkStream(responseStream.Connection.NetworkStream, true);
responseStream.Connection.NetworkStream.ConvertToNotSocketOwner();
flag = true;
}
catch (Exception exception)
{
if (this.m_InnerException == null)
{
this.m_InnerException = exception;
}
}
return flag;
}
