public async Task <string> GetClientIpAddress()
{
if (!string.IsNullOrEmpty(ipAddress))
{
return(ipAddress);
}
HttpResponseMessage response;
try
{
response = await base.GetAsync("https://api.ipify.org/?format=json");
}
catch (Exception e)
{
Status = ProxyStatus.Invalid;
throw new Exception("Proxy is not valid");
}
if (!response.IsSuccessStatusCode)
{
Status = ProxyStatus.Invalid;
throw new Exception("Proxy is not valid");
}
var content = await response.Content.ReadAsStringAsync();
ipAddress = JsonConvert.DeserializeObject <ProxyIp>(content).IpAddress;
return(content);
}
/// <summary>
/// Добавление прокси
/// </summary>
/// <param name="key"></param>
/// <param name="status"></param>
/// <param name="dateCheck"></param>
public void UpdateStatus(string key, ProxyStatus status, DateTime dateCheck)
{
try
{
if (_locker.TryEnterWriteLock(LOCK_TIMEOUT))
{
if (_proxies.ContainsKey(key))
{
var proxyInfo = _proxies[key];
proxyInfo.Status = status;
proxyInfo.LastCheck = dateCheck;
_proxies[key] = proxyInfo;
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
if (_locker.IsWriteLockHeld)
{
_locker.ExitWriteLock();
}
}
}
public data(ProxyStatus status, string proxy, string ip, string country, string city, int speed, int uptime)
{
this.status = status;
this.proxy = proxy;
this.ip = ip;
this.country = country;
this.city = city;
this.speed = speed;
this.uptime = uptime;
}
public void SetProxyStatus(Proxy proxy, ProxyStatus proxyStatus)
{
var itemData = GetData(proxy);
itemData.Status = proxyStatus;
if (proxyStatus == ProxyStatus.Broken)
{
itemData.BrokenOn = DateTime.UtcNow;
}
}
public Proxy(ProxyStatus status, string proxies, string ip, string country, string city, double speed, double uptime)
{
_status = status;
Proxies = proxies;
Ip = ip;
Country = country;
City = city;
Speed = speed;
Uptime = uptime;
}
static SystemProxy()
{
try
{
using var proxy = new ProxyService();
Old = proxy.Query();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
}
public bool Load(string str)
{
if (string.IsNullOrEmpty(str))
{
return(false);
}
var list = str.Split('|');
if (list.Length < 4)
{
return(false);
}
Address = list[0];
int port;
if (!int.TryParse(list[1], out port))
{
return(false);
}
Port = port;
int type;
if (!int.TryParse(list[2], out type))
{
return(false);
}
Type = (ProxyType)type;
DateCreated = DateTime.Parse(list[3]);
LastCheck = DateTime.Parse(list[4]);
if (list.Length > 4)
{
int status;
if (int.TryParse(list[5], out status))
{
Status = (ProxyStatus)status;
}
else
{
Status = ProxyStatus.Add;
}
}
return(true);
}
public void OnChatsDisposed(IChatHandler chatHandler1, IChatHandler chatHandler2, TwoChatsHandlerStatus twoChatsHandlerStatus)
{
ProxyStatus proxyStatus = (twoChatsHandlerStatus == TwoChatsHandlerStatus.FatalError) ? ProxyStatus.Dead : ProxyStatus.Free;
if (chatHandler1 != null)
{
var ch1 = chatHandler1 as ChatHandler_WrapperForChatvdvoemBasicWorker;
CacheHandle(ch1.CacheFolder, twoChatsHandlerStatus == TwoChatsHandlerStatus.FatalError);
if (ch1.ProxyStr != null)
{
_ProxyDispatcher.SetProxyStatus(ch1.ProxyStr, proxyStatus);
}
}
if (chatHandler2 != null)
{
var ch2 = chatHandler2 as ChatHandler_WrapperForChatvdvoemBasicWorker;
CacheHandle(ch2.CacheFolder, twoChatsHandlerStatus == TwoChatsHandlerStatus.FatalError);
if (ch2.ProxyStr != null)
{
_ProxyDispatcher.SetProxyStatus(ch2.ProxyStr, proxyStatus);
}
}
}
private static void handleSetProxyStatus(string[] args)
{
if (args.Length > 1)
{
try
{
ProxyStatus status = (ProxyStatus)Enum.Parse(typeof(ProxyStatus), args[1], true);
foreach (IBrowserProxy proxy in getProxies())
{
proxy.Status = status;
}
printProxyStatus();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
printHelp();
}
}
else
{
printHelp();
}
}
private ProxyResult Finish(ProxyStatus proxyStatus)
{
_result.ProxyStatus = proxyStatus;
_result.Elapsed = DateTime.Now - _start;
return(_result);
}
/// <summary> /// /// </summary> /// <param name="proxyStatus"></param> /// <returns></returns> private bool IsProxyAvailable(ProxyStatus proxyStatus) => !proxyStatus.IsLocked && proxyStatus.NextAvailability <= DateTime.Now.AddMilliseconds(_random.Next(-DELAY_JITTER, DELAY_JITTER));
public void UnLock(short searchEngineId, short regionId, int proxyId,
CrawlResultID crawlResultID)
{
lock (_locker)
{
// TODO(zvp): Should we handle this differently ?
if (!_addedInitStatuses)
{
InitializeProxyStatuses();
}
Tuple <short, short> key = new Tuple <short, short>(searchEngineId, regionId);
if (_proxyStatuses.ContainsKey(key) &&
_proxyStatuses[key].ContainsKey(proxyId))
{
ProxyStatus status = _proxyStatuses[key][proxyId];
status.IsLocked = false; // unlock proxy
// update next availability based on crawl result
switch (crawlResultID)
{
case CrawlResultID.Success:
{
Data.Entities.ProxyMultiplier multipler = _proxyMultiplierRepo.Select(
searchEngineId, regionId, proxyId);
if (multipler != null)
{
status.NextAvailability = DateTime.Now.AddSeconds(multipler.Multiplier);
}
else
{
Data.Entities.SearchString searchString = _searchStringRepo
.Select(searchEngineId, regionId);
if (searchString != null)
{
status.NextAvailability = DateTime.Now.AddSeconds(searchString.DelayMultiplier);
}
else
{
status.NextAvailability = DateTime.Now.AddMinutes(SUCCESS_FALLBACK_DELAY);
}
}
break;
}
case CrawlResultID.Failure:
status.NextAvailability = DateTime.Now.AddMinutes(
FAILURE_DELAY);
break;
case CrawlResultID.Captcha:
status.NextAvailability = DateTime.Now.AddMinutes(
CAPTCHA_DELAY);
break;
case CrawlResultID.Block:
status.NextAvailability = DateTime.Now.AddMinutes(
BLOCK_DELAY);
break;
}
}
else
{
// throw ?
}
}
}
public void SetProxyStatus(string proxy, ProxyStatus proxyStatus)
{
throw new NotImplementedException();
}
public static void Init(string confPath)
{
allConf = new ConcurrentDictionary <string, List <string> > (StringComparer.OrdinalIgnoreCase);
confFilePath = confPath;
ReadAll();
ImportUsers();
Console.WriteLine("find user(s): {0}", EagleTunnelUser.users.Count);
encryptionKey = 0x22;
if (allConf.ContainsKey("data-key"))
{
if (byte.TryParse(allConf["data-key"][0], out byte tmpByte))
{
encryptionKey = tmpByte;
}
}
if (allConf.ContainsKey("user"))
{
if (EagleTunnelUser.TryParse(allConf["user"][0], out EagleTunnelUser user, true))
{
localUser = user;
}
}
if (LocalUser != null)
{
Console.WriteLine("User: {0}", LocalUser.ID);
}
PipeTimeOut = 0;
if (Conf.allConf.ContainsKey("timeout"))
{
if (int.TryParse(Conf.allConf["timeout"][0], out int timeout))
{
PipeTimeOut = timeout;
}
}
Console.WriteLine("TimeOut(ms): {0} (0 means infinite timeout period.)", PipeTimeOut);
maxClientsCount = 500;
if (allConf.ContainsKey("worker"))
{
if (int.TryParse(allConf["worker"][0], out int workerCount))
{
maxClientsCount = workerCount;
}
}
Console.WriteLine("worker: {0}", maxClientsCount);
try
{
List <string> remoteAddressStrs = Conf.allConf["relayer"];
remoteAddresses = CreateEndPoints(remoteAddressStrs);
}
catch (KeyNotFoundException)
{
Console.WriteLine("Warning: Relayer not found.");
}
if (RemoteAddresses != null)
{
Console.WriteLine("Count of Relayer: {0}", RemoteAddresses.Length);
}
try
{
List <string> localAddressStrs = Conf.allConf["listen"];
localAddresses = CreateEndPoints(localAddressStrs);
}
catch (KeyNotFoundException)
{
Console.WriteLine("Warning: Listen not found");
}
if (allConf.ContainsKey("socks"))
{
if (allConf["socks"][0] == "on")
{
enableSOCKS = true;
}
}
Console.WriteLine("SOCKS Switch: {0}", EnableSOCKS.ToString());
if (allConf.ContainsKey("http"))
{
if (allConf["http"][0] == "on")
{
enableHTTP = true;
}
}
Console.WriteLine("HTTP Switch: {0}", EnableHTTP.ToString());
if (allConf.ContainsKey("et"))
{
if (allConf["et"][0] == "on")
{
enableEagleTunnel = true;
}
}
Console.WriteLine("Eagle Tunnel Switch: {0}", EnableEagleTunnel.ToString());
if (allConf.ContainsKey("proxy-status"))
{
proxyStatus = (ProxyStatus)Enum.Parse(typeof(Conf.ProxyStatus),
allConf["proxy-status"][0].ToUpper());
}
else
{
proxyStatus = ProxyStatus.ENABLE; // default enable proxy
}
Console.WriteLine("Proxy Status: {0}", proxyStatus.ToString());
ImportList("whitelist_domain.txt", out whitelist_domain);
ImportList("whitelist_ip.txt", out whitelist_ip);
ImportList("blacklist_ip.txt", out blacklist_ip);
ImportHosts(out hosts);
}
