Guest User

Untitled

a guest
Jul 31st, 2013
398
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.IO.Ports;
  5. using System.Net;
  6. using System.Net.Sockets;
  7. using System.Runtime.Remoting.Messaging;
  8. using System.Threading;
  9. using Craft.Net;
  10. using Jayrock.Json;
  11.  
  12. namespace tman0.CraftProxy
  13. {
  14.     class Program
  15.     {
  16.         static void Main(string[] args)
  17.         {
  18.            
  19.             try
  20.             {
  21.                 if (!File.Exists("config.json")) SetUpConfig();
  22.                 FileStream config = File.OpenRead("config.json");
  23.                 JsonReader configreader = new JsonTextReader(new StreamReader(config));
  24.                 configreader.Read();
  25.                 Configuration.Import(configreader);
  26.                 config.Close();
  27.                
  28.             }
  29.             catch (JsonException ex)
  30.             {
  31.                 Console.WriteLine("[Config] There was an error reading the configuration file.");
  32.                 Console.WriteLine(ex.ToString());
  33.                 Console.WriteLine("[Config] You can delete config.json to generate a new one if needed.");
  34.                 Console.WriteLine("Please press enter to continue...");
  35.                 Console.ReadLine();
  36.                 return;
  37.             }
  38.             catch (IOException ex)
  39.             {
  40.                 Console.WriteLine("[Config] There was an error opening/reading the configuration file.");
  41.                 Console.WriteLine(ex.ToString());
  42.                 Console.WriteLine("[Config] You can delete config.json to generate a new one if needed.");
  43.                 Console.WriteLine("Please press enter to continue.");
  44.                 Console.ReadLine();
  45.                 return;
  46.             }
  47.             try
  48.             {
  49.                 JsonObject listensettings = (JsonObject)Configuration["listen"];
  50.                 IPEndPoint ListeningAddress = new IPEndPoint(IPAddress.Parse((listensettings["ip"]).ToString()),
  51.                     ((JsonNumber)listensettings["port"]).ToInt16());
  52.                 theListener = new TcpListener(ListeningAddress);
  53.                 Console.WriteLine("Listening on " + ListeningAddress);
  54.                 theListener.Start();
  55.                 LoadRoutes();
  56.                 Console.WriteLine("[Config] Successfully loaded {0} routes.", Routes.Count);
  57.                 theListener.BeginAcceptTcpClient(OnConnected, null);
  58.             }
  59.             catch (Exception ex)
  60.             {
  61.                 Console.WriteLine("[Server] A server error occured.");
  62.                 Console.WriteLine(ex.ToString());
  63.                 Console.WriteLine("Please press enter to continue.");
  64.                 Console.ReadLine();
  65.                 return;
  66.                 throw;
  67.             }
  68.             while (true) ;
  69.         }
  70.  
  71.         public static JsonObject Configuration = new JsonObject();
  72.         private static TcpListener theListener;
  73.  
  74.         private static ManualResetEvent connected = new ManualResetEvent(false);
  75.  
  76.         private static Dictionary<string, Route> Routes = new Dictionary<string, Route>();
  77.  
  78.         private static void Proxy(TcpClient theClient, TcpClient theServer, IPacket handshake, bool isPing)
  79.         {
  80.             try
  81.             {
  82.                 bool ClientOpen = true;
  83.                 bool ServerOpen = true;
  84.  
  85.                 var client = theClient.GetStream();
  86.                 var server = theServer.GetStream();
  87.                 var clientStream = new MinecraftStream(client);
  88.                 var serverStream = new MinecraftStream(server);
  89.                 /*if (isPing)
  90.                 {
  91.                     new ServerListPingPacket().WritePacket(serverStream);
  92.                     handshake.WritePacket(serverStream);
  93.                     Thread.Sleep(1);
  94.                         Console.WriteLine("[Proxy] Relaying data Server -> Client");
  95.                         while (!server.DataAvailable) ;
  96.                         while (server.DataAvailable)
  97.                         {
  98.                             client.Write(new[] {(byte) server.ReadByte()}, 0, 1);
  99.                         }
  100.                     theClient.Client.Disconnect(true);
  101.                     theServer.Client.Disconnect(true);
  102.                     return;
  103.                 }
  104.                 else */
  105.                 handshake.WritePacket(serverStream);
  106.                  
  107.                 while (ClientOpen && ServerOpen)
  108.                 {
  109.                     if (client.DataAvailable)
  110.                     {
  111.                         Console.WriteLine("[Proxy] Relaying data Client -> Server");
  112.                         while (client.DataAvailable)
  113.                         {
  114.                             server.Write(new[] {(byte) client.ReadByte()}, 0, 1);
  115.                         }
  116.                     }
  117.                     else if (server.DataAvailable)
  118.                     {
  119.                         Console.WriteLine("[Proxy] Relaying data Server -> Client");
  120.                         while (server.DataAvailable)
  121.                         {
  122.                             client.Write(new[] {(byte) server.ReadByte()}, 0, 1);
  123.                         }
  124.                         if (handshake is ServerListPingPacket2) break;
  125.                     }
  126.                     else
  127.                     {
  128.                         // Detect if client disconnected
  129.                         if (theClient.Client.Poll(0, SelectMode.SelectRead))
  130.                         {
  131.                             byte[] buff = new byte[1];
  132.                             if (theClient.Client.Receive(buff, SocketFlags.Peek) == 0)
  133.                             {
  134.                                 // Client disconnected
  135.                                 ClientOpen = false;
  136.                             }
  137.                         }
  138.  
  139.                         // Detect if server disconnected
  140.                         if (theServer.Client.Poll(0, SelectMode.SelectRead))
  141.                         {
  142.                             byte[] buff = new byte[1];
  143.                             if (theServer.Client.Receive(buff, SocketFlags.Peek) == 0)
  144.                             {
  145.                                 // Server disconnected
  146.                                 ServerOpen = false;
  147.                             }
  148.                         }
  149.                     }
  150.                     Thread.Sleep(1);
  151.                 }
  152.             }
  153.             catch (Exception ex)
  154.             {
  155.                 if(handshake is HandshakePacket)
  156.                 Console.WriteLine("[Proxy] Client {0} disconnected abnormally.", ((HandshakePacket)handshake).Username);
  157.                 else
  158.                     Console.WriteLine("[Proxy] Client {0} disconnected abnormally.", theClient.Client.RemoteEndPoint);
  159.                 Console.WriteLine(ex.ToString());
  160.             }
  161.             finally
  162.             {
  163.                 if (handshake is HandshakePacket)
  164.                 Console.WriteLine("[Proxy] Client {0} ({1}) disconnected.", ((HandshakePacket)handshake).Username,
  165.                     theClient.Client.RemoteEndPoint);
  166.                 else
  167.                     Console.WriteLine("[Proxy] Client {0} disconnected. (Server Ping)", theClient.Client.RemoteEndPoint);
  168.                 theClient.Client.Disconnect(true);
  169.                 theServer.Client.Disconnect(true);
  170.                 Thread.CurrentThread.Abort();
  171.             }
  172.         }
  173.  
  174.         private static void OnConnected(IAsyncResult res)
  175.         {
  176.             TcpClient client = theListener.EndAcceptTcpClient(res);
  177.             Thread.CurrentThread.Name = "CraftProxy Client " + client.Client.RemoteEndPoint;
  178.             Console.WriteLine("[Server] Client connected");
  179.             var clstream = new MinecraftStream(client.GetStream());
  180.            
  181.             while (!client.GetStream().DataAvailable) ;
  182.             int ID = clstream.ReadUInt8();
  183.             /*if (ID == ServerListPingPacket.PacketId) // We're being pinged
  184.             {
  185.                 new ServerListPingPacket().ReadPacket(clstream);
  186.                 clstream.ReadUInt8();
  187.                 var ping = new ServerListPingPacket2();
  188.                 ping.ReadPacket(clstream);
  189.                 Route correctRoute = FindMatch(ping.ServerHostname, ping.ServerPort);
  190.                 Console.WriteLine("[Server] Received ping request from {0} (route {1})", client.Client.RemoteEndPoint, correctRoute.Name);
  191.                 TcpClient server = new TcpClient();
  192.                 server.Connect(correctRoute.To, correctRoute.ToPort);
  193.                 Proxy(client, server, ping, true);
  194.             }
  195.             else*/
  196.             if (ID == HandshakePacket.PacketId) // We're being joined
  197.             {
  198.                 var handshake = new HandshakePacket();
  199.                 handshake.ReadPacket(clstream);
  200.                 Console.WriteLine("[Server] Client {0} connected to {1}:{2} from {3}", handshake.Username,
  201.                     handshake.ServerHostname, handshake.ServerPort, client.Client.RemoteEndPoint);
  202.                 Console.WriteLine("[Proxy] Starting proxy for {0}...", handshake.Username);
  203.                 Route correctRoute = FindMatch(handshake.ServerHostname, handshake.ServerPort);
  204.                 TcpClient server = new TcpClient();
  205.                 server.Connect(correctRoute.To, correctRoute.ToPort);
  206.                 Console.WriteLine("[Proxy] Proxying {0} (route {1}) to {2}:{3}", handshake.Username, correctRoute.Name,
  207.                     correctRoute.To, correctRoute.ToPort);
  208.                 theListener.Start();
  209.                 theListener.BeginAcceptTcpClient(OnConnected, null);
  210.                 Proxy(client, server, handshake, false);
  211.             }
  212.             else
  213.             {
  214.                 Console.WriteLine("[Server] Invalid packet received from " + client.Client.RemoteEndPoint);
  215.                 client.Close();
  216.                 theListener.Start();
  217.                 theListener.BeginAcceptTcpClient(OnConnected, null);
  218.             }
  219.            
  220.         }
  221.  
  222.         private static void SetUpConfig()
  223.         {
  224.             Console.WriteLine("[Config] Creating a new config file...");
  225.             if (File.Exists("config.json")) File.Delete("config.json");
  226.             JsonObject document = new JsonObject();
  227.             JsonObject listenerconfig = new JsonObject();
  228.             listenerconfig.Add("ip", "0.0.0.0");
  229.             listenerconfig.Add("port", 25565);
  230.  
  231.             document.Add("listen", listenerconfig);
  232.  
  233.             JsonObject routeconfig = new JsonObject();
  234.             JsonObject route = new JsonObject();
  235.             route.Add("from", "mc.myexampledomain.com");
  236.             route.Add("from_port", 25565);
  237.             route.Add("to", "s1.myserverhost.com");
  238.             route.Add("to_port", 9203);
  239.             route.Add("default", true);
  240.  
  241.             JsonObject route2 = new JsonObject();
  242.             route2.Add("from", "ftb.myexampledomain.com");
  243.             route2.Add("from_port", 25565);
  244.             route2.Add("to", "s2.myserverhost.com");
  245.             route2.Add("to_port", 9298);
  246.             route2.Add("default", false);
  247.  
  248.             routeconfig.Add("My First Server", route);
  249.             routeconfig.Add("My Second Server", route2);
  250.             document.Add("routes", routeconfig);
  251.             /*StringWriter toReturn = new StringWriter();
  252.             JsonTextWriter w = new JsonTextWriter(toReturn);
  253.             w.PrettyPrint = true;
  254.             document.Export(w);*/
  255.  
  256.             FileStream s = File.OpenWrite("config.json");
  257.             StreamWriter configfile = new StreamWriter(s);
  258.             JsonTextWriter f = new JsonTextWriter(configfile);
  259.             f.PrettyPrint = true;
  260.             document.Export(f);
  261.             configfile.Flush();
  262.             s.Flush();
  263.             s.Close();
  264.  
  265.             //Console.WriteLine(toReturn.ToString());
  266.         }
  267.  
  268.         private static void LoadRoutes()
  269.         {
  270.             foreach (JsonMember o in (JsonObject)Configuration["routes"])
  271.             {
  272.                 JsonObject route = (JsonObject) o.Value;
  273.                 Route newroute = new Route
  274.                 {
  275.                     Default = (bool)route["default"],
  276.                     From = route["from"].ToString(),
  277.                     FromPort = ((JsonNumber)route["from_port"]).ToInt16(),
  278.                     To = route["to"].ToString(),
  279.                     ToPort = ((JsonNumber)route["to_port"]).ToInt16(),
  280.                     Name = o.Name
  281.                 };
  282.                 Routes.Add(o.Name, newroute);
  283.  
  284.                 Console.WriteLine("[Config] Loaded new route '{0}' (default: {1}).", newroute.Name, newroute.Default);
  285.                 Console.WriteLine("\tFrom: {0}:{1}", newroute.From, newroute.FromPort);
  286.                 Console.WriteLine("\tTo: {0}:{1}", newroute.To, newroute.ToPort);
  287.             }
  288.         }
  289.  
  290.         private static Route FindMatch(string From, int FromPort)
  291.         {
  292.             foreach (KeyValuePair<string, Route> p in Routes)
  293.             {
  294.                 if (p.Value.IsMatch(From, FromPort))
  295.                     return p.Value;
  296.             }
  297.             return null;
  298.         }
  299.     }
  300. }
RAW Paste Data