static void Main(string[] args)
{
byte clientId = 0;
var serv = new TunnelServer(clientId, new IPEndPoint(IPAddress.Loopback, 8899));
var client = new TunnelClient(clientId, Utils.DetectHost(), new IPEndPoint(IPAddress.Loopback, 8888));
GlobalEventLoop.Instance().EventLoop();
}
private ConnectionInfo Virtualize(string connectionString, string sshTunnelInfo)
{
lock (LockObject)
{
if (Clients.ContainsKey(connectionString))
{
return(Clients[connectionString]);
}
var url = new MySqlConnectionStringBuilder(connectionString);
string finalConnectionString = null;
if (!TunnelClient.GetInstance().ForwardedPortInfoExists(url.Server, Convert.ToUInt32(url.Port)))
{
if (Ping(connectionString))
{
finalConnectionString = connectionString;
}
}
if (finalConnectionString == null)
{
var portInfo = TunnelClient.GetInstance()
.GetForwardedPortInfo(
new TunnelRequest
{
RemoteHost = url.Server,
RemotePort = Convert.ToUInt32(url.Port),
SshTunnelInfo = sshTunnelInfo
});
var alternateBuilder =
new MySqlConnectionStringBuilder(connectionString)
{
Port = portInfo.BoundPort,
Server = portInfo.BoundHost
};
var newConnectionString = alternateBuilder.ToString();
if (Ping(newConnectionString))
{
finalConnectionString = newConnectionString;
}
else
{
throw new Exception("Can't connect to MySQL");
}
}
var connectionInfo =
new ConnectionInfo
{
VirtualizedConnectionString = finalConnectionString
};
Clients[connectionString] = connectionInfo;
return(connectionInfo);
}
}
private ConnectionInfo Virtualize(string connectionString, string sshTunnelInfo)
{
lock (Mutex)
{
if (Clients.ContainsKey(connectionString))
{
return(Clients[connectionString]);
}
var virtualizedConnectionString = connectionString;
var url = MongoUrl.Create(connectionString);
IMongoClient client = null;
if (!TunnelClient.GetInstance()
.ForwardedPortInfoExists(url.Server.Host, Convert.ToUInt32(url.Server.Port)))
{
client = new MongoClient(connectionString);
if (!Ping(client))
{
client = null;
}
}
if (client == null)
{
var tunnelRequest = new TunnelRequest
{
RemoteHost = url.Server.Host,
RemotePort = Convert.ToUInt32(url.Server.Port), SshTunnelInfo = sshTunnelInfo
};
var portInfo = TunnelClient.GetInstance().GetForwardedPortInfo(tunnelRequest);
var newConnectionString = string.Format("mongodb://{2}{3}:{0}/{1}", portInfo.BoundPort,
url.DatabaseName,
string.IsNullOrWhiteSpace(url.Username)
? string.Empty
: string.Concat(url.Username, ":", url.Password, "@"), portInfo.BoundHost);
virtualizedConnectionString = newConnectionString;
client = new MongoClient(newConnectionString);
if (!Ping(client))
{
throw new Exception("Can't connect to MongoDb");
}
}
var connectionInfo =
new ConnectionInfo
{
VirtualizedConnectionString = virtualizedConnectionString,
Client = client
};
Clients[connectionString] = connectionInfo;
return(connectionInfo);
}
}
static void Main(string[] args)
{
IPAddress remoteAddr = IPAddress.Parse(args[0]);
byte thisClientId = 1;
byte thisServerId = 2;
if (args[1] == "1")
{
var temp = thisClientId;
thisClientId = thisServerId;
thisServerId = temp;
}
var serv = new TunnelServer(thisServerId, new IPEndPoint(IPAddress.Loopback, 8899));
var client = new TunnelClient(thisClientId, remoteAddr, new IPEndPoint(IPAddress.Loopback, 8888));
GlobalEventLoop.Instance().EventLoop();
}
public void SetState(bool state)
{
if (state == currentState)
{
return;
}
if (state)
{
clientConnected = -1;
tunnelSettings = new TunnelSettings();
tunnelSettings.Load("TunnelSettings.txt");
guiData.statistics = new Statistics();
udpServer = new UDPServer(tunnelSettings, guiData.statistics);
if (tunnelSettings.tunnelServer == "")
{
tunnelServer = new TunnelServer(tunnelSettings, udpServer);
}
else
{
tunnelClient = new TunnelClient(tunnelSettings, udpServer);
}
currentState = state;
}
else
{
currentState = state;
if (tunnelClient != null)
{
tunnelClient.Stop();
tunnelClient = null;
}
tunnelServer = null;
udpServer.Stop();
udpServer = null;
tunnelSettings = null;
guiData.labelText = "Disconnected";
guiData.iconName = "gtk-no";
UpdateGUI();
}
}
public new void WritePacket(G2Protocol protocol, G2Frame root, byte name)
{
byte[] payload = new byte[PAYLOAD_SIZE];
BitConverter.GetBytes(UserID).CopyTo(payload, 0);
BitConverter.GetBytes(ClientID).CopyTo(payload, 8);
BitConverter.GetBytes(UdpPort).CopyTo(payload, 10);
BitConverter.GetBytes(TcpPort).CopyTo(payload, 12);
G2Frame address = protocol.WritePacket(root, name, payload);
protocol.WritePacket(address, Packet_IP, IP.GetAddressBytes());
if (TunnelServer != null)
{
TunnelServer.WritePacket(protocol, address, Packet_Server);
}
if (TunnelClient != null)
{
protocol.WritePacket(address, Packet_Client, TunnelClient.ToBytes());
}
}
static int Main(string[] args)
{
Settings settings = new Settings();
settings.isServer = false;
settings.ipEndpointStr = "minecraft1.52k.de:25560";
settings.listenPort = 0;
int serverCount = 0;
foreach (string arg in args)
{
if (serverCount == 2)
{
settings.ipEndpointStr = arg;
}
if (serverCount == 1)
{
settings.listenPort = Int32.Parse(arg);
}
if (serverCount > 0)
{
serverCount--;
continue;
}
if (arg == "--server")
{
settings.isServer = true;
serverCount = 2;
}
if (arg == "--ipv6")
{
settings.ipv4only = false;
settings.ipv6only = true;
}
if (arg == "--ipv4")
{
settings.ipv4only = true;
settings.ipv6only = false;
}
}
//ParseIPEndpoint
string addPart = settings.ipEndpointStr.Substring(0, settings.ipEndpointStr.LastIndexOf(":"));
//Trim [] parts;
if (addPart.Contains("["))
{
addPart.Substring(1, addPart.Length - 2);
}
if (!IPAddress.TryParse(addPart, out IPAddress ipAddr))
{
IPAddress[] addrs = null;
try
{
addrs = Dns.GetHostAddresses(addPart);
}
catch (Exception e)
{
Console.WriteLine("DNS error: " + e.Message);
return(-1);
}
foreach (IPAddress testIP in addrs)
{
if (!settings.ipv4only && !settings.ipv6only)
{
ipAddr = testIP;
break;
}
if (settings.ipv4only && testIP.AddressFamily == AddressFamily.InterNetwork)
{
ipAddr = testIP;
break;
}
if (settings.ipv6only && testIP.AddressFamily == AddressFamily.InterNetworkV6)
{
ipAddr = testIP;
break;
}
}
}
if (ipAddr == null)
{
Console.WriteLine("DNS returned no usable results");
return(-2);
}
string portPart = settings.ipEndpointStr.Substring(settings.ipEndpointStr.LastIndexOf(":") + 1);
settings.ipEndpoint = new IPEndPoint(ipAddr, Int32.Parse(portPart));
if (settings.listenPort == 0)
{
settings.listenPort = Int32.Parse(portPart);
}
//Init
running = true;
NetworkHandler networkHandler = new NetworkHandler();
UDPTunnel udpt = new UDPTunnel(networkHandler, settings);
if (settings.isServer)
{
TunnelServer ts = new TunnelServer(networkHandler, settings);
Console.WriteLine("Press Ctrl+C key to quit");
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs e) =>
{
running = false;
ts.Shutdown();
udpt.Shutdown();
};
DisplayMain(networkHandler);
}
else
{
TunnelClient tc = new TunnelClient(networkHandler, settings);
Console.WriteLine("Press Ctrl+C to quit");
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs e) =>
{
running = false;
tc.Shutdown();
udpt.Shutdown();
};
DisplayMain(networkHandler);
}
return(0);
}
public void SetClient(TunnelClient tunnelClient)
{
this.tunnelClient = tunnelClient;
}
public void Start()
{
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetHeightRequest(new Empty());
var resp = ServerClient.GetHeight(request);
TunnelClient.TunnelGetHeightResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetHeightRequest(new Empty());
var resp = ServerClient.SetHeight(request);
TunnelClient.TunnelSetHeightResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetLeftRequest(new Empty());
var resp = ServerClient.GetLeft(request);
TunnelClient.TunnelGetLeftResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetLeftRequest(new Empty());
var resp = ServerClient.SetLeft(request);
TunnelClient.TunnelSetLeftResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetLocationRequest(new Empty());
var resp = ServerClient.GetLocation(request);
TunnelClient.TunnelGetLocationResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetLocationRequest(new Empty());
var resp = ServerClient.SetLocation(request);
TunnelClient.TunnelSetLocationResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetMonitorsRequest(new Empty());
var resp = ServerClient.GetMonitors(request);
TunnelClient.TunnelGetMonitorsResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetResizableRequest(new Empty());
var resp = ServerClient.GetResizable(request);
TunnelClient.TunnelGetResizableResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetResizableRequest(new Empty());
var resp = ServerClient.SetResizable(request);
TunnelClient.TunnelSetResizableResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetScreenDpiRequest(new Empty());
var resp = ServerClient.GetScreenDpi(request);
TunnelClient.TunnelGetScreenDpiResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSendMessageRequest(new Empty());
var resp = ServerClient.SendMessage(request);
TunnelClient.TunnelSendMessageResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetIconFileRequest(new Empty());
var resp = ServerClient.SetIconFile(request);
TunnelClient.TunnelSetIconFileResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelShowRequest(new Empty());
var resp = ServerClient.Show(request);
TunnelClient.TunnelShowResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelShowMessageRequest(new Empty());
var resp = ServerClient.ShowMessage(request);
TunnelClient.TunnelShowMessageResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetSizeRequest(new Empty());
var resp = ServerClient.GetSize(request);
TunnelClient.TunnelGetSizeResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetSizeRequest(new Empty());
var resp = ServerClient.SetSize(request);
TunnelClient.TunnelSetSizeResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetTitleRequest(new Empty());
var resp = ServerClient.GetTitle(request);
TunnelClient.TunnelGetTitleResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetTitleRequest(new Empty());
var resp = ServerClient.SetTitle(request);
TunnelClient.TunnelSetTitleResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetTopRequest(new Empty());
var resp = ServerClient.GetTop(request);
TunnelClient.TunnelGetTopResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetTopRequest(new Empty());
var resp = ServerClient.SetTop(request);
TunnelClient.TunnelSetTopResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetTopmostRequest(new Empty());
var resp = ServerClient.GetTopmost(request);
TunnelClient.TunnelGetTopmostResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetTopmostRequest(new Empty());
var resp = ServerClient.SetTopmost(request);
TunnelClient.TunnelSetTopmostResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelNavigateToLocalFileRequest(new Empty());
var resp = ServerClient.NavigateToLocalFile(request);
TunnelClient.TunnelNavigateToLocalFileResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelNavigateToStringRequest(new Empty());
var resp = ServerClient.NavigateToString(request);
TunnelClient.TunnelNavigateToStringResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelNavigateToUrlRequest(new Empty());
var resp = ServerClient.NavigateToUrl(request);
TunnelClient.TunnelNavigateToUrlResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelWaitForExitRequest(new Empty());
var resp = ServerClient.WaitForExit(request);
TunnelClient.TunnelWaitForExitResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelGetWidthRequest(new Empty());
var resp = ServerClient.GetWidth(request);
TunnelClient.TunnelGetWidthResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelSetWidthRequest(new Empty());
var resp = ServerClient.SetWidth(request);
TunnelClient.TunnelSetWidthResponse(resp);
}
});
Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelCreateWebWindowRequest(new Empty());
var respStream = ServerClient.CreateWebWindow(request);
Task.Run(async() =>
{
await foreach (var resp in respStream.ResponseStream.ReadAllAsync())
{
TunnelClient.TunnelCreateWebWindowResponse(resp);
}
});
}
});
Task.Run(async() =>
{
while (true)
{
var respStream = ServerClient.FileReader();
var task = Task.Run(() =>
{
while (true)
{
var request = TunnelClient.TunnelFileReaderRequest(new Empty());
respStream.RequestStream.WriteAsync(request);
}
});
await foreach (var resp in respStream.ResponseStream.ReadAllAsync())
{
TunnelClient.TunnelFileReaderResponse(resp);
}
}
});
}
