private static string GetSingleIssuer(string url)
{
string issuer = null;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls
| SecurityProtocolType.Tls11
| SecurityProtocolType.Tls12
| SecurityProtocolType.Ssl3;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://" + url);
IWebProxy proxy = request.Proxy;
if (proxy.GetProxy(request.RequestUri).ToString().Substring(0, 8) != "https://")
{
string proxyuri = proxy.GetProxy(request.RequestUri).ToString();
request.UseDefaultCredentials = true;
request.Proxy = new WebProxy(proxyuri, false);
request.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
}
request.UseDefaultCredentials = true;
request.UserAgent = userAgent;
request.Timeout = 5000;
X509Certificate cert2 = null;
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)request.GetResponse();
X509Certificate cert = request.ServicePoint.Certificate;
cert2 = new X509Certificate2(cert);
}
catch (Exception e)
{
if (verbose)
{
Console.WriteLine("[-] Failed to connect to {0}", url);
return(null);
}
}
if (cert2 != null)
{
issuer = cert2.Issuer;
}
return(issuer);
}
private void FillLabels()
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
Settings settings = new Settings();
this.lblExportDaysWithoutTrade.Left += this.lblExportDaysWithoutTrade.Width;
this.lblExportDaysWithoutTrade.Text = settings.ExportDaysWithoutTrade ? "بلی" : "خیر";
this.lblExportDaysWithoutTrade.Left -= this.lblExportDaysWithoutTrade.Width;
this.lblStorageLocation.Left += this.lblStorageLocation.Width;
this.lblStorageLocation.Text = settings.StorageLocation;
this.lblStorageLocation.Left -= this.lblStorageLocation.Width;
this.lblAdjustedStorageLocation.Left += this.lblAdjustedStorageLocation.Width;
this.lblAdjustedStorageLocation.Text = settings.AdjustedStorageLocation;
this.lblAdjustedStorageLocation.Left -= this.lblAdjustedStorageLocation.Width;
this.lblFileType.Left += this.lblFileType.Width;
this.lblFileType.Text = settings.ExcelOutput ? "Excel" : "CSV";
this.lblFileType.Left -= this.lblFileType.Width;
this.lblProxy.Left += this.lblProxy.Width;
try {
IWebProxy defaultWebProxy = WebRequest.DefaultWebProxy;
string str1 = defaultWebProxy.GetProxy(new Uri("http://www.tsetmc.com")).Host.ToString();
string str2 = defaultWebProxy.GetProxy(new Uri("http://www.tsetmc.com")).Port.ToString();
if (str1.Equals("www.tsetmc.com") && str2.Equals("80"))
{
this.lblProxy.Text = "ندارد";
}
else
{
this.lblProxy.Text = "دارد";
}
} catch {
this.lblProxy.Text = "خطا در دریافت اطلاعات پراکسی";
}
this.lblProxy.Left -= this.lblProxy.Width;
this.txtSelectedColumns.Text = "";
foreach (ColumnInfo columnInfo in StaticData.ColumnsInfo)
{
if (columnInfo.Visible)
{
TextBox txtSelectedColumns = this.txtSelectedColumns;
txtSelectedColumns.Text = txtSelectedColumns.Text + FormFillMethods.GetColumnHeader(columnInfo.Type) + ",";
}
}
this.txtSelectedColumns.Text = this.txtSelectedColumns.Text.Substring(0, this.txtSelectedColumns.Text.Length - 1);
this.groupBoxContainer.Text = "نمایش تنظیمات";
this.lblWait.Visible = false;
}
public void GetProxy_AllValuesSpecified_ReturnsProxyWithCredentials()
{
var mockSettings = new Mock <ISettings>();
string proxyServer = "http://proxyValue/";
string proxyUser = "******";
string proxyPassword = "******";
mockSettings.Setup(s => s.TryGetValue(It.Is <string>(v => v.Equals("http_proxy")), out proxyServer))
.Returns(true);
mockSettings.Setup(s => s.TryGetValue(It.Is <string>(v => v.Equals("http_proxy.user")), out proxyUser))
.Returns(true);
mockSettings.Setup(s => s.TryGetEncryptedValue(It.IsAny <string>(), out proxyPassword))
.Returns(true);
var ut = new ProxySettings(mockSettings.Object);
IWebProxy result = ut.GetProxy(new Uri("http://test"));
Assert.IsNotNull(result);
Assert.AreEqual(new Uri("http://proxyValue/"), result.GetProxy(new Uri("http://test")));
Assert.IsNotNull(result.Credentials);
NetworkCredential cred = result.Credentials.GetCredential(new Uri("http://test"), "");
Assert.AreEqual(proxyUser, cred.UserName);
Assert.AreEqual(proxyPassword, cred.Password);
}
public void WebProxy()
{
IWebProxy proxy = PlatformCFNetwork.GetDefaultProxy();
Assert.True(proxy.IsBypassed(uri), "IsBypassed");
Assert.That(proxy.GetProxy(uri), Is.SameAs(uri), "GetProxy");
}
/// <summary>
/// 比较代理是否相等
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
private static bool IsProxyEquals(IWebProxy x, IWebProxy y)
{
if (x == null && y == null)
{
return(true);
}
if (x == null || y == null)
{
return(false);
}
if (x.GetProxy(destination) != y.GetProxy(destination))
{
return(false);
}
if (x.Credentials == null && y.Credentials == null)
{
return(true);
}
if (x.Credentials == null || y.Credentials == null)
{
return(false);
}
return(true);
}
protected virtual IActualProxy GetSystemActualProxy(SystemSettings systemSettings)
{
// argument checks
Debug.Assert(systemSettings != null);
// detect the system web proxy by try to give external urls
// Note this implementation simply detect a possible typical proxy.
IWebProxy systemProxy = WebRequest.GetSystemWebProxy();
Func <string, IActualProxy> detect = (sampleExternalUrl) => {
Uri sampleUri = new Uri(sampleExternalUrl);
IActualProxy value = null;
if (systemProxy.IsBypassed(sampleUri) == false)
{
Uri uri = systemProxy.GetProxy(sampleUri);
if (uri != sampleUri)
{
// uri seems to be a proxy
value = new StaticActualProxy(new DnsEndPoint(uri.Host, uri.Port));
}
}
return(value);
};
// try with google's URL
IActualProxy actualProxy = detect("http://www.google.com/");
if (actualProxy == null)
{
// try with Microsoft's URL
actualProxy = detect("http://www.microsoft.com/");
}
return(actualProxy); // note that it may be null
}
static WebProxy GetSystemProxyUri(string host)
{
if (_networkConfiguration.ProxyClass == ProxyType.Socks5)
{
if (PolipoSocks5ToHttpProxyWrapper.Instance.IsRunning)
{
return(new WebProxy(PolipoSocks5ToHttpProxyWrapper.Instance.LocalUri));
}
return(null);
}
WebProxy result;
if (!_systemCachedProxy.TryGetValue(host, out result))
{
lock (_systemCachedProxy)
{
var uri = new Uri("https://" + host + "/");
var proxyuri = _systemProxy.GetProxy(uri);
if (proxyuri == uri)
{
proxyuri = null;
}
result = (proxyuri == null ? null : new WebProxy(proxyuri));
if (!_systemCachedProxy.ContainsKey(host))
{
_systemCachedProxy.Add(host, result);
}
}
}
return(result);
}
private IWebProxy GetProxy(string uri)
{
if (_proxy != null)
{
return(_proxy);
}
if (_globalOptions.ProxyUseSystem || _globalOptions.ProxyAddress.Length == 0)
{
UseSystemProxy();
}
else
{
try
{
_proxy = new WebProxy(_globalOptions.ProxyAddress);
_proxy.Credentials = new NetworkCredential(
_globalOptions.ProxyUser,
_globalOptions.ProxySecurePassword.ConvertToUnsecureString());
}
catch (Exception ex)
{
_eventAggregator.PublishOnUIThread(new OutputMessage(MessageType.Error, "Error connecting to HTTP Proxy specified in File > Options: " + ex.Message));
Log.Error("{class} {method} {message} {stacktrace}", "WebRequestFactory", "GetProxy", ex.Message, ex.StackTrace);
UseSystemProxy();
}
}
Log.Verbose("Proxy: {proxyAddress}", _proxy.GetProxy(new Uri(uri)).AbsolutePath);
return(_proxy);
}
private static GeoResponse GetGeoResponse(string url)
{
GeoResponse res = null;
try
{
HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;
request.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip,deflate");
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(GeoResponse));
IWebProxy proxy = request.Proxy;
if (proxy != null)
{
string proxyuri = proxy.GetProxy(request.RequestUri).ToString();
request.UseDefaultCredentials = true;
request.Proxy = new WebProxy(proxyuri, false);
request.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
}
Stream stream = request.GetResponse().GetResponseStream();
res = (GeoResponse)serializer.ReadObject(stream);
}
catch (Exception ex)
{
MessageBox.Show("Unable to contact http://maps.googleapis.com error was : " + ex.Message, "FTAnalyzer");
}
return(res);
}
public static Uri GetCurrentConfig(string url)
{
IWebProxy proxy = WebRequest.GetSystemWebProxy();
Uri uriProxy = proxy.GetProxy(new Uri(url));
return(uriProxy);
}
public void GetProxy_AllValuesSpecified_ReturnsProxyWithCredentials()
{
var mockSettings = new Mock <ISettings>();
string proxyServer = "http://proxyValue/";
string proxyUser = "******";
// [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine", Justification="test value; not a real secret")]
string proxyPassword = "******";
mockSettings.Setup(s => s.TryGetValue(It.Is <string>(v => v.Equals("http_proxy")), out proxyServer))
.Returns(true);
mockSettings.Setup(s => s.TryGetValue(It.Is <string>(v => v.Equals("http_proxy.user")), out proxyUser))
.Returns(true);
mockSettings.Setup(s => s.TryGetEncryptedValue(It.IsAny <string>(), out proxyPassword))
.Returns(true);
var ut = new ProxySettings(mockSettings.Object);
IWebProxy result = ut.GetProxy(new Uri("http://test"));
Assert.IsNotNull(result);
Assert.AreEqual(new Uri("http://proxyValue/"), result.GetProxy(new Uri("http://test")));
Assert.IsNotNull(result.Credentials);
NetworkCredential cred = result.Credentials.GetCredential(new Uri("http://test"), "");
Assert.AreEqual(proxyUser, cred.UserName);
Assert.AreEqual(proxyPassword, cred.Password);
}
private bool CurrentProxyStatue()
{
HttpWebRequest myWebRequest = (HttpWebRequest)WebRequest.Create("http://www.microsoft.com");
// Obtain the 'Proxy' of the Default browser.
IWebProxy proxy = myWebRequest.Proxy;
// Print the Proxy Url to the console.
if (proxy != null)
{
string prx = TrimProxyString(proxy.GetProxy(myWebRequest.RequestUri).ToString());
string res = string.Format("Proxy: {0}", prx);
lblCPS.Text = "Current " + res;
if (res.Contains("micro"))
{
lblCPS.Text = "No proxy";
Notify(lblCPS.Text);
return(false);
}
Notify(lblCPS.Text);
return(true);
}
else
{
lblCPS.Text = "No proxy";
Notify(lblCPS.Text);
return(false);
}
}
public static IWebProxy CreateWebProxyWithCredentials(String sUrl, string ProxyUserName, string ProxyUserPassword, string sAuthType, string ProxyUserDomain)
{
if (String.IsNullOrEmpty(ProxyUserName) || String.IsNullOrEmpty(ProxyUserPassword))
{
return(null);
}
// get default proxy and assign it to the WebService. Alternatively, you can replace this with manual WebProxy creation.
IWebProxy iDefaultWebProxy = WebRequest.DefaultWebProxy;
Uri uriProxy = iDefaultWebProxy.GetProxy(new Uri(sUrl));
string sProxyUrl = uriProxy.AbsoluteUri;
if (sProxyUrl == sUrl)
{//no proxy specified
return(null);
}
IWebProxy proxyObject = new WebProxy(sProxyUrl, true);
// assign the credentials to the Proxy
//todo do we need to add credentials to WebService too??
if ((!String.IsNullOrEmpty(sAuthType)) && (sAuthType.ToLower() != "basic"))
{
//from http://www.mcse.ms/archive105-2004-10-1165271.html
// create credentials cache - it will hold both, the WebProxy credentials (??and the WebService credentials too??)
System.Net.CredentialCache cache = new System.Net.CredentialCache();
// add default credentials for Proxy (notice the authType = 'Kerberos' !) Other types are 'Basic', 'Digest', 'Negotiate', 'NTLM'
cache.Add(new Uri(sProxyUrl), sAuthType, new System.Net.NetworkCredential(ProxyUserName, ProxyUserPassword, ProxyUserDomain));
proxyObject.Credentials = cache;
}
else//special case for Basic (from http://www.xmlwebservices.cc/index_FAQ.htm )
{
proxyObject.Credentials = new System.Net.NetworkCredential(ProxyUserName, ProxyUserPassword);
}
return(proxyObject);
}
static async Task <ClientWebSocket> CreateClientWebSocketAsync(Uri websocketUri, TimeSpan timeout)
{
var websocket = new ClientWebSocket();
// Set SubProtocol to AMQPWSB10
websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10);
// Check if we're configured to use a proxy server
IWebProxy webProxy = WebRequest.DefaultWebProxy;
Uri proxyAddress = null;
try
{
proxyAddress = webProxy?.GetProxy(websocketUri);
if (!websocketUri.Equals(proxyAddress))
{
// Configure proxy server
websocket.Options.Proxy = webProxy;
}
}
catch (PlatformNotSupportedException)
{
// .NET Core 2.0 doesn't support proxy. Ignore this setting.
}
websocket.Options.UseDefaultCredentials = true;
using (var cancellationTokenSource = new CancellationTokenSource(timeout))
{
await websocket.ConnectAsync(websocketUri, cancellationTokenSource.Token).ConfigureAwait(false);
}
return(websocket);
}
static void SimulateMonoGetProxy(Uri uri)
{
Console.WriteLine("# Mono - simulate Mono's WebRequest.DefaultWebProxy");
IWebProxy proxy = MonoWebRequest.DefaultWebProxy;
if (proxy != null)
{
Console.WriteLine("MonoWebRequest.DefaultWebProxy.GetType: {0}", proxy.GetType().FullName);
Uri proxyAddress = new Uri(proxy.GetProxy(uri).AbsoluteUri);
if (string.Equals(proxyAddress.AbsoluteUri, uri.AbsoluteUri))
{
Console.WriteLine("ProxyAddress matches request uri. Ignoring proxy uri: '{0}'", proxyAddress);
return;
}
if (proxy.IsBypassed(uri))
{
Console.WriteLine("Proxy IsByPassed for '{0}'", uri);
return;
}
Console.WriteLine("Proxy found. Uri: '{0}'", proxyAddress);
}
else
{
Console.WriteLine("MonoWebRequest.DefaultWebProxy is null. Trying WebRequest.GetSystemWebProxy");
}
}
private string GetCurrentProxyString()
{
HttpWebRequest myWebRequest = (HttpWebRequest)WebRequest.Create("http://www.microsoft.com");
// Obtain the 'Proxy' of the Default browser.
IWebProxy proxy = myWebRequest.Proxy;
// Print the Proxy Url to the console.
if (proxy != null)
{
string res = proxy.GetProxy(myWebRequest.RequestUri).ToString();//string.Format("Proxy: {0}", );
if (res.Contains("micro"))
{
return("No proxy");
}
else
{
return(res);
}
}
else
{
return("No proxy");
}
}
public override ch.cyberduck.core.proxy.Proxy find(string host)
{
Uri target;
try
{
target = new Uri(host);
}
catch (UriFormatException)
{
return(ch.cyberduck.core.proxy.Proxy.DIRECT);
}
if (_system.IsBypassed(target))
{
return(ch.cyberduck.core.proxy.Proxy.DIRECT);
}
// Hack to make Secur32/IWA work. With a non-us locale we get an invalid codepage (1) exception when using the native library.
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Uri proxy = _system.GetProxy(target);
return(new ch.cyberduck.core.proxy.Proxy(ch.cyberduck.core.proxy.Proxy.Type.valueOf(proxy.Scheme.ToUpper()),
proxy.Host, proxy.Port, proxy.UserInfo));
}
private static bool ProxyAddressIfNecessary(ref Uri address, IWebProxy proxy)
{
if (proxy != null && !address.IsLoopback)
{
try
{
Uri proxyAddress = proxy.GetProxy(address);
if (proxyAddress != null)
{
if (proxyAddress.Scheme != Uri.UriSchemeHttp)
{
throw new NotSupportedException(SR.Format(SR.net_proxyschemenotsupported, address.Scheme));
}
address = proxyAddress;
return(true);
}
}
catch (PlatformNotSupportedException)
{
// HttpWebRequest has a dummy SystemWebProxy that's used as a sentinel
// and whose GetProxy method throws a PlatformNotSupportedException.
// For the purposes of this stand-in ServicePointManager implementation,
// we ignore this default "system" proxy for the purposes of mapping
// to a particular ServicePoint instance.
}
}
return(false);
}
public void GetProxyInformation(string url)
{
IWebProxy wp = WebRequest.GetSystemWebProxy();
Uri req = new Uri(url);
Console.Out.WriteLine("URL Requested: " + req.AbsoluteUri);
Uri proxy = wp.GetProxy(req);
if (String.Compare(req.AbsoluteUri, proxy.AbsoluteUri) == 0)
{
Console.Out.WriteLine("Proxy: DIRECT");
}
else
{
Console.Out.WriteLine("Proxy: " + proxy.AbsoluteUri);
}
if (wp.Credentials != null)
{
NetworkCredential cred = wp.Credentials.GetCredential(req, "basic");
Console.Out.WriteLine("Proxy Username: "******"Proxy Password: "******"Proxy Domain: " + cred.Domain);
}
}
async Task <ClientWebSocket> CreateClientWebSocketAsync(Uri websocketUri, TimeSpan timeout)
{
var websocket = new ClientWebSocket();
// Set SubProtocol to AMQPWSB10
websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10);
// Check if we're configured to use a proxy server
IWebProxy webProxy = WebRequest.DefaultWebProxy;
Uri proxyAddress = webProxy != null?webProxy.GetProxy(websocketUri) : null;
if (!websocketUri.Equals(proxyAddress))
{
// Configure proxy server
websocket.Options.Proxy = webProxy;
}
if (this.AmqpTransportSettings.ClientCertificate != null)
{
websocket.Options.ClientCertificates.Add(this.AmqpTransportSettings.ClientCertificate);
}
else
{
websocket.Options.UseDefaultCredentials = true;
}
using (var cancellationTokenSource = new CancellationTokenSource(timeout))
{
await websocket.ConnectAsync(websocketUri, cancellationTokenSource.Token);
}
return(websocket);
}
private static HttpWebRequest CreateRequest(String url)
{
HttpWebRequest request = null;
request = (HttpWebRequest)WebRequest.Create(url);
request.KeepAlive = false;
DateTime buildDate = System.IO.File.GetLastWriteTime(System.Reflection.Assembly.GetExecutingAssembly().Location);
request.UserAgent = @"Ultraschall_Agent " + QueryLocalVersion() + " (" + System.Environment.OSVersion + ")";
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; // this is crucial, don't ask
IWebProxy proxy = request.Proxy;
if (proxy != null)
{
String proxyUri = proxy.GetProxy(request.RequestUri).ToString();
if (String.IsNullOrEmpty(proxyUri) == false)
{
if (proxyUri != url)
{
request.UseDefaultCredentials = true;
request.Proxy = new WebProxy(proxyUri, true);
request.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
}
}
}
return(request);
}
public static ServicePoint FindServicePoint(Uri address, IWebProxy proxy)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
var origAddress = new Uri(address.Scheme + "://" + address.Authority);
bool usesProxy = false;
bool useConnect = false;
if (proxy != null && !proxy.IsBypassed(address))
{
usesProxy = true;
bool isSecure = address.Scheme == "https";
address = proxy.GetProxy(address);
if (address.Scheme != "http")
{
throw new NotSupportedException("Proxy scheme not supported.");
}
if (isSecure && address.Scheme == "http")
{
useConnect = true;
}
}
address = new Uri(address.Scheme + "://" + address.Authority);
var key = new SPKey(origAddress, usesProxy ? address : null, useConnect);
lock (servicePoints) {
if (servicePoints.TryGetValue(key, out var sp))
{
return(sp);
}
if (maxServicePoints > 0 && servicePoints.Count >= maxServicePoints)
{
throw new InvalidOperationException("maximum number of service points reached");
}
int limit;
#if MOBILE
limit = defaultConnectionLimit;
#else
string addr = address.ToString();
limit = (int)manager.GetMaxConnections(addr);
#endif
sp = new ServicePoint(key, address, limit, maxServicePointIdleTime);
sp.Expect100Continue = expectContinue;
sp.UseNagleAlgorithm = useNagle;
sp.UsesProxy = usesProxy;
sp.UseConnect = useConnect;
sp.SetTcpKeepAlive(tcp_keepalive, tcp_keepalive_time, tcp_keepalive_interval);
return(servicePoints.GetOrAdd(key, sp));
}
}
public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
{
// if looking for proxy credentials, we care about the proxy's URL, not the request URL
if (credentialType == CredentialType.ProxyCredentials)
{
var proxyUri = proxy.GetProxy(uri);
if (proxyUri != null)
{
uri = proxyUri;
}
}
lock (guiLock) {
// If this is the first attempt, return any stored credentials. If they fail, we'll be called again.
if (!retrying)
{
var creds = GetExistingCredentials(uri, credentialType);
if (creds != null)
{
return(creds);
}
}
return(GetCredentialsFromUser(uri, proxy, credentialType));
}
}
private Uri GetProxyUri(string strSessionUrl, bool bForceHttp)
{
if (string.IsNullOrEmpty(strSessionUrl))
{
Debug.Assert(false); return(null);
}
try
{
if (bForceHttp && !strSessionUrl.StartsWith("http:",
StrUtil.CaseIgnoreCmp))
{
strSessionUrl = "http://" + UrlUtil.RemoveScheme(strSessionUrl);
}
Uri uriSession = new Uri(strSessionUrl);
if ((m_prx != null) && !m_prx.IsBypassed(uriSession))
{
Uri uriProxy = m_prx.GetProxy(uriSession);
Debug.Assert(uriProxy != uriSession);
return(uriProxy);
}
}
catch (Exception) { Debug.Assert(false); }
return(null);
}
/// <summary>
/// Return true or false if connecting through a proxy server
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
private static bool IsSystemProxySet(Uri uri)
{
// The reason for not calling the GetSystemProxy is because the object
// that will be returned is no longer going to be the proxy that is set by the settings
// on the users machine only the Address is going to be the same.
// Not sure why the .NET team did not want to expose all of the useful settings like
// ByPass list and other settings that we can't get because of it.
// Anyway the reason why we need the DefaultWebProxy is to see if the uri that we are
// getting the proxy for to should be bypassed or not. If it should be bypassed then
// return that we don't need a proxy and we should try to connect directly.
IWebProxy proxy = WebRequest.DefaultWebProxy;
if (proxy != null)
{
Uri proxyUri = proxy.GetProxy(uri);
if (proxyUri != null)
{
Uri proxyAddress = new Uri(proxyUri.AbsoluteUri);
if (String.Equals(proxyAddress.AbsoluteUri, uri.AbsoluteUri))
{
return(false);
}
bool bypassUri = proxy.IsBypassed(uri);
if (bypassUri)
{
return(false);
}
proxy = new WebProxy(proxyAddress);
}
}
return(proxy != null);
}
public Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (_proxy == null)
{
return(SendAsyncCore(request, null, false, cancellationToken));
}
Uri proxyUri = null;
try
{
if (!_proxy.IsBypassed(request.RequestUri))
{
proxyUri = _proxy.GetProxy(request.RequestUri);
}
}
catch (Exception ex)
{
// Eat any exception from the IWebProxy and just treat it as no proxy.
// This matches the behavior of other handlers.
}
if (proxyUri != null && proxyUri.Scheme != "http")
{
throw new NotSupportedException("net_http_invalid_proxy_scheme");
}
return(SendAsyncCore(request, proxyUri, false, cancellationToken));
}
/// <summary>
/// Checks the web client and installs basic proxy settings
/// </summary>
/// <param name="client">web client</param>
public static void CheckClient(WebClient client)
{
if (proxy == null)
{
string host = "";
IWebProxy proxy2 = WebRequest.GetSystemWebProxy();
//High-availability server
host = proxy2.GetProxy(new Uri("http://www.google.com")).Host;
proxy = new WebProxy(host, true);
try
{
//Low-data return, checks for error when downloading
client.DownloadData("www.google.com");
}
catch
{
if (Username == "" && Password == "")
{
//Always returns proxy server if there is a proxy - which does not equal the initial proxy host
if (proxy.Address.Host != "www.google.com")
{
PromptCredientials(proxy.Address.Host);
proxy.Credentials = new NetworkCredential(Username, Password);
}
else
{
proxy = null;
}
}
}
}
client.Proxy = proxy;
}
public static ServicePoint FindServicePoint(Uri address, IWebProxy proxy)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
RecycleServicePoints();
bool usesProxy = false;
bool useConnect = false;
if (proxy != null && !proxy.IsBypassed(address))
{
usesProxy = true;
bool isSecure = address.Scheme == "https";
address = proxy.GetProxy(address);
if (address.Scheme != "http" && !isSecure)
{
throw new NotSupportedException("Proxy scheme not supported.");
}
if (isSecure && address.Scheme == "http")
{
useConnect = true;
}
}
address = new Uri(address.Scheme + "://" + address.Authority);
ServicePoint sp = null;
lock (servicePoints) {
int key = address.GetHashCode() + (int)((useConnect) ? 1 : 0);
sp = servicePoints [key] as ServicePoint;
if (sp != null)
{
return(sp);
}
if (maxServicePoints > 0 && servicePoints.Count >= maxServicePoints)
{
throw new InvalidOperationException("maximum number of service points reached");
}
string addr = address.ToString();
int limit = (int)manager.GetMaxConnections(addr);
sp = new ServicePoint(address, limit, maxServicePointIdleTime);
#if NET_1_1
sp.Expect100Continue = expectContinue;
sp.UseNagleAlgorithm = useNagle;
#endif
sp.UsesProxy = usesProxy;
sp.UseConnect = useConnect;
servicePoints.Add(key, sp);
}
return(sp);
}
void ProcessMethod()
{
ServicePoint sp = GetServicePoint();
if (sp.UsesProxy)
{
if (method != WebRequestMethods.Ftp.DownloadFile)
{
throw new NotSupportedException("FTP+proxy only supports RETR");
}
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(proxy.GetProxy(requestUri));
req.Address = requestUri;
requestState = RequestState.Finished;
WebResponse response = req.GetResponse();
ftpResponse.Stream = new FtpDataStream(this, response.GetResponseStream(), true);
ftpResponse.StatusCode = FtpStatusCode.CommandOK;
return;
}
State = RequestState.Connecting;
ResolveHost();
OpenControlConnection();
CWDAndSetFileName(requestUri);
SetType();
switch (method)
{
// Open data connection and receive data
case WebRequestMethods.Ftp.DownloadFile:
case WebRequestMethods.Ftp.ListDirectory:
case WebRequestMethods.Ftp.ListDirectoryDetails:
DownloadData();
break;
// Open data connection and send data
case WebRequestMethods.Ftp.AppendFile:
case WebRequestMethods.Ftp.UploadFile:
case WebRequestMethods.Ftp.UploadFileWithUniqueName:
UploadData();
break;
// Get info from control connection
case WebRequestMethods.Ftp.GetFileSize:
case WebRequestMethods.Ftp.GetDateTimestamp:
case WebRequestMethods.Ftp.PrintWorkingDirectory:
case WebRequestMethods.Ftp.MakeDirectory:
case WebRequestMethods.Ftp.Rename:
case WebRequestMethods.Ftp.DeleteFile:
ProcessSimpleMethod();
break;
default: // What to do here?
throw new Exception(String.Format("Support for command {0} not implemented yet", method));
}
CheckIfAborted();
}
private static WebProxy GetSystemProxy(Uri uri)
{
// WebRequest.DefaultWebProxy seems to be more capable in terms of getting the default
// proxy settings instead of the WebRequest.GetSystemProxy()
var proxyUri = _originalSystemProxy.GetProxy(uri);
return(new WebProxy(proxyUri));
}
public ICredentials GetCredentials (Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
{
// if looking for proxy credentials, we care about the proxy's URL, not the request URL
if (credentialType == CredentialType.ProxyCredentials) {
var proxyUri = proxy.GetProxy (uri);
if (proxyUri != null)
uri = proxyUri;
}
lock (guiLock) {
// If this is the first attempt, return any stored credentials. If they fail, we'll be called again.
if (!retrying) {
var creds = GetExistingCredentials (uri, credentialType);
if (creds != null)
return creds;
}
return GetCredentialsFromUser (uri, proxy, credentialType);
}
}
/// <summary>
/// Returns an ICredentials instance that the consumer would need in order
/// to properly authenticate to the given Uri.
/// </summary>
public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
// Capture the original proxy before we do anything
// so that we can re-set it once we get the credentials for the given Uri.
IWebProxy originalProxy = null;
if (proxy != null)
{
// If the current Uri should be bypassed then don't try to get the specific
// proxy but simply capture the one that is given to us
if (proxy.IsBypassed(uri))
{
originalProxy = proxy;
}
// If the current Uri is not bypassed then get a valid proxy for the Uri
// and make sure that we have the credentials also.
else
{
originalProxy = new WebProxy(proxy.GetProxy(uri));
originalProxy.Credentials = proxy.Credentials == null
? null : proxy.Credentials.GetCredential(uri, null);
}
}
try
{
// The cached credentials that we found are not valid so let's ask the user
// until they abort or give us valid credentials.
InitializeCredentialProxy(uri, originalProxy);
return PromptForCredentials(uri);
}
finally
{
// Reset the original WebRequest.DefaultWebProxy to what it was when we started credential discovery.
WebRequest.DefaultWebProxy = originalProxy;
}
}
public static void SetWarp(this WebRequest webRequest, WarpEngine warpEngine, IWebProxy proxy)
{
warpEngine.SetWarp(webRequest);
if (proxy != null)
{
// warproxy header
string base64String;
if (proxy is WebProxy)
{
base64String = Helper.FromProxy(proxy as WebProxy);
}
else
{
WebProxy webProxy = new WebProxy(proxy.GetProxy(webRequest.RequestUri));
webProxy.Credentials = proxy.Credentials.GetCredential(webRequest.RequestUri, "BASIC");
base64String = Helper.FromProxy(webProxy);
}
webRequest.Headers.Set("warproxy", base64String);
}
}
public ICredentials GetCredentials (Uri uri, IWebProxy proxy, CredentialType credentialType, bool retrying)
{
if (credentialType != CredentialType.ProxyCredentials)
return wrapped.GetCredentials (uri, proxy, credentialType, retrying);
var proxyUri = proxy.GetProxy (uri);
if (proxyUri == null)
return null;
if (!retrying) {
var cached = CredentialStore.Instance.GetCredentials (proxyUri);
if (cached != null)
return cached;
}
lock (locker) {
if (!retrying) {
var cached = CredentialStore.Instance.GetCredentials (proxyUri);
if (cached != null)
return cached;
}
var creds = wrapped.GetCredentials (uri, proxy, credentialType, retrying);
if (creds != null)
CredentialStore.Instance.Add (proxyUri, creds);
return creds;
}
}
public static string GetWebData(string url, CookieContainer cc = null, string referer = null, IWebProxy proxy = null, bool forceUTF8 = false, bool allowUnsafeHeader = false, string userAgent = null, Encoding encoding = null)
{
HttpWebResponse response = null;
try
{
string requestCRC = Helpers.EncryptionUtils.CalculateCRC32(string.Format("{0}{1}{2}{3}{4}", url, referer, userAgent, proxy != null ? proxy.GetProxy(new Uri(url)).AbsoluteUri : "", cc != null ? cc.GetCookieHeader(new Uri(url)) : ""));
// try cache first
string cachedData = WebCache.Instance[requestCRC];
Log.Debug("GetWebData{1}: '{0}'", url, cachedData != null ? " (cached)" : "");
if (cachedData != null) return cachedData;
// request the data
if (allowUnsafeHeader) Helpers.DotNetFrameworkHelper.SetAllowUnsafeHeaderParsing(true);
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
if (request == null) return "";
if (!String.IsNullOrEmpty(userAgent))
request.UserAgent = userAgent; // set specific UserAgent if given
else
request.UserAgent = OnlineVideoSettings.Instance.UserAgent; // set OnlineVideos default UserAgent
request.Accept = "*/*"; // we accept any content type
request.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip,deflate"); // we accept compressed content
request.Headers.Add("X-Requested-With: XMLHttpRequest");
request.Headers.Add("x-addr: 127.0.0.1");
if (!String.IsNullOrEmpty(referer)) request.Referer = referer; // set referer if given
if (cc != null) request.CookieContainer = cc; // set cookies if given
if (proxy != null) request.Proxy = proxy; // send the request over a proxy if given
try
{
response = (HttpWebResponse)request.GetResponse();
}
catch (WebException webEx)
{
Log.Debug(webEx.Message);
response = (HttpWebResponse)webEx.Response; // if the server returns a 404 or similar .net will throw a WebException that has the response
}
Stream responseStream;
if (response == null) return "";
if (response.ContentEncoding.ToLower().Contains("gzip"))
responseStream = new System.IO.Compression.GZipStream(response.GetResponseStream(), System.IO.Compression.CompressionMode.Decompress);
else if (response.ContentEncoding.ToLower().Contains("deflate"))
responseStream = new System.IO.Compression.DeflateStream(response.GetResponseStream(), System.IO.Compression.CompressionMode.Decompress);
else
responseStream = response.GetResponseStream();
// UTF8 is the default encoding as fallback
Encoding responseEncoding = Encoding.UTF8;
// try to get the response encoding if one was specified and neither forceUTF8 nor encoding were set as parameters
if (!forceUTF8 && encoding == null && response.CharacterSet != null && !String.IsNullOrEmpty(response.CharacterSet.Trim())) responseEncoding = Encoding.GetEncoding(response.CharacterSet.Trim(new char[] { ' ', '"' }));
// the caller did specify a forced encoding
if (encoding != null) responseEncoding = encoding;
// the caller wants to force UTF8
if (forceUTF8) responseEncoding = Encoding.UTF8;
using (StreamReader reader = new StreamReader(responseStream, responseEncoding, true))
{
string str = reader.ReadToEnd().Trim();
// add to cache if HTTP Status was 200 and we got more than 500 bytes (might just be an errorpage otherwise)
if (response.StatusCode == HttpStatusCode.OK && str.Length > 500) WebCache.Instance[requestCRC] = str;
return str;
}
}
finally
{
if (response != null) ((IDisposable)response).Dispose();
// disable unsafe header parsing if it was enabled
if (allowUnsafeHeader) Helpers.DotNetFrameworkHelper.SetAllowUnsafeHeaderParsing(false);
}
}
//
// FindServicePoint - Query using an Uri for a given server point
//
/// <include file='doc\ServicePointManager.uex' path='docs/doc[@for="ServicePointManager.FindServicePoint2"]/*' />
/// <devdoc>
/// <para>Findes an existing <see cref='System.Net.ServicePoint'/> or creates a new <see cref='System.Net.ServicePoint'/> to manage communications to the specified <see cref='System.Uri'/>
/// instance.</para>
/// </devdoc>
public static ServicePoint FindServicePoint(Uri address, IWebProxy proxy) {
if (address==null) {
throw new ArgumentNullException("address");
}
GlobalLog.Enter("ServicePointManager::FindServicePoint() address:" + address.ToString());
string tempEntry;
bool isProxyServicePoint = false;
ScavengeIdleServicePoints();
//
// find proxy info, and then switch on proxy
//
if (proxy!=null && !proxy.IsBypassed(address)) {
// use proxy support
// rework address
Uri proxyAddress = proxy.GetProxy(address);
if (proxyAddress.Scheme != Uri.UriSchemeHttps && proxyAddress.Scheme != Uri.UriSchemeHttp) {
Exception exception = new NotSupportedException(SR.GetString(SR.net_proxyschemenotsupported, proxyAddress.Scheme));
GlobalLog.LeaveException("ServicePointManager::FindServicePoint() proxy has unsupported scheme:" + proxyAddress.Scheme.ToString(), exception);
throw exception;
}
address = proxyAddress;
isProxyServicePoint = true;
//
// Search for the correct proxy host,
// then match its acutal host by using ConnectionGroups
// which are located on the actual ServicePoint.
//
tempEntry = MakeQueryString(proxyAddress);
}
else {
//
// Typical Host lookup
//
tempEntry = MakeQueryString(address);
}
//
// lookup service point in the table
//
ServicePoint servicePoint = null;
lock (s_ServicePointTable) {
//
// once we grab the lock, check if it wasn't already added
//
WeakReference servicePointReference = (WeakReference) s_ServicePointTable[tempEntry];
if ( servicePointReference != null ) {
servicePoint = (ServicePoint)servicePointReference.Target;
}
if (servicePoint == null) {
//
// lookup failure or timeout, we need to create a new ServicePoint
//
if (s_MaxServicePoints<=0 || s_ServicePointTable.Count<s_MaxServicePoints) {
//
// Determine Connection Limit
//
int connectionLimit = InternalConnectionLimit;
string schemeHostPort = MakeQueryString(address);
if (ConfigTable.ContainsKey(schemeHostPort) ) {
connectionLimit = (int) ConfigTable[schemeHostPort];
}
// Note: we don't check permissions to access proxy.
// Rather, we should protect proxy property from being changed
servicePoint = new ServicePoint(address, s_MaxServicePointIdleTime, connectionLimit);
servicePointReference = new WeakReference(servicePoint);
// only set this when created, donates a proxy, statt Server
servicePoint.InternalProxyServicePoint = isProxyServicePoint;
s_ServicePointTable[tempEntry] = servicePointReference;
}
else {
Exception exception = new InvalidOperationException(SR.GetString(SR.net_maxsrvpoints));
GlobalLog.LeaveException("ServicePointManager::FindServicePoint() reached the limit count:" + s_ServicePointTable.Count.ToString() + " limit:" + s_MaxServicePoints.ToString(), exception);
throw exception;
}
}
} // lock
GlobalLog.Leave("ServicePointManager::FindServicePoint() servicePoint#" + ValidationHelper.HashString(servicePoint));
return servicePoint;
}
public static ServicePoint FindServicePoint (Uri address, IWebProxy proxy)
{
if (address == null)
throw new ArgumentNullException ("address");
RecycleServicePoints ();
bool usesProxy = false;
bool useConnect = false;
if (proxy != null && !proxy.IsBypassed(address)) {
usesProxy = true;
bool isSecure = address.Scheme == "https";
address = proxy.GetProxy (address);
if (address.Scheme != "http" && !isSecure)
throw new NotSupportedException ("Proxy scheme not supported.");
if (isSecure && address.Scheme == "http")
useConnect = true;
}
address = new Uri (address.Scheme + "://" + address.Authority);
ServicePoint sp = null;
lock (servicePoints) {
SPKey key = new SPKey (address, useConnect);
sp = servicePoints [key] as ServicePoint;
if (sp != null)
return sp;
if (maxServicePoints > 0 && servicePoints.Count >= maxServicePoints)
throw new InvalidOperationException ("maximum number of service points reached");
string addr = address.ToString ();
#if NET_2_1
int limit = defaultConnectionLimit;
#else
int limit = (int) manager.GetMaxConnections (addr);
#endif
sp = new ServicePoint (address, limit, maxServicePointIdleTime);
sp.Expect100Continue = expectContinue;
sp.UseNagleAlgorithm = useNagle;
sp.UsesProxy = usesProxy;
sp.UseConnect = useConnect;
sp.SetTcpKeepAlive (tcp_keepalive, tcp_keepalive_time, tcp_keepalive_interval);
servicePoints.Add (key, sp);
}
return sp;
}
/// <summary>
/// This method attaches credentials to the web proxy object.
/// </summary>
/// <param name="proxy">The proxy to attach credentials to.</param>
/// <param name="webCallUrl">The url for the web call.</param>
/// <param name="oldProxyState">The current state fo the web call.</param>
/// <param name="newProxyState">The new state for the web call.</param>
/// <param name="okToPrompt">Prompt user for credentials if they are not available.</param>
public WebProxyState PrepareWebProxy(IWebProxy proxy, string webCallUrl, WebProxyState oldProxyState, bool okToPrompt)
{
WebProxyState newProxyState = WebProxyState.Abort;
if (string.IsNullOrEmpty(webCallUrl)) {
Debug.Fail("PrepareWebProxy called with an empty WebCallUrl.");
webCallUrl = "http://go.microsoft.com/fwlink/?LinkId=81947";
}
// Get the web proxy url for the the current web call.
Uri webCallProxy = null;
if (proxy != null) {
webCallProxy = proxy.GetProxy(new Uri(webCallUrl));
}
if ((proxy != null) && (webCallProxy != null)) {
// get proxy url.
string proxyUrl = webCallProxy.Host;
if (string.IsNullOrEmpty(currentProxyUrl)) {
currentProxyUrl = proxyUrl;
}
switch (oldProxyState) {
case WebProxyState.NoCredentials:
// Add the default credentials only if there aren't any credentials attached to
// the DefaultWebProxy. If the first calls attaches the correct credentials, the
// second call will just use them, instead of overwriting it with the default credentials.
// This avoids multiple web calls. Note that state is transitioned to DefaultCredentials
// instead of CachedCredentials. This ensures that web calls be tried with the
// cached credentials if the currently attached credentials don't result in successful web call.
if ((proxy.Credentials == null)) {
proxy.Credentials = CredentialCache.DefaultCredentials;
}
newProxyState = WebProxyState.DefaultCredentials;
break;
case WebProxyState.DefaultCredentials:
// Fetch cached credentials if they are null or if the proxy url has changed.
if ((cachedCredentials == null) ||
!string.Equals(currentProxyUrl, proxyUrl, StringComparison.OrdinalIgnoreCase)) {
cachedCredentials = GetCachedCredentials(proxyUrl);
}
if (cachedCredentials != null) {
proxy.Credentials = cachedCredentials;
newProxyState = WebProxyState.CachedCredentials;
break;
}
// Proceed to next step if cached credentials are not available.
goto case WebProxyState.CachedCredentials;
case WebProxyState.CachedCredentials:
case WebProxyState.PromptForCredentials:
if (okToPrompt) {
if (DialogResult.OK == PromptForCredentials(proxyUrl)) {
proxy.Credentials = cachedCredentials;
newProxyState = WebProxyState.PromptForCredentials;
} else {
newProxyState = WebProxyState.Abort;
}
} else {
newProxyState = WebProxyState.Abort;
}
break;
case WebProxyState.Abort:
throw new InvalidOperationException();
default:
throw new ArgumentException(string.Empty, "oldProxyState");
}
} else {
// No proxy for the webCallUrl scenario.
if (oldProxyState == WebProxyState.NoCredentials) {
// if it is the first call, change the state and let the web call proceed.
newProxyState = WebProxyState.DefaultCredentials;
} else {
Debug.Fail("This method is called a second time when 407 occurs. A 407 shouldn't have occurred as there is no default proxy.");
// We dont have a good idea of the circumstances under which
// WebProxy might be null for a url. To be safe, for VS 2005 SP1,
// we will just return the abort state, instead of throwing
// an exception. Abort state will ensure that no further procesing
// occurs and we will not bring down the app.
// throw new InvalidOperationException();
newProxyState = WebProxyState.Abort;
}
}
return newProxyState;
}
internal static ServicePoint FindServicePoint(Uri address, IWebProxy proxy, out ProxyChain chain, ref HttpAbortDelegate abortDelegate, ref int abortState)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
bool isProxyServicePoint = false;
chain = null;
Uri current = null;
if ((proxy != null) && !address.IsLoopback)
{
IAutoWebProxy proxy2 = proxy as IAutoWebProxy;
if (proxy2 != null)
{
chain = proxy2.GetProxies(address);
abortDelegate = chain.HttpAbortDelegate;
try
{
Thread.MemoryBarrier();
if (abortState != 0)
{
Exception exception = new WebException(NetRes.GetWebStatusString(WebExceptionStatus.RequestCanceled), WebExceptionStatus.RequestCanceled);
throw exception;
}
chain.Enumerator.MoveNext();
current = chain.Enumerator.Current;
}
finally
{
abortDelegate = null;
}
}
else if (!proxy.IsBypassed(address))
{
current = proxy.GetProxy(address);
}
if (current != null)
{
address = current;
isProxyServicePoint = true;
}
}
return FindServicePointHelper(address, isProxyServicePoint);
}
// If abortState becomes non-zero, the attempt to find a service point has been aborted.
internal static ServicePoint FindServicePoint(Uri address, IWebProxy proxy, out ProxyChain chain, ref HttpAbortDelegate abortDelegate, ref int abortState)
{
if (address==null) {
throw new ArgumentNullException("address");
}
GlobalLog.Enter("ServicePointManager::FindServicePoint() address:" + address.ToString());
bool isProxyServicePoint = false;
chain = null;
//
// find proxy info, and then switch on proxy
//
Uri proxyAddress = null;
if (proxy!=null && !address.IsLoopback) {
IAutoWebProxy autoProxy = proxy as IAutoWebProxy;
if (autoProxy != null)
{
chain = autoProxy.GetProxies(address);
// Set up our ability to abort this MoveNext call. Note that the current implementations of ProxyChain will only
// take time on the first call, so this is the only place we do this. If a new ProxyChain takes time in later
// calls, this logic should be copied to other places MoveNext is called.
GlobalLog.Assert(abortDelegate == null, "ServicePointManager::FindServicePoint()|AbortDelegate already set.");
abortDelegate = chain.HttpAbortDelegate;
try
{
Thread.MemoryBarrier();
if (abortState != 0)
{
Exception exception = new WebException(NetRes.GetWebStatusString(WebExceptionStatus.RequestCanceled), WebExceptionStatus.RequestCanceled);
GlobalLog.LeaveException("ServicePointManager::FindServicePoint() Request aborted before proxy lookup.", exception);
throw exception;
}
if (!chain.Enumerator.MoveNext())
{
GlobalLog.Assert("ServicePointManager::FindServicePoint()|GetProxies() returned zero proxies.");
/*
Exception exception = new WebException(NetRes.GetWebStatusString(WebExceptionStatus.RequestProhibitedByProxy), WebExceptionStatus.RequestProhibitedByProxy);
GlobalLog.LeaveException("ServicePointManager::FindServicePoint() Proxy prevented request.", exception);
throw exception;
*/
}
proxyAddress = chain.Enumerator.Current;
}
finally
{
abortDelegate = null;
}
}
else if (!proxy.IsBypassed(address))
{
// use proxy support
// rework address
proxyAddress = proxy.GetProxy(address);
}
// null means DIRECT
if (proxyAddress!=null) {
address = proxyAddress;
isProxyServicePoint = true;
}
}
ServicePoint servicePoint = FindServicePointHelper(address, isProxyServicePoint);
GlobalLog.Leave("ServicePointManager::FindServicePoint() servicePoint#" + ValidationHelper.HashString(servicePoint));
return servicePoint;
}
private string MyGetWebData(Uri uri, string postData = null, CookieContainer cookies = null, string referer = null, IWebProxy proxy = null, bool forceUTF8 = false, bool allowUnsafeHeader = false, string userAgent = null, Encoding encoding = null, NameValueCollection headers = null, bool cache = true)
{
// do not use the cache when doing a POST
if (postData != null) cache = false;
// set a few headers if none were given
if (headers == null)
{
headers = new NameValueCollection();
headers.Add("Accept", "*/*"); // accept any content type
headers.Add("User-Agent", userAgent ?? OnlineVideoSettings.Instance.UserAgent); // set the default OnlineVideos UserAgent when none specified
}
if (referer != null) headers.Set("Referer", referer);
HttpWebResponse response = null;
try
{
// build a CRC of the url and all headers + proxy + cookies for caching
string requestCRC = Helpers.EncryptionUtils.CalculateCRC32(
string.Format("{0}{1}{2}{3}",
uri.ToString(),
headers != null ? string.Join("&", (from item in headers.AllKeys select string.Format("{0}={1}", item, headers[item])).ToArray()) : "",
proxy != null ? proxy.GetProxy(uri).AbsoluteUri : "",
cookies != null ? cookies.GetCookieHeader(uri) : ""));
// try cache first
string cachedData = cache ? WebCache.Instance[requestCRC] : null;
Log.Debug("GetWebData-{2}{1}: '{0}'", uri.ToString(), cachedData != null ? " (cached)" : "", postData != null ? "POST" : "GET");
if (cachedData != null) return cachedData;
// build the request
if (allowUnsafeHeader) Helpers.DotNetFrameworkHelper.SetAllowUnsafeHeaderParsing(true);
HttpWebRequest request = WebRequest.Create(uri) as HttpWebRequest;
if (request == null) return "";
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate; // turn on automatic decompression of both formats (adds header "AcceptEncoding: gzip,deflate" to the request)
if (cookies != null) request.CookieContainer = cookies; // set cookies if given
if (proxy != null) request.Proxy = proxy; // send the request over a proxy if given
if (headers != null) // set user defined headers
{
foreach (var headerName in headers.AllKeys)
{
switch (headerName.ToLowerInvariant())
{
case "accept":
request.Accept = headers[headerName];
break;
case "user-agent":
request.UserAgent = headers[headerName];
break;
case "referer":
request.Referer = headers[headerName];
break;
default:
request.Headers.Set(headerName, headers[headerName]);
break;
}
}
}
if (postData != null)
{
byte[] data = encoding != null ? encoding.GetBytes(postData) : Encoding.UTF8.GetBytes(postData);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
request.ProtocolVersion = HttpVersion.Version10;
Stream requestStream = request.GetRequestStream();
requestStream.Write(data, 0, data.Length);
requestStream.Close();
}
// request the data
try
{
response = (HttpWebResponse)request.GetResponse();
}
catch (WebException webEx)
{
Log.Debug(webEx.Message);
response = (HttpWebResponse)webEx.Response; // if the server returns a 404 or similar .net will throw a WebException that has the response
}
Stream responseStream = response.GetResponseStream();
// UTF8 is the default encoding as fallback
Encoding responseEncoding = Encoding.UTF8;
// try to get the response encoding if one was specified and neither forceUTF8 nor encoding were set as parameters
if (!forceUTF8 && encoding == null && response.CharacterSet != null && !String.IsNullOrEmpty(response.CharacterSet.Trim())) responseEncoding = Encoding.GetEncoding(response.CharacterSet.Trim(new char[] { ' ', '"' }));
// the caller did specify a forced encoding
if (encoding != null) responseEncoding = encoding;
// the caller wants to force UTF8
if (forceUTF8) responseEncoding = Encoding.UTF8;
using (StreamReader reader = new StreamReader(responseStream, responseEncoding, true))
{
string str = reader.ReadToEnd().Trim();
// add to cache if HTTP Status was 200 and we got more than 500 bytes (might just be an errorpage otherwise)
if (cache && response.StatusCode == HttpStatusCode.OK && str.Length > 500) WebCache.Instance[requestCRC] = str;
return str;
}
}
finally
{
if (response != null) ((IDisposable)response).Dispose();
// disable unsafe header parsing if it was enabled
if (allowUnsafeHeader) Helpers.DotNetFrameworkHelper.SetAllowUnsafeHeaderParsing(false);
}
}
/// <summary>
/// This function will connect a stream to a uri (host and port),
/// negotiating proxies and SSL
/// </summary>
/// <param name="uri"></param>
/// <param name="timeout_ms">Timeout, in ms. 0 for no timeout.</param>
/// <returns></returns>
public static Stream ConnectStream(Uri uri, IWebProxy proxy, bool nodelay, int timeout_ms)
{
IMockWebProxy mockProxy = proxy != null ? proxy as IMockWebProxy : null;
if (mockProxy != null)
return mockProxy.GetStream(uri);
Stream stream;
bool useProxy = proxy != null && !proxy.IsBypassed(uri);
if (useProxy)
{
Uri proxyURI = proxy.GetProxy(uri);
stream = ConnectSocket(proxyURI, nodelay, timeout_ms);
}
else
{
stream = ConnectSocket(uri, nodelay, timeout_ms);
}
try
{
if (useProxy)
{
string line = String.Format("CONNECT {0}:{1} HTTP/1.0", uri.Host, uri.Port);
WriteLine(line, stream);
WriteLine(stream);
ReadHttpHeaders(ref stream, proxy, nodelay, timeout_ms);
}
if (UseSSL(uri))
{
SslStream sslStream = new SslStream(stream, false,
new RemoteCertificateValidationCallback(ValidateServerCertificate), null);
sslStream.AuthenticateAsClient("");
stream = sslStream;
}
return stream;
}
catch
{
stream.Close();
throw;
}
}
private static bool ProxyAddressIfNecessary(ref Uri address, IWebProxy proxy)
{
if (proxy != null && !address.IsLoopback)
{
Uri proxyAddress = proxy.GetProxy(address);
if (proxyAddress != null)
{
if (proxyAddress.Scheme != Uri.UriSchemeHttp)
{
throw new NotSupportedException(SR.Format(SR.net_proxyschemenotsupported, address.Scheme));
}
address = proxyAddress;
return true;
}
}
return false;
}
public static ServicePoint FindServicePoint(Uri address, IWebProxy proxy)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
var usesProxy = false;
if (proxy != null && !proxy.IsBypassed(address))
{
usesProxy = true;
var isSecure = address.Scheme == Uri.UriSchemeHttps;
address = proxy.GetProxy(address);
if (address.Scheme != Uri.UriSchemeHttp && !isSecure)
{
throw new NotSupportedException("Proxy scheme not supported.");
}
}
var key = MakeQueryString(address, usesProxy);
return _servicePoints.GetOrAdd(key, new Lazy<ServicePoint>(() =>
{
if (_maxServicePoints > 0 && _servicePoints.Count >= _maxServicePoints)
{
throw new InvalidOperationException("maximum number of service points reached");
}
return new ServicePoint(address, _defaultConnectionLimit, key, usesProxy);
}, false)).Value;
}
