private static bool ResolvByProxy(EagleTunnelArgs e)
{
bool result = false;
if (CreateTunnel(out Tunnel tunnel))
{
string req = EagleTunnelHandler.EagleTunnelRequestType.DNS.ToString();
req += " " + e.Domain;
bool done = tunnel.WriteR(req);
if (done)
{
string reply = tunnel.ReadStringR();
if (!string.IsNullOrEmpty(reply) && reply != "nok")
{
if (IPAddress.TryParse(reply, out IPAddress ip))
{
e.IP = ip;
result = true;
}
}
}
tunnel.Close();
}
return(result);
}
private static bool HandleTCPReq(ByteBuffer request, Tunnel tunnel)
{
bool result = false;
if (request != null && tunnel != null)
{
IPAddress ip = GetIP(request);
int port = GetPort(request);
if (ip != null && port != 0)
{
IPEndPoint reqIPEP = new IPEndPoint(ip, port);
string reply;
EagleTunnelArgs e = new EagleTunnelArgs();
e.EndPoint = reqIPEP;
e.tunnel = tunnel;
if (EagleTunnelSender.Handle(
EagleTunnelHandler.EagleTunnelRequestType.TCP, e))
{
if (Conf.LocalUser != null)
{
Conf.LocalUser.AddTunnel(tunnel);
}
reply = "\u0005\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000";
}
else
{
reply = "\u0005\u0001\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000";
}
result = tunnel.WriteL(reply);
}
}
return(result);
}
private static void DNSReqSender(Tunnel tunnel, EagleTunnelArgs e)
{
if (tunnel != null && e != null)
{
e.IP = null;
if (e.Domain != null)
{
if (IPAddress.TryParse(e.Domain, out IPAddress ip0))
{
;
// e.Domain is IP but not domain
e.IP = ip0;
}
else
{
string req = EagleTunnelHandler.EagleTunnelRequestType.DNS.ToString();
req += " " + e.Domain;
bool done = tunnel.WriteR(req);
if (done)
{
string reply = tunnel.ReadStringR();
if (!string.IsNullOrEmpty(reply) && reply != "nok")
{
if (IPAddress.TryParse(reply, out IPAddress ip1))
{
e.IP = ip1;
}
}
}
}
}
}
}
private static void SendLOCATIONReq(EagleTunnelArgs e)
{
string ip2Resolv = e.IP.ToString();
// local cache resolv firstly
if (EagleTunnelHandler.insideCache.ContainsKey(ip2Resolv))
{
e.EnableProxy = !EagleTunnelHandler.insideCache[ip2Resolv];
e.Success = true;
}
else
{
// req remote
if (CheckIfInsideByRemote(ip2Resolv, out bool inside))
{
e.EnableProxy = !inside;
EagleTunnelHandler.insideCache.TryAdd(ip2Resolv, inside);
e.Success = true;
}
else
{
EagleTunnelHandler.ips2Resolv.Enqueue(ip2Resolv);
}
}
}
public static bool Handle(EagleTunnelHandler.EagleTunnelRequestType type, EagleTunnelArgs e)
{
bool result = false;
if (e != null)
{
switch (type)
{
case EagleTunnelHandler.EagleTunnelRequestType.DNS:
SendDNSReq(e);
break;
case EagleTunnelHandler.EagleTunnelRequestType.TCP:
result = SendTCPReq(e);
break;
case EagleTunnelHandler.EagleTunnelRequestType.LOCATION:
SendLOCATIONReq(e);
break;
case EagleTunnelHandler.EagleTunnelRequestType.Unknown:
default:
break;
}
}
return(result);
}
public static IPAddress GetIP(ByteBuffer request)
{
IPAddress ip;
int destype = request[3];
string ip_str;
switch (destype)
{
case 1:
ip_str = request[4].ToString();
ip_str += '.' + request[5].ToString();
ip_str += '.' + request[6].ToString();
ip_str += '.' + request[7].ToString();
if (IPAddress.TryParse(ip_str, out IPAddress ipa0))
{
ip = ipa0;
}
else
{
ip = null;
}
break;
case 3:
int len = request[4];
char[] hostChars = new char[len];
for (int i = 0; i < len; ++i)
{
hostChars[i] = (char)request[5 + i];
}
string host = new string (hostChars);
// if host is real ip but not domain name
if (IPAddress.TryParse(host, out IPAddress ipa))
{
ip = ipa;
}
else
{
EagleTunnelArgs e = new EagleTunnelArgs();
e.Domain = host;
EagleTunnelSender.Handle(
EagleTunnelHandler.EagleTunnelRequestType.DNS, e);
ip = e.IP;
}
break;
default:
ip = null;
break;
}
return(ip);
}
private static bool SendTCPReq(EagleTunnelArgs e)
{
bool result = false;
if (e != null && e.EndPoint != null)
{
if (e.EnableProxy)
{
result = ConnectByProxy(e);
}
else
{
result = DirectConnect(e);
}
}
return(result);
}
private static Tunnel HandleTCPReq(byte[] request, Socket socket2Client)
{
Tunnel result = null;
if (request != null && socket2Client != null)
{
IPAddress ip = GetIP(request);
int port = GetPort(request);
if (ip != null && port != 0)
{
IPEndPoint reqIPEP = new IPEndPoint(ip, port);
string reply;
EagleTunnelArgs e = new EagleTunnelArgs();
e.EndPoint = reqIPEP;
result = EagleTunnelSender.Handle(
EagleTunnelHandler.EagleTunnelRequestType.TCP, e);
if (result != null)
{
reply = "\u0005\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000";
}
else
{
reply = "\u0005\u0001\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000";
}
byte[] buffer = Encoding.ASCII.GetBytes(reply);
int written;
try {
written = socket2Client.Send(buffer);
} catch { written = 0; }
if (result != null)
{
if (written > 0)
{
result.SocketL = socket2Client;
}
else
{
result.Close();
result = null;
}
}
}
}
return(result);
}
private static bool ResolvDomain(EagleTunnelArgs e)
{
bool result;
if (e.EnableProxy)
{
result = ResolvByProxy(e);
}
else
{
result = ResolvByLocal(e);
if (!result)
{
result = ResolvByProxy(e);
}
}
return(result);
}
public static Tunnel Handle(
string firstMsg, System.Net.Sockets.Socket socket2Client)
{
Tunnel result = null;
if (firstMsg != null && socket2Client != null)
{
if (HTTPReqArgs.TryParse(firstMsg, out HTTPReqArgs e0))
{
IPEndPoint reqEP = HTTPReqArgs.GetIPEndPoint(e0);
EagleTunnelArgs e1 = new EagleTunnelArgs();
e1.EndPoint = reqEP;
Tunnel tunnel = EagleTunnelSender.Handle(
EagleTunnelHandler.EagleTunnelRequestType.TCP, e1);
if (tunnel != null)
{
tunnel.SocketL = socket2Client;
bool done;
if (e0.HTTP_Request_Type == HTTPRequestType.CONNECT)
{
// HTTPS: reply web client;
string re443 = "HTTP/1.1 200 Connection Established\r\n\r\n";
done = tunnel.WriteL(re443);
}
else
{
// HTTP: relay new request to web server
string newReq = HTTPReqArgs.CreateNewRequest(firstMsg);
done = tunnel.WriteR(newReq);
}
if (done)
{
result = tunnel;
}
else
{
tunnel.Close();
}
}
}
}
return(result);
}
private static bool CheckEnableProxy(IPAddress ip)
{
bool result = true;
if (ip != null)
{
EagleTunnelArgs e = new EagleTunnelArgs();
e.IP = ip;
EagleTunnelSender.Handle(
EagleTunnelHandler.EagleTunnelRequestType.LOCATION,
e
);
if (e.Success)
{
result = e.EnableProxy;
}
}
return(result);
}
public static Tunnel Handle(EagleTunnelHandler.EagleTunnelRequestType type, EagleTunnelArgs e)
{
Tunnel result = null;
if (type != EagleTunnelHandler.EagleTunnelRequestType.Unknown &&
e != null)
{
IPEndPoint ipeOfServer = Conf.GetRemoteIPEndPoint();
Socket socket2Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try {
socket2Server.Connect(ipeOfServer);
} catch { socket2Server = null; }
Tunnel tunnel = CheckVersion(socket2Server);
if (tunnel != null)
{
bool done = CheckUser(tunnel);
if (done)
{
switch (type)
{
case EagleTunnelHandler.EagleTunnelRequestType.DNS:
DNSReqSender(tunnel, e);
done = false; // no need to continue;
break;
case EagleTunnelHandler.EagleTunnelRequestType.TCP:
done = TCPReqSender(tunnel, e);
break;
}
}
if (done)
{
result = tunnel;
}
else
{
tunnel.Close();
}
}
}
return(result);
}
private static void SendDNSReq(EagleTunnelArgs e)
{
if (e != null)
{
if (e.Domain != null)
{
if (Conf.hosts.ContainsKey(e.Domain))
{
e.IP = Conf.hosts[e.Domain];
e.Success = true;
}
else
{
if (EagleTunnelHandler.dnsCaches.ContainsKey(e.Domain))
{
if (!EagleTunnelHandler.dnsCaches[e.Domain].IsDead)
{
e.IP = EagleTunnelHandler.dnsCaches[e.Domain].IP;
e.Success = true;
}
else
{
if (ResolvDomain(e))
{
EagleTunnelHandler.dnsCaches[e.Domain].IP = e.IP;
e.Success = true;
}
}
}
else
{
if (ResolvDomain(e))
{
DnsCache cache = new DnsCache(e.Domain, e.IP, Conf.DnsCacheTtl);
EagleTunnelHandler.dnsCaches.TryAdd(e.Domain, cache);
e.Success = true;
}
}
}
}
}
}
private static bool TCPReqSender(Tunnel tunnel, EagleTunnelArgs e)
{
bool result = false;
if (tunnel != null && e != null)
{
if (e.EndPoint != null)
{
string req = EagleTunnelHandler.EagleTunnelRequestType.TCP.ToString();
req += ' ' + e.EndPoint.Address.ToString();
req += ' ' + e.EndPoint.Port.ToString();
bool done = tunnel.WriteR(req);
if (done)
{
string reply = tunnel.ReadStringR();
result = reply == "ok";
}
}
}
return(result);
}
// public static string CreateNewRequest (string oldRequest) {
// string newReq = "";
// string[] lines = oldRequest.Replace ("\r\n", "\n").Split ('\n');
// string[] args = lines[0].Split (' ');
// if (args.Length >= 2) {
// string des = args[1];
// Uri uri = new Uri (des);
// if (uri.HostNameType != UriHostNameType.Unknown) {
// string line = args[0];
// line += ' ' + uri.AbsolutePath;
// newReq = line;
// if (args.Length >= 3) {
// newReq += ' ' + args[2];
// for (int i = 1; i < lines.Length; ++i) {
// line = lines[i];
// newReq += "\r\n" + line;
// }
// }
// }
// }
// return newReq;
// }
public static IPEndPoint GetIPEndPoint(HTTPReqArgs e0)
{
IPEndPoint result = null;
if (e0 != null)
{
if (e0.Host != null & e0.Port != 0)
{
// resolv ip of domain name by EagleTunnel Sender
EagleTunnelArgs e1 = new EagleTunnelArgs();
e1.Domain = e0.Host;
EagleTunnelSender.Handle(
EagleTunnelHandler.EagleTunnelRequestType.DNS, e1);
if (e1.IP != null)
{
// resolv successfully
result = new IPEndPoint(e1.IP, e0.Port);
}
}
}
return(result);
}
private static bool ConnectByProxy(EagleTunnelArgs e)
{
bool succeed = false;
if (e.tunnel != null)
{
Tunnel tunnel = e.tunnel;
if (Connect2Relayer(tunnel))
{
string req = EagleTunnelHandler.EagleTunnelRequestType.TCP.ToString();
req += ' ' + e.EndPoint.Address.ToString();
req += ' ' + e.EndPoint.Port.ToString();
bool done = tunnel.WriteR(req);
if (done)
{
string reply = tunnel.ReadStringR();
succeed = reply == "ok";
}
}
}
return(succeed);
}
private static bool DirectConnect(EagleTunnelArgs e)
{
bool result = false;
Socket socket2Server = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
try
{
socket2Server.Connect(e.EndPoint);
}
catch (SocketException)
{
socket2Server.Close();
}
if (socket2Server.Connected)
{
e.tunnel.SocketR = socket2Server;
result = true;
}
return(result);
}
public static bool Handle(string firstMsg, Tunnel tunnel)
{
bool result = false;
if (firstMsg != null && tunnel != null)
{
if (HTTPReqArgs.TryParse(firstMsg, out HTTPReqArgs e0))
{
IPEndPoint reqEP = HTTPReqArgs.GetIPEndPoint(e0);
EagleTunnelArgs e1 = new EagleTunnelArgs();
e1.EndPoint = reqEP;
e1.tunnel = tunnel;
if (EagleTunnelSender.Handle(
EagleTunnelHandler.EagleTunnelRequestType.TCP, e1))
{
if (Conf.LocalUser != null)
{
Conf.LocalUser.AddTunnel(tunnel);
}
if (e0.HTTP_Request_Type == HTTPRequestType.CONNECT)
{
// HTTPS: reply web client;
string re443 = "HTTP/1.1 200 Connection Established\r\n\r\n";
result = tunnel.WriteL(re443);
}
else
{
// HTTP: relay new request to web server
string newReq = HTTPReqArgs.CreateNewRequest(firstMsg);
result = tunnel.WriteR(newReq);
}
}
}
}
return(result);
}
private static bool ResolvByLocal(EagleTunnelArgs e)
{
bool result = false;
IPHostEntry iphe;
try
{
iphe = Dns.GetHostEntry(e.Domain);
}
catch { iphe = null; }
if (iphe != null)
{
foreach (IPAddress tmp in iphe.AddressList)
{
if (tmp.AddressFamily == AddressFamily.InterNetwork)
{
e.IP = tmp;
result = true;
break;
}
}
}
return(result);
}
