Пример #1
0
        private GeoIP getResponse()
        {
            GeoIPServiceSoapClient client = new GeoIPServiceSoapClient();
            GeoIP response = client.GetGeoIP(ip);

            return(response);
        }
Пример #2
0
        public ServerListReport(IPAddress listen, ushort port, Action <string, string> log, Action <string, string> logError)
        {
            Log      = log;
            LogError = logError;

            GeoIP.Initialize(log, Category);

            Servers = new ConcurrentDictionary <string, GameServer>();

            Thread = new Thread(StartServer)
            {
                Name = "Server Reporting Socket Thread"
            };
            Thread.Start(new AddressInfo()
            {
                Address = listen,
                Port    = port
            });

            new Thread(StartCleanup)
            {
                Name = "Server Reporting Cleanup Thread"
            }.Start();

            new Thread(StartDynamicInfoReload)
            {
                Name = "Dynamic Info Reload Thread"
            }.Start();
        }
Пример #3
0
        public AnonymousProfileTooltipLogic(Widget widget, OrderManager orderManager, Session.Client client)
        {
            var address             = LobbyUtils.GetExternalIP(client, orderManager);
            var cachedDescriptiveIP = address ?? "Unknown IP";

            var nameLabel = widget.Get <LabelWidget>("NAME");
            var nameFont  = Game.Renderer.Fonts[nameLabel.Font];

            widget.Bounds.Width = nameFont.Measure(nameLabel.Text).X + 2 * nameLabel.Bounds.Left;

            var ipLabel = widget.Get <LabelWidget>("IP");

            ipLabel.GetText = () => cachedDescriptiveIP;

            var locationLabel       = widget.Get <LabelWidget>("LOCATION");
            var cachedCountryLookup = GeoIP.LookupCountry(address);

            locationLabel.GetText = () => cachedCountryLookup;

            if (client.IsAdmin)
            {
                var adminLabel = widget.Get("GAME_ADMIN");
                adminLabel.IsVisible  = () => client.IsAdmin;
                widget.Bounds.Height += adminLabel.Bounds.Height;
            }
        }
Пример #4
0
        private void CheckGeoIP(string sURL, ref string sIP, ref string sCountry, ref string sCountryCode)
        {
            string    domainCode;
            Utilities utilities = Globals.G_Utilities;

            lock (utilities)
            {
                sIP        = Globals.G_Utilities.UrlToIP(sURL);
                domainCode = Globals.G_Utilities.GetDomainCode(sURL);
            }
            GeoIP oip = Globals.G_GEOIP;

            lock (oip)
            {
                if (Globals.G_GEOIP.CountryCodeExist(domainCode))
                {
                    sCountry     = Globals.G_GEOIP.CountryNameByCode(domainCode);
                    sCountryCode = Globals.G_GEOIP.LookupCountryCode(sIP);
                }
                else
                {
                    sCountry     = Globals.G_GEOIP.LookupCountry(sIP);
                    sCountryCode = Globals.G_GEOIP.LookupCountryCode(sIP);
                }
            }
        }
Пример #5
0
 private static void timeOffsetCheck(IFlyMiningEntityDI fDb)
 {
     try
     {
         if (fDb.UserProfile2.Any(t =>
                                  (t.TimeZone == null || (t.TimeZone != null && t.TimeZone == "")) && t.userIP != "::1"))
         {
             List <UserProfile2> userlist = fDb.UserProfile2.Where(t =>
                                                                   (t.TimeZone == null || (t.TimeZone != null && t.TimeZone == "")) && t.userIP != "::1").ToList();
             foreach (UserProfile2 user in userlist)
             {
                 GeoData myLocation = GeoIP.GetCountryInfo(user.userIP);
                 if (myLocation == null || myLocation.timeZone == "")
                 {
                     myLocation = GeoIP.GetCountryInfoCheck(user.userIP);
                 }
                 if (myLocation != null)
                 {
                     user.TimeOffset = myLocation.timeOffset;
                     user.TimeZone   = myLocation.timeZone;
                     if (user.TimeZone.Length >= 50)
                     {
                         user.TimeZone = myLocation.timeZone.Substring(0, 50);
                     }
                 }
             }
             fDb.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         Logger.AddLogRecord("timeOffsetCheck " + Convert.ToString(ex));
     }
 }
Пример #6
0
        public LoginServer(IPAddress listen, ushort clientManagerPort, ushort searchManagerPort, Action <string, string> log, Action <string, string> logError)
        {
            ServicePointManager.SetTcpKeepAlive(true, 60 * 1000 * 10, 1000);

            Log      = log;
            LogError = logError;

            GeoIP.Initialize(log, Category);

            ThreadClientManager = new Thread(StartServerClientManager)
            {
                Name = "Login Thread Client Manager"
            };
            ThreadClientManager.Start(new AddressInfo()
            {
                Address = listen,
                Port    = clientManagerPort
            });

            ThreadSearchManager = new Thread(StartServerSearchManager)
            {
                Name = "Login Thread Search Manager"
            };
            ThreadSearchManager.Start(new AddressInfo()
            {
                Address = listen,
                Port    = searchManagerPort
            });
        }
        private async Task CargarItems()
        {
            if (!Plugin.Connectivity.CrossConnectivity.Current.IsConnected)
            {
                await DisplayAlert("Advertencia", "No hay internet", "Cerrar");

                return;
            }
            IsBusy = true;

            Items.Clear();

            var Ip = IPAddress.Text;

            if (Ip == "" || Ip == null)
            {
                await DisplayAlert("Digitar IP", "Debe digitar un dirección IP", "Cerrar");
            }
            else
            {
                var ciudades = await CargarDatos(Ip);

                GeoIP geoData = new GeoIP();

                if (ciudades.Status == "fail")
                {
                    ciudades.Mensaje = "La ip: " + ciudades.IpAdress + " no se pudo encontrar";
                    geoData.Mensaje  = ciudades.Mensaje;
                }
                else
                {
                    var latitud  = double.Parse(ciudades.Latitud, CultureInfo.InvariantCulture);
                    var longitud = double.Parse(ciudades.Longitud, CultureInfo.InvariantCulture);
                    var position = new Position(latitud, longitud); // Latitude, Longitude
                    var pin      = new Pin
                    {
                        Type     = PinType.Place,
                        Position = position,
                        Label    = "custom pin",
                        Address  = "custom detail info"
                    };
                    geoData.Pais    = ciudades.Pais;
                    geoData.Ciudad  = ciudades.Ciudad;
                    geoData.Region  = ciudades.Region;
                    geoData.ISP     = ciudades.ISP;
                    geoData.Zip     = ciudades.Zip;
                    geoData.Mensaje = "Ip encontrada: " + ciudades.IpAdress;

                    Mapa.MoveToRegion(MapSpan.FromCenterAndRadius(
                                          position,
                                          Distance.FromMiles(0.3)));
                    Mapa.Pins.Add(pin);
                }

                Items.Add(geoData);
            }

            IsBusy = false;
        }
Пример #8
0
 public static void GeoIPRoute(IEndpointRouteBuilder endpoints)
 {
     endpoints.Map(Config.IpPerfix,
                   async context => await context.WriteResponseAsync(RealIP.Get(context).ToString()));
     endpoints.Map(Config.IpPerfix + "/source", async context =>
     {
         var jObject = new JObject
         {
             { "IP", RealIP.Get(context).ToString() }, { "UserHostAddress", context.Connection.RemoteIpAddress.ToString() }
         };
         if (context.Request.Headers.TryGetValue("X-Forwarded-For", out var xFwdValue))
         {
             jObject.Add("X-Forwarded-For", xFwdValue.ToString());
         }
         if (context.Request.Headers.TryGetValue("CF-Connecting-IP", out var xCfValue))
         {
             jObject.Add("CF-Connecting-IP", xCfValue.ToString());
         }
         if (context.Request.Headers.TryGetValue("X-Real-IP", out var xRealValue))
         {
             jObject.Add("X-Real-IP", xRealValue.ToString());
         }
         await context.WriteResponseAsync(jObject.ToString(), type: "application/json");
     });
     endpoints.Map(Config.IpPerfix + "/json", async context =>
     {
         var(responseAsn, responseCity) = GeoIP.GetAsnCityValueTuple(context.Request.Query.ContainsKey("ip")
             ? IPAddress.Parse(context.Request.Query["ip"].ToString())
             : RealIP.Get(context));
         var jObject = new JObject
         {
             { "IP", responseAsn.IPAddress },
             { "ASN", responseAsn.AutonomousSystemNumber },
             { "Organization", responseAsn.AutonomousSystemOrganization },
             { "CountryCode", responseCity.Country.IsoCode },
             { "Country", responseCity.Country.Name }
         };
         if (!string.IsNullOrWhiteSpace(responseCity.MostSpecificSubdivision.IsoCode))
         {
             jObject.Add("ProvinceCode", responseCity.MostSpecificSubdivision.IsoCode);
         }
         if (!string.IsNullOrWhiteSpace(responseCity.MostSpecificSubdivision.Name))
         {
             jObject.Add("Province", responseCity.MostSpecificSubdivision.Name);
         }
         if (!string.IsNullOrWhiteSpace(responseCity.City.Name))
         {
             jObject.Add("City", responseCity.City.Name);
         }
         var cnIsp = GeoIP.GetCnISP(responseAsn, responseCity);
         if (!string.IsNullOrWhiteSpace(cnIsp))
         {
             jObject.Add("ISP", cnIsp);
         }
         await context.WriteResponseAsync(jObject.ToString(), type: "application/json");
     });
 }
Пример #9
0
        /// <summary>
        /// Protected constructor, common functionality for this class and subclasses
        /// </summary>
        /// <param name="socket">TCP socket for communicating with the remote server</param>
        /// <param name="connectionLogWriter">Log writer module</param>
        /// <param name="serverList">Server List object</param>
        /// <param name="geoIP">GeoIP resolver</param>
        protected Connection(Socket socket, IConnectionLogWriter logWriter, ServerList serverList, GeoIP geoIP)
        {
            this.socket     = socket;
            this.logWriter  = logWriter;
            this.serverList = serverList;
            this.geoIP      = geoIP;

            // Socket ID for logging
            SocketID = String.Format("{0}:{1}", (socket.RemoteEndPoint as IPEndPoint).Address, (socket.RemoteEndPoint as IPEndPoint).Port);
        }
Пример #10
0
        public void GetGeoIPTest()
        {
            var ipInformation = new GeoIP();

            Assert.IsNotNull(ipInformation.City);
            Assert.IsNotNull(ipInformation.Country);
            Assert.IsNotNull(ipInformation.CountryCode);
            Assert.IsNotNull(ipInformation.Region);
            Assert.IsNotNull(ipInformation.WanIp);
        }
        public ServerListReport(IPAddress listen, ushort port)
        {
            GeoIP.Initialize(Log, Category);

            StartServer(new AddressInfo()
            {
                Address = listen,
                Port    = port
            });
        }
Пример #12
0
        public void OnGet()
        {
            var city = GeoIP.GetIPInfo(IP);

            if (city?.Latitude != null && city?.Longitude != null)
            {
                InitialLatitude  = city.Latitude.Value;
                InitialLongitude = city.Longitude.Value;
                InitialZoom      = 9;
            }
        }
Пример #13
0
        /// <summary>
        /// Master server constructor. Initialises child objects, helpers and listeners
        /// </summary>
        /// <param name="statusDisplay"></param>
        /// <param name="commandInterface"></param>
        private MasterServer(IStatusDisplay statusDisplay, ICommandInterface commandInterface, ICDKeyValidator cdKeyValidator, IGameStatsLog gameStats, ILogWriter logWriter)
        {
            if (MasterServer.instance != null)
            {
                throw new InvalidOperationException("Attempted to create a Master Server instance whilst another instance was still active");
            }

            // Assign static references
            MasterServer.instance  = this;
            MasterServer.logWriter = logWriter;

            // Assign instance references
            this.statusDisplay    = statusDisplay;
            this.commandInterface = commandInterface;
            this.cdKeyValidator   = cdKeyValidator;
            this.gameStats        = gameStats;

            // Initialise the command interface if we have one
            if (commandInterface != null)
            {
                commandInterface.OnChange += new EventHandler(DisplayCommandInterface);
            }

            // GeoIP resolver is used to resolve IP addresses to locations
            geoIP = new GeoIP();

            // MD5 database is used to download new MD5 package data to connecting servers
            md5Manager = new MD5Manager();

            // IP ban manager used to ban clients from accessing the server
            banManager = new IPBanManager();

            // Create the Server List object
            serverList = new ServerList(this);

            // Create the web server
            webServer = new WebServer(banManager);

            // Initialise the status display module if we have one
            if (statusDisplay != null)
            {
                logBufferSize = statusDisplay.LogBufferSize;
                logBufferWrap = statusDisplay.LogBufferWrap;

                displayTimer = new Timer(new TimerCallback(this.Display));
                Display(null);
            }

            // Load the GeoIP database, MD5 database and ban list from the files (this happens last because they may take a while)
            geoIP.Load(MasterServer.Settings.GeoIPDataFile);
            md5Manager.Load(MasterServer.Settings.MD5DataFile);
            banManager.Load(MasterServer.Settings.BanListFile);
        }
Пример #14
0
        /// <summary>
        /// Creates a new ServerList
        /// </summary>
        /// <param name="masterServer"></param>
        public ServerList(MasterServer masterServer)
        {
            this.masterServer = masterServer;
            this.geoIP        = masterServer.GeoIP;

            this.connectionLogWriter = ModuleManager.GetModule <IConnectionLogWriter>();

            StartService(); // RPC Server
            UpdateLinks();  // RPC Client

            scavengeTimer = new Timer(new TimerCallback(this.Scavenge), null, 10000, Timeout.Infinite);

            ModuleManager.RegisterCommandListener(this);
        }
Пример #15
0
        public HttpServer(IPAddress listen, ushort port)
        {
            GeoIP.Initialize(Log, Category);

            _thread = new Thread(StartServer)
            {
                Name = "Http Socket Thread"
            };

            _thread.Start(new AddressInfo()
            {
                Address = listen,
                Port    = port
            });
        }
Пример #16
0
        public Main(NWR_Client.Client client)
        {
            InitializeComponent();
            Clients = null;
            xClient = client;
            Functions.Center(this);
            conAddr = new List <string>();
            Icon    = GlobalProperties.ApplicationIcon;
            GlobalProperties.MainForm = this;
            log            = new Log(this);
            received       = 0;
            sent           = 0;
            peak           = 0;
            total          = Settings.GetTotal();
            lblTotal.Text  = "Total: " + total.ToString();
            SelectionCount = 0;
            MultiFlood     = false;
            geoIp          = new GeoIP();
            User32.RegisterHotKey(Handle, 0, 0, (int)Keys.F1);
            User32.RegisterHotKey(Handle, 1, 0, (int)Keys.F2);
            User32.RegisterHotKey(Handle, 2, 0, (int)Keys.F3);
            User32.RegisterHotKey(Handle, 3, 0, (int)Keys.F4);
            User32.RegisterHotKey(Handle, 4, 0, (int)Keys.F5);
            User32.RegisterHotKey(Handle, 5, 0, (int)Keys.F6);

            xClient.DataReceived += new EventHandler <NWR_Client.DataReceivedEventArgs>(xClient_DataReceived);
            xClient.Disconnected += new EventHandler(xClient_Disconnected);

            GlobalProperties.Client     = xClient;
            PluginHelper.PluginChanged += new EventHandler(PluginHelper_PluginChanged);
            FloodTimer.TimerStarted    += new EventHandler(FloodTimer_TimerStarted);
            FloodTimer.TimerAborted    += new EventHandler(FloodTimer_TimerAborted);
            FloodTimer.TimerChanged    += new FloodTimer.FloodTimerChangedEventHandler(FloodTimer_TimerChanged);
            FloodTimer.TimerFinished   += new EventHandler(FloodTimer_TimerFinished);
            Load += new EventHandler(Main_Load);
            NatUtility.StartDiscovery();

            NatUtility.DeviceFound += (S, E) =>
            {
                GlobalProperties.NatDevices.Add(E.Device);
            };
            NatUtility.DeviceLost += (S, E) =>
            {
                GlobalProperties.NatDevices.Remove(E.Device);
            };

            GlobalProperties.NI = ni;
        }
Пример #17
0
        public Main(NWR_Client.Client client)
        {
            InitializeComponent();
            Clients = null;
            xClient = client;
            Functions.Center(this);
            conAddr = new List<string>();
            Icon = GlobalProperties.ApplicationIcon;
            GlobalProperties.MainForm = this;
            log = new Log(this);
            received = 0;
            sent = 0;
            peak = 0;
            total = Settings.GetTotal();
            lblTotal.Text = "Total: " + total.ToString();
            SelectionCount = 0;
            MultiFlood = false;
            geoIp = new GeoIP();
            User32.RegisterHotKey(Handle, 0, 0, (int)Keys.F1);
            User32.RegisterHotKey(Handle, 1, 0, (int)Keys.F2);
            User32.RegisterHotKey(Handle, 2, 0, (int)Keys.F3);
            User32.RegisterHotKey(Handle, 3, 0, (int)Keys.F4);
            User32.RegisterHotKey(Handle, 4, 0, (int)Keys.F5);
            User32.RegisterHotKey(Handle, 5, 0, (int)Keys.F6);

            xClient.DataReceived += new EventHandler<NWR_Client.DataReceivedEventArgs>(xClient_DataReceived);
            xClient.Disconnected += new EventHandler(xClient_Disconnected);

            GlobalProperties.Client = xClient;
            PluginHelper.PluginChanged += new EventHandler(PluginHelper_PluginChanged);
            FloodTimer.TimerStarted += new EventHandler(FloodTimer_TimerStarted);
            FloodTimer.TimerAborted += new EventHandler(FloodTimer_TimerAborted);
            FloodTimer.TimerChanged += new FloodTimer.FloodTimerChangedEventHandler(FloodTimer_TimerChanged);
            FloodTimer.TimerFinished += new EventHandler(FloodTimer_TimerFinished);
            Load += new EventHandler(Main_Load);
            NatUtility.StartDiscovery();

            NatUtility.DeviceFound += (S, E) =>
                {
                    GlobalProperties.NatDevices.Add(E.Device);
                };
            NatUtility.DeviceLost += (S, E) =>
                {
                    GlobalProperties.NatDevices.Remove(E.Device);
                };

            GlobalProperties.NI = ni;
        }
Пример #18
0
        private static void SetServerVariables(GameServer gameServer, string[] serverDataFrag, IPEndPoint remote)
        {
            gameServer.Country = (remote.Address.AddressFamily == AddressFamily.InterNetwork)
               ? GeoIP.GetCountryCode(remote.Address).ToUpperInvariant()
               : "??";

            for (int i = 0; i < serverDataFrag.Length - 1; i += 2)
            {
                //Fetch the properties
                PropertyInfo property = typeof(GameServer).GetProperty(serverDataFrag[i]);
                if (property == null)
                {
                    continue;
                }
            }
        }
Пример #19
0
        public ServerNatNeg(IPAddress listen, ushort port, Action <string, string> log, Action <string, string> logError)
        {
            Log      = log;
            LogError = logError;

            GeoIP.Initialize(log, Category);

            Thread = new Thread(StartServer)
            {
                Name = "Server NatNeg Socket Thread"
            };
            Thread.Start(new AddressInfo()
            {
                Address = listen,
                Port    = port
            });
        }
Пример #20
0
        public void TestDropConditions()
        {
            JObject jsonInputLine1 = new JObject
            {
                { "type", "Win32-FileLog" },
                { "IP", "8.8.8.8" }
            };


            string jsonFilter = @"{  
            ""TimberWinR"":{        
                ""Filters"":[  
	                {  
		            ""geoip"":{  
		                ""type"": ""Win32-FileLog"",
		                ""target"": ""mygeoip"",
                        ""source"": ""IP""            
		            }
	              }]
                }
            }";

            // Positive Tests
            Configuration c  = Configuration.FromString(jsonFilter);
            GeoIP         jf = c.Filters.First() as GeoIP;

            Assert.IsTrue(jf.Apply(jsonInputLine1));

            JObject stuff = jsonInputLine1["mygeoip"] as JObject;

            Assert.IsNotNull(stuff);

            Assert.AreEqual("8.8.8.8", stuff["ip"].ToString());
            Assert.AreEqual("US", stuff["country_code2"].ToString());
            Assert.AreEqual("United States", stuff["country_name"].ToString());
            Assert.AreEqual("CA", stuff["region_name"].ToString());
            Assert.AreEqual("Mountain View", stuff["city_name"].ToString());
            Assert.AreEqual("California", stuff["real_region_name"].ToString());
            Assert.AreEqual(37.386f, (float)stuff["latitude"]);
            Assert.AreEqual(-122.0838f, (float)stuff["longitude"]);
        }
Пример #21
0
        //  public static void SendToAllConnected()
        //  {
        //_socket.
        //    }
        public ServerListReport(IPAddress listen, ushort port, Action <string, string> log, Action <string, string> logError, string gameName)
        {
            if (gameName != null)
            {
                _gameName = gameName;
            }
            List <byte> initialMessage = new byte[] { 0x09, 0x00, 0x00, 0x00, 0x00 }.ToList();

            initialMessage.AddRange(Encoding.ASCII.GetBytes(_gameName));
            initialMessage.Add(0x00);
            //Console.WriteLine("[initial:]" + _initialMessage[0] + _initialMessage[1] + _initialMessage[2] + _initialMessage[3] + _initialMessage[4] + ',' + _initialMessage[5] + ',' + _initialMessage[6] + ',' + _initialMessage[7] + ',' + _initialMessage[8] + ',' + _initialMessage[9]);
            _initialMessage = initialMessage.ToArray();
            //Console.WriteLine("[initial:]" + _initialMessage[0] + _initialMessage[1] + _initialMessage[2] + _initialMessage[3] + _initialMessage[4] + ',' + _initialMessage[5] + ',' + _initialMessage[6] + ',' + _initialMessage[7] + ',' + _initialMessage[8]);

            Log      = log;
            LogError = logError;

            GeoIP.Initialize(log, Category);

            Servers = new ConcurrentDictionary <string, GameServer>();

            Thread = new Thread(StartServer)
            {
                Name = "Server Reporting Socket Thread"
            };
            Thread.Start(new AddressInfo()
            {
                Address = listen,
                Port    = port
            });

            new Thread(StartCleanup)
            {
                Name = "Server Reporting Cleanup Thread"
            }.Start();

            new Thread(StartDynamicInfoReload)
            {
                Name = "Dynamic Info Reload Thread"
            }.Start();
        }
Пример #22
0
        /// <summary>
        /// Shut down this listener and all child threads
        /// </summary>
        public void Shutdown()
        {
            aborted = true;

            this.serverList     = null;
            this.geoIP          = null;
            this.cdKeyValidator = null;
            this.gameStats      = null;
            this.md5Manager     = null;
            this.banManager     = null;

            if (listenThread != null)
            {
                // Try to close the listen socket
                if (listenSocket != null)
                {
                    try
                    {
                        listenSocket.Close();
                    }
                    catch { }
                }

                // Try to forcibly abort the listen thread
                listenThread.Abort();
                listenThread.Join();
                listenThread = null;

                MasterServer.Log("[NET] Query listener socket {0} shut down.", endpoint.Port);
            }

            // Abort active connections
            ConnectionManager.AbortAll(endpoint.Port);

            // Release log writer
            ModuleManager.ReleaseModule <IConnectionLogWriter>();
        }
Пример #23
0
        /// <summary>
        /// Constructor, create a new query listener at the specified endpoint
        /// </summary>
        /// <param name="endpoint">Endpoint for this listener</param>
        /// <param name="serverList">Server list object to pass to new connections</param>
        /// <param name="geoIP">GeoIP resolver to pass to new connections</param>
        /// <param name="md5Manager">MD5 manager to pass to new connections</param>
        /// <param name="banManager">IP ban manager to pass to new connections</param>
        /// <param name="cdKeyValidator">CD key validator module to pass to new connections</param>
        /// <param name="gameStats">Game stats module to pass to new connections</param>
        public QueryListener(IPEndPoint endpoint, ServerList serverList, GeoIP geoIP, MD5Manager md5Manager, IPBanManager banManager, ICDKeyValidator cdKeyValidator, IGameStatsLog gameStats)
        {
            // Endpoint to listen
            this.endpoint = endpoint;

            // These objects are passed to new connections
            this.serverList     = serverList;
            this.geoIP          = geoIP;
            this.md5Manager     = md5Manager;
            this.banManager     = banManager;
            this.cdKeyValidator = cdKeyValidator;
            this.gameStats      = gameStats;

            // Get configured connection log writer module
            this.logWriter = ModuleManager.GetModule <IConnectionLogWriter>();

            // Bind the listen socket ready to begin listening
            listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
            listenSocket.Bind(this.Endpoint);

            // Create and start the listen thread
            listenThread = new Thread(ListenThreadProc);
            listenThread.Start();
        }
Пример #24
0
        static void Initialize(Arguments args)
        {
            Console.WriteLine("Platform is {0}", Platform.CurrentPlatform);

            // Load the engine version as early as possible so it can be written to exception logs
            try
            {
                EngineVersion = File.ReadAllText(Platform.ResolvePath(Path.Combine(".", "VERSION"))).Trim();
            }
            catch { }

            if (string.IsNullOrEmpty(EngineVersion))
            {
                EngineVersion = "Unknown";
            }

            Console.WriteLine("Engine version is {0}", EngineVersion);

            // Special case handling of Game.Mod argument: if it matches a real filesystem path
            // then we use this to override the mod search path, and replace it with the mod id
            var modID            = args.GetValue("Game.Mod", null);
            var explicitModPaths = new string[0];

            if (modID != null && (File.Exists(modID) || Directory.Exists(modID)))
            {
                explicitModPaths = new[] { modID };
                modID            = Path.GetFileNameWithoutExtension(modID);
            }

            InitializeSettings(args);

            Log.AddChannel("perf", "perf.log");
            Log.AddChannel("debug", "debug.log");
            Log.AddChannel("server", "server.log");
            Log.AddChannel("sound", "sound.log");
            Log.AddChannel("graphics", "graphics.log");
            Log.AddChannel("geoip", "geoip.log");
            Log.AddChannel("irc", "irc.log");
            Log.AddChannel("nat", "nat.log");

            Sound    = new Sound();
            Renderer = new Renderer(Settings.Graphics);
            GeoIP.Initialize();

            if (Settings.Server.DiscoverNatDevices)
            {
                discoverNat = UPnP.DiscoverNatDevices(Settings.Server.NatDiscoveryTimeout);
            }

            var modSearchArg   = args.GetValue("Engine.ModSearchPaths", null);
            var modSearchPaths = modSearchArg != null?
                                 FieldLoader.GetValue <string[]>("Engine.ModsPath", modSearchArg) :
                                     new[] { Path.Combine(".", "mods") };

            Mods = new InstalledMods(modSearchPaths, explicitModPaths);
            Console.WriteLine("Internal mods:");
            foreach (var mod in Mods)
            {
                Console.WriteLine("\t{0}: {1} ({2})", mod.Key, mod.Value.Metadata.Title, mod.Value.Metadata.Version);
            }

            ExternalMods = new ExternalMods();

            Manifest currentMod;

            if (modID != null && Mods.TryGetValue(modID, out currentMod))
            {
                var launchPath = args.GetValue("Engine.LaunchPath", Assembly.GetEntryAssembly().Location);

                // Sanitize input from platform-specific launchers
                // Process.Start requires paths to not be quoted, even if they contain spaces
                if (launchPath.First() == '"' && launchPath.Last() == '"')
                {
                    launchPath = launchPath.Substring(1, launchPath.Length - 2);
                }

                ExternalMods.Register(Mods[modID], launchPath, ModRegistration.User);

                ExternalMod activeMod;
                if (ExternalMods.TryGetValue(ExternalMod.MakeKey(Mods[modID]), out activeMod))
                {
                    ExternalMods.ClearInvalidRegistrations(activeMod, ModRegistration.User);
                }
            }

            Console.WriteLine("External mods:");
            foreach (var mod in ExternalMods)
            {
                Console.WriteLine("\t{0}: {1} ({2})", mod.Key, mod.Value.Title, mod.Value.Version);
            }

            InitializeMod(modID, args);
        }
Пример #25
0
        void ValidateClient(Connection newConn, string data)
        {
            try
            {
                if (State == ServerState.GameStarted)
                {
                    Log.Write("server", "Rejected connection from {0}; game is already started.",
                              newConn.Socket.RemoteEndPoint);

                    SendOrderTo(newConn, "ServerError", "The game has already started");
                    DropClient(newConn);
                    return;
                }

                var handshake = HandshakeResponse.Deserialize(data);

                if (!string.IsNullOrEmpty(Settings.Password) && handshake.Password != Settings.Password)
                {
                    var message = string.IsNullOrEmpty(handshake.Password) ? "Server requires a password" : "Incorrect password";
                    SendOrderTo(newConn, "AuthenticationError", message);
                    DropClient(newConn);
                    return;
                }

                var ipAddress = ((IPEndPoint)newConn.Socket.RemoteEndPoint).Address;
                var client    = new Session.Client
                {
                    Name                = OpenRA.Settings.SanitizedPlayerName(handshake.Client.Name),
                    IPAddress           = ipAddress.ToString(),
                    AnonymizedIPAddress = Type != ServerType.Local && Settings.ShareAnonymizedIPs ? Session.AnonymizeIP(ipAddress) : null,
                    Location            = GeoIP.LookupCountry(ipAddress),
                    Index               = newConn.PlayerIndex,
                    PreferredColor      = handshake.Client.PreferredColor,
                    Color               = handshake.Client.Color,
                    Faction             = "Random",
                    SpawnPoint          = 0,
                    Team                = 0,
                    State               = Session.ClientState.Invalid,
                };

                if (ModData.Manifest.Id != handshake.Mod)
                {
                    Log.Write("server", "Rejected connection from {0}; mods do not match.",
                              newConn.Socket.RemoteEndPoint);

                    SendOrderTo(newConn, "ServerError", "Server is running an incompatible mod");
                    DropClient(newConn);
                    return;
                }

                if (ModData.Manifest.Metadata.Version != handshake.Version)
                {
                    Log.Write("server", "Rejected connection from {0}; Not running the same version.",
                              newConn.Socket.RemoteEndPoint);

                    SendOrderTo(newConn, "ServerError", "Server is running an incompatible version");
                    DropClient(newConn);
                    return;
                }

                if (handshake.OrdersProtocol != ProtocolVersion.Orders)
                {
                    Log.Write("server", "Rejected connection from {0}; incompatible Orders protocol version {1}.",
                              newConn.Socket.RemoteEndPoint, handshake.OrdersProtocol);

                    SendOrderTo(newConn, "ServerError", "Server is running an incompatible protocol");
                    DropClient(newConn);
                    return;
                }

                // Check if IP is banned
                var bans = Settings.Ban.Union(TempBans);
                if (bans.Contains(client.IPAddress))
                {
                    Log.Write("server", "Rejected connection from {0}; Banned.", newConn.Socket.RemoteEndPoint);
                    SendOrderTo(newConn, "ServerError", "You have been {0} from the server".F(Settings.Ban.Contains(client.IPAddress) ? "banned" : "temporarily banned"));
                    DropClient(newConn);
                    return;
                }

                Action completeConnection = () =>
                {
                    lock (LobbyInfo)
                    {
                        client.Slot    = LobbyInfo.FirstEmptySlot();
                        client.IsAdmin = !LobbyInfo.Clients.Any(c1 => c1.IsAdmin);

                        if (client.IsObserver && !LobbyInfo.GlobalSettings.AllowSpectators)
                        {
                            SendOrderTo(newConn, "ServerError", "The game is full");
                            DropClient(newConn);
                            return;
                        }

                        if (client.Slot != null)
                        {
                            SyncClientToPlayerReference(client, Map.Players.Players[client.Slot]);
                        }
                        else
                        {
                            client.Color = Color.White;
                        }

                        // Promote connection to a valid client
                        PreConns.Remove(newConn);
                        Conns.Add(newConn);
                        LobbyInfo.Clients.Add(client);
                        newConn.Validated = true;

                        var clientPing = new Session.ClientPing {
                            Index = client.Index
                        };
                        LobbyInfo.ClientPings.Add(clientPing);

                        Log.Write("server", "Client {0}: Accepted connection from {1}.",
                                  newConn.PlayerIndex, newConn.Socket.RemoteEndPoint);

                        if (client.Fingerprint != null)
                        {
                            Log.Write("server", "Client {0}: Player fingerprint is {1}.",
                                      newConn.PlayerIndex, client.Fingerprint);
                        }

                        foreach (var t in serverTraits.WithInterface <IClientJoined>())
                        {
                            t.ClientJoined(this, newConn);
                        }

                        SyncLobbyInfo();

                        Log.Write("server", "{0} ({1}) has joined the game.",
                                  client.Name, newConn.Socket.RemoteEndPoint);

                        // Report to all other players
                        SendMessage("{0} has joined the game.".F(client.Name), newConn);

                        // Send initial ping
                        SendOrderTo(newConn, "Ping", Game.RunTime.ToString(CultureInfo.InvariantCulture));

                        if (Type == ServerType.Dedicated)
                        {
                            var motdFile = Platform.ResolvePath(Platform.SupportDirPrefix, "motd.txt");
                            if (!File.Exists(motdFile))
                            {
                                File.WriteAllText(motdFile, "Welcome, have fun and good luck!");
                            }

                            var motd = File.ReadAllText(motdFile);
                            if (!string.IsNullOrEmpty(motd))
                            {
                                SendOrderTo(newConn, "Message", motd);
                            }
                        }

                        if (Map.DefinesUnsafeCustomRules)
                        {
                            SendOrderTo(newConn, "Message", "This map contains custom rules. Game experience may change.");
                        }

                        if (!LobbyInfo.GlobalSettings.EnableSingleplayer)
                        {
                            SendOrderTo(newConn, "Message", TwoHumansRequiredText);
                        }
                        else if (Map.Players.Players.Where(p => p.Value.Playable).All(p => !p.Value.AllowBots))
                        {
                            SendOrderTo(newConn, "Message", "Bots have been disabled on this map.");
                        }
                    }
                };

                if (Type == ServerType.Local)
                {
                    // Local servers can only be joined by the local client, so we can trust their identity without validation
                    client.Fingerprint = handshake.Fingerprint;
                    completeConnection();
                }
                else if (!string.IsNullOrEmpty(handshake.Fingerprint) && !string.IsNullOrEmpty(handshake.AuthSignature))
                {
                    waitingForAuthenticationCallback++;

                    Action <DownloadDataCompletedEventArgs> onQueryComplete = i =>
                    {
                        PlayerProfile profile = null;

                        if (i.Error == null)
                        {
                            try
                            {
                                var yaml = MiniYaml.FromString(Encoding.UTF8.GetString(i.Result)).First();
                                if (yaml.Key == "Player")
                                {
                                    profile = FieldLoader.Load <PlayerProfile>(yaml.Value);

                                    var publicKey  = Encoding.ASCII.GetString(Convert.FromBase64String(profile.PublicKey));
                                    var parameters = CryptoUtil.DecodePEMPublicKey(publicKey);
                                    if (!profile.KeyRevoked && CryptoUtil.VerifySignature(parameters, newConn.AuthToken, handshake.AuthSignature))
                                    {
                                        client.Fingerprint = handshake.Fingerprint;
                                        Log.Write("server", "{0} authenticated as {1} (UID {2})", newConn.Socket.RemoteEndPoint,
                                                  profile.ProfileName, profile.ProfileID);
                                    }
                                    else if (profile.KeyRevoked)
                                    {
                                        profile = null;
                                        Log.Write("server", "{0} failed to authenticate as {1} (key revoked)", newConn.Socket.RemoteEndPoint, handshake.Fingerprint);
                                    }
                                    else
                                    {
                                        profile = null;
                                        Log.Write("server", "{0} failed to authenticate as {1} (signature verification failed)",
                                                  newConn.Socket.RemoteEndPoint, handshake.Fingerprint);
                                    }
                                }
                                else
                                {
                                    Log.Write("server", "{0} failed to authenticate as {1} (invalid server response: `{2}` is not `Player`)",
                                              newConn.Socket.RemoteEndPoint, handshake.Fingerprint, yaml.Key);
                                }
                            }
                            catch (Exception ex)
                            {
                                Log.Write("server", "{0} failed to authenticate as {1} (exception occurred)",
                                          newConn.Socket.RemoteEndPoint, handshake.Fingerprint);
                                Log.Write("server", ex.ToString());
                            }
                        }
                        else
                        {
                            Log.Write("server", "{0} failed to authenticate as {1} (server error: `{2}`)",
                                      newConn.Socket.RemoteEndPoint, handshake.Fingerprint, i.Error);
                        }

                        delayedActions.Add(() =>
                        {
                            var notAuthenticated = Type == ServerType.Dedicated && profile == null && (Settings.RequireAuthentication || Settings.ProfileIDWhitelist.Any());
                            var blacklisted      = Type == ServerType.Dedicated && profile != null && Settings.ProfileIDBlacklist.Contains(profile.ProfileID);
                            var notWhitelisted   = Type == ServerType.Dedicated && Settings.ProfileIDWhitelist.Any() &&
                                                   (profile == null || !Settings.ProfileIDWhitelist.Contains(profile.ProfileID));

                            if (notAuthenticated)
                            {
                                Log.Write("server", "Rejected connection from {0}; Not authenticated.", newConn.Socket.RemoteEndPoint);
                                SendOrderTo(newConn, "ServerError", "Server requires players to have an OpenRA forum account");
                                DropClient(newConn);
                            }
                            else if (blacklisted || notWhitelisted)
                            {
                                if (blacklisted)
                                {
                                    Log.Write("server", "Rejected connection from {0}; In server blacklist.", newConn.Socket.RemoteEndPoint);
                                }
                                else
                                {
                                    Log.Write("server", "Rejected connection from {0}; Not in server whitelist.", newConn.Socket.RemoteEndPoint);
                                }

                                SendOrderTo(newConn, "ServerError", "You do not have permission to join this server");
                                DropClient(newConn);
                            }
                            else
                            {
                                completeConnection();
                            }

                            waitingForAuthenticationCallback--;
                        }, 0);
                    };

                    new Download(playerDatabase.Profile + handshake.Fingerprint, _ => { }, onQueryComplete);
                }
                else
                {
                    if (Type == ServerType.Dedicated && (Settings.RequireAuthentication || Settings.ProfileIDWhitelist.Any()))
                    {
                        Log.Write("server", "Rejected connection from {0}; Not authenticated.", newConn.Socket.RemoteEndPoint);
                        SendOrderTo(newConn, "ServerError", "Server requires players to have an OpenRA forum account");
                        DropClient(newConn);
                    }
                    else
                    {
                        completeConnection();
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Write("server", "Dropping connection {0} because an error occurred:", newConn.Socket.RemoteEndPoint);
                Log.Write("server", ex.ToString());
                DropClient(newConn);
            }
        }
Пример #26
0
        public Server(List <IPEndPoint> endpoints, ServerSettings settings, ModData modData, ServerType type)
        {
            Log.AddChannel("server", "server.log", true);

            SocketException lastException   = null;
            var             checkReadServer = new List <Socket>();

            foreach (var endpoint in endpoints)
            {
                var listener = new TcpListener(endpoint);
                try
                {
                    try
                    {
                        listener.Server.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 1);
                    }
                    catch (Exception ex)
                    {
                        if (ex is SocketException || ex is ArgumentException)
                        {
                            Log.Write("server", "Failed to set socket option on {0}: {1}", endpoint.ToString(), ex.Message);
                        }
                        else
                        {
                            throw;
                        }
                    }

                    listener.Start();
                    listeners.Add(listener);
                    checkReadServer.Add(listener.Server);
                }
                catch (SocketException ex)
                {
                    lastException = ex;
                    Log.Write("server", "Failed to listen on {0}: {1}", endpoint.ToString(), ex.Message);
                }
            }

            if (listeners.Count == 0)
            {
                throw lastException;
            }

            Type     = type;
            Settings = settings;

            Settings.Name = OpenRA.Settings.SanitizedServerName(Settings.Name);

            ModData = modData;

            playerDatabase = modData.Manifest.Get <PlayerDatabase>();

            randomSeed = (int)DateTime.Now.ToBinary();

            if (type != ServerType.Local && settings.EnableGeoIP)
            {
                GeoIP.Initialize();
            }

            if (UPnP.Status == UPnPStatus.Enabled)
            {
                UPnP.ForwardPort(Settings.ListenPort, Settings.ListenPort).Wait();
            }

            foreach (var trait in modData.Manifest.ServerTraits)
            {
                serverTraits.Add(modData.ObjectCreator.CreateObject <ServerTrait>(trait));
            }

            serverTraits.TrimExcess();

            LobbyInfo = new Session
            {
                GlobalSettings =
                {
                    RandomSeed         = randomSeed,
                    Map                = settings.Map,
                    ServerName         = settings.Name,
                    EnableSingleplayer = settings.EnableSingleplayer || Type != ServerType.Dedicated,
                    EnableSyncReports  = settings.EnableSyncReports,
                    GameUid            = Guid.NewGuid().ToString(),
                    Dedicated          = Type == ServerType.Dedicated
                }
            };

            new Thread(_ =>
            {
                foreach (var t in serverTraits.WithInterface <INotifyServerStart>())
                {
                    t.ServerStarted(this);
                }

                Log.Write("server", "Initial mod: {0}", ModData.Manifest.Id);
                Log.Write("server", "Initial map: {0}", LobbyInfo.GlobalSettings.Map);

                while (true)
                {
                    var checkRead = new List <Socket>();
                    if (State == ServerState.WaitingPlayers)
                    {
                        checkRead.AddRange(checkReadServer);
                    }

                    checkRead.AddRange(Conns.Select(c => c.Socket));
                    checkRead.AddRange(PreConns.Select(c => c.Socket));

                    // Block for at most 1 second in order to guarantee a minimum tick rate for ServerTraits
                    // Decrease this to 100ms to improve responsiveness if we are waiting for an authentication query
                    var localTimeout = waitingForAuthenticationCallback > 0 ? 100000 : 1000000;
                    if (checkRead.Count > 0)
                    {
                        Socket.Select(checkRead, null, null, localTimeout);
                    }

                    if (State == ServerState.ShuttingDown)
                    {
                        EndGame();
                        break;
                    }

                    foreach (var s in checkRead)
                    {
                        var serverIndex = checkReadServer.IndexOf(s);
                        if (serverIndex >= 0)
                        {
                            AcceptConnection(listeners[serverIndex]);
                            continue;
                        }

                        var preConn = PreConns.SingleOrDefault(c => c.Socket == s);
                        if (preConn != null)
                        {
                            preConn.ReadData(this);
                            continue;
                        }

                        var conn = Conns.SingleOrDefault(c => c.Socket == s);
                        conn?.ReadData(this);
                    }

                    delayedActions.PerformActions(0);

                    // PERF: Dedicated servers need to drain the action queue to remove references blocking the GC from cleaning up disposed objects.
                    if (Type == ServerType.Dedicated)
                    {
                        Game.PerformDelayedActions();
                    }

                    foreach (var t in serverTraits.WithInterface <ITick>())
                    {
                        t.Tick(this);
                    }

                    if (State == ServerState.ShuttingDown)
                    {
                        EndGame();
                        if (UPnP.Status == UPnPStatus.Enabled)
                        {
                            UPnP.RemovePortForward().Wait();
                        }
                        break;
                    }
                }

                foreach (var t in serverTraits.WithInterface <INotifyServerShutdown>())
                {
                    t.ServerShutdown(this);
                }

                PreConns.Clear();
                Conns.Clear();

                foreach (var listener in listeners)
                {
                    try { listener.Stop(); }
                    catch { }
                }
            })
            {
                IsBackground = true
            }.Start();
        }
Пример #27
0
        List <Widget> LoadGameRows(List <GameServer> games, out ScrollItemWidget nextServerRow)
        {
            nextServerRow = null;
            var rows = new List <Widget>();
            var mods = games.GroupBy(g => g.ModLabel)
                       .OrderByDescending(g => GroupSortOrder(g.First()))
                       .ThenByDescending(g => g.Count());

            foreach (var modGames in mods)
            {
                if (modGames.All(Filtered))
                {
                    continue;
                }

                var header = ScrollItemWidget.Setup(headerTemplate, () => true, () => { });

                var headerTitle = modGames.First().ModLabel;
                header.Get <LabelWidget>("LABEL").GetText = () => headerTitle;
                rows.Add(header);

                Func <GameServer, int> listOrder = g =>
                {
                    // Servers waiting for players are always first
                    if (g.State == (int)ServerState.WaitingPlayers && g.Players > 0)
                    {
                        return(0);
                    }

                    // Then servers with spectators
                    if (g.State == (int)ServerState.WaitingPlayers && g.Spectators > 0)
                    {
                        return(1);
                    }

                    // Then active games
                    if (g.State >= (int)ServerState.GameStarted)
                    {
                        return(2);
                    }

                    // Empty servers are shown at the end because a flood of empty servers
                    // at the top of the game list make the community look dead
                    return(3);
                };

                foreach (var modGamesByState in modGames.GroupBy(listOrder).OrderBy(g => g.Key))
                {
                    // Sort 'Playing' games by Started, others by number of players
                    foreach (var game in modGamesByState.Key == 2 ? modGamesByState.OrderByDescending(g => g.Started) : modGamesByState.OrderByDescending(g => g.Players))
                    {
                        if (Filtered(game))
                        {
                            continue;
                        }

                        var canJoin = game.IsJoinable;
                        var item    = ScrollItemWidget.Setup(serverTemplate, () => currentServer == game, () => SelectServer(game), () => onJoin(game));
                        var title   = item.GetOrNull <LabelWidget>("TITLE");
                        if (title != null)
                        {
                            var font  = Game.Renderer.Fonts[title.Font];
                            var label = WidgetUtils.TruncateText(game.Name, title.Bounds.Width, font);
                            title.GetText  = () => label;
                            title.GetColor = () => canJoin ? title.TextColor : incompatibleGameColor;
                        }

                        var password = item.GetOrNull <ImageWidget>("PASSWORD_PROTECTED");
                        if (password != null)
                        {
                            password.IsVisible    = () => game.Protected;
                            password.GetImageName = () => canJoin ? "protected" : "protected-disabled";
                        }

                        var players = item.GetOrNull <LabelWithTooltipWidget>("PLAYERS");
                        if (players != null)
                        {
                            var label = "{0} / {1}".F(game.Players + game.Bots, game.MaxPlayers + game.Bots)
                                        + (game.Spectators > 0 ? " + {0}".F(game.Spectators) : "");

                            var color = canJoin ? players.TextColor : incompatibleGameColor;
                            players.GetText  = () => label;
                            players.GetColor = () => color;

                            if (game.Clients.Any())
                            {
                                var displayClients = game.Clients.Select(c => c.Name);
                                if (game.Clients.Length > 10)
                                {
                                    displayClients = displayClients
                                                     .Take(9)
                                                     .Append("+ {0} other players".F(game.Clients.Length - 9));
                                }

                                var tooltip = displayClients.JoinWith("\n");
                                players.GetTooltipText = () => tooltip;
                            }
                            else
                            {
                                players.GetTooltipText = null;
                            }
                        }

                        var state = item.GetOrNull <LabelWidget>("STATUS");
                        if (state != null)
                        {
                            var label = game.State >= (int)ServerState.GameStarted ?
                                        "Playing" : "Waiting";
                            state.GetText = () => label;

                            var color = GetStateColor(game, state, !canJoin);
                            state.GetColor = () => color;
                        }

                        var location = item.GetOrNull <LabelWidget>("LOCATION");
                        if (location != null)
                        {
                            var font = Game.Renderer.Fonts[location.Font];
                            var cachedServerLocation = game.Id != -1 ? GeoIP.LookupCountry(game.Address.Split(':')[0]) : "Local Network";
                            var label = WidgetUtils.TruncateText(cachedServerLocation, location.Bounds.Width, font);
                            location.GetText  = () => label;
                            location.GetColor = () => canJoin ? location.TextColor : incompatibleGameColor;
                        }

                        if (currentServer != null && game.Address == currentServer.Address)
                        {
                            nextServerRow = item;
                        }

                        rows.Add(item);
                    }
                }
            }

            return(rows);
        }
Пример #28
0
        static void Initialize(Arguments args)
        {
            var supportDirArg = args.GetValue("Engine.SupportDir", null);

            if (supportDirArg != null)
            {
                Platform.OverrideSupportDir(supportDirArg);
            }

            Console.WriteLine("Platform is {0}", Platform.CurrentPlatform);

            // Load the engine version as early as possible so it can be written to exception logs
            try
            {
                EngineVersion = File.ReadAllText(Platform.ResolvePath(Path.Combine(".", "VERSION"))).Trim();
            }
            catch { }

            if (string.IsNullOrEmpty(EngineVersion))
            {
                EngineVersion = "Unknown";
            }

            Console.WriteLine("Engine version is {0}", EngineVersion);

            // Special case handling of Game.Mod argument: if it matches a real filesystem path
            // then we use this to override the mod search path, and replace it with the mod id
            var modID            = args.GetValue("Game.Mod", null);
            var explicitModPaths = new string[0];

            if (modID != null && (File.Exists(modID) || Directory.Exists(modID)))
            {
                explicitModPaths = new[] { modID };
                modID            = Path.GetFileNameWithoutExtension(modID);
            }

            InitializeSettings(args);

            Log.AddChannel("perf", "perf.log");
            Log.AddChannel("debug", "debug.log");
            Log.AddChannel("server", "server.log", true);
            Log.AddChannel("sound", "sound.log");
            Log.AddChannel("graphics", "graphics.log");
            Log.AddChannel("geoip", "geoip.log");
            Log.AddChannel("nat", "nat.log");

            var platforms = new[] { Settings.Game.Platform, "Default", null };

            foreach (var p in platforms)
            {
                if (p == null)
                {
                    throw new InvalidOperationException("Failed to initialize platform-integration library. Check graphics.log for details.");
                }

                Settings.Game.Platform = p;
                try
                {
                    var rendererPath = Platform.ResolvePath(Path.Combine(".", "OpenRA.Platforms." + p + ".dll"));
                    var assembly     = Assembly.LoadFile(rendererPath);

                    var platformType = assembly.GetTypes().SingleOrDefault(t => typeof(IPlatform).IsAssignableFrom(t));
                    if (platformType == null)
                    {
                        throw new InvalidOperationException("Platform dll must include exactly one IPlatform implementation.");
                    }

                    var platform = (IPlatform)platformType.GetConstructor(Type.EmptyTypes).Invoke(null);
                    Renderer = new Renderer(platform, Settings.Graphics);
                    Sound    = new Sound(platform, Settings.Sound);

                    break;
                }
                catch (Exception e)
                {
                    Log.Write("graphics", "{0}", e);
                    Console.WriteLine("Renderer initialization failed. Check graphics.log for details.");

                    if (Renderer != null)
                    {
                        Renderer.Dispose();
                    }

                    if (Sound != null)
                    {
                        Sound.Dispose();
                    }
                }
            }

            GeoIP.Initialize();

            if (Settings.Server.DiscoverNatDevices)
            {
                discoverNat = UPnP.DiscoverNatDevices(Settings.Server.NatDiscoveryTimeout);
            }

            var modSearchArg   = args.GetValue("Engine.ModSearchPaths", null);
            var modSearchPaths = modSearchArg != null?
                                 FieldLoader.GetValue <string[]>("Engine.ModsPath", modSearchArg) :
                                     new[] { Path.Combine(".", "mods") };

            Mods = new InstalledMods(modSearchPaths, explicitModPaths);
            Console.WriteLine("Internal mods:");
            foreach (var mod in Mods)
            {
                Console.WriteLine("\t{0}: {1} ({2})", mod.Key, mod.Value.Metadata.Title, mod.Value.Metadata.Version);
            }

            modLaunchWrapper = args.GetValue("Engine.LaunchWrapper", null);

            ExternalMods = new ExternalMods();

            Manifest currentMod;

            if (modID != null && Mods.TryGetValue(modID, out currentMod))
            {
                var launchPath = args.GetValue("Engine.LaunchPath", Assembly.GetEntryAssembly().Location);

                // Sanitize input from platform-specific launchers
                // Process.Start requires paths to not be quoted, even if they contain spaces
                if (launchPath.First() == '"' && launchPath.Last() == '"')
                {
                    launchPath = launchPath.Substring(1, launchPath.Length - 2);
                }

                ExternalMods.Register(Mods[modID], launchPath, ModRegistration.User);

                ExternalMod activeMod;
                if (ExternalMods.TryGetValue(ExternalMod.MakeKey(Mods[modID]), out activeMod))
                {
                    ExternalMods.ClearInvalidRegistrations(activeMod, ModRegistration.User);
                }
            }

            Console.WriteLine("External mods:");
            foreach (var mod in ExternalMods)
            {
                Console.WriteLine("\t{0}: {1} ({2})", mod.Key, mod.Value.Title, mod.Value.Version);
            }

            InitializeMod(modID, args);
        }
Пример #29
0
        internal static void Initialize(Arguments args)
        {
            Console.WriteLine("Platform is {0}", Platform.CurrentPlatform);

            // Special case handling of Game.Mod argument: if it matches a real filesystem path
            // then we use this to override the mod search path, and replace it with the mod id
            var    modArgument   = args.GetValue("Game.Mod", null);
            string customModPath = null;

            if (modArgument != null && (File.Exists(modArgument) || Directory.Exists(modArgument)))
            {
                customModPath = modArgument;
                args.ReplaceValue("Game.Mod", Path.GetFileNameWithoutExtension(modArgument));
            }

            InitializeSettings(args);

            Log.AddChannel("perf", "perf.log");
            Log.AddChannel("debug", "debug.log");
            Log.AddChannel("server", "server.log");
            Log.AddChannel("sound", "sound.log");
            Log.AddChannel("graphics", "graphics.log");
            Log.AddChannel("geoip", "geoip.log");
            Log.AddChannel("irc", "irc.log");
            Log.AddChannel("nat", "nat.log");

            var platforms = new[] { Settings.Game.Platform, "Default", null };

            foreach (var p in platforms)
            {
                if (p == null)
                {
                    throw new InvalidOperationException("Failed to initialize platform-integration library. Check graphics.log for details.");
                }

                Settings.Game.Platform = p;
                try
                {
                    var rendererPath = Platform.ResolvePath(Path.Combine(".", "OpenRA.Platforms." + p + ".dll"));
                    var assembly     = Assembly.LoadFile(rendererPath);

                    var platformType = assembly.GetTypes().SingleOrDefault(t => typeof(IPlatform).IsAssignableFrom(t));
                    if (platformType == null)
                    {
                        throw new InvalidOperationException("Platform dll must include exactly one IPlatform implementation.");
                    }

                    var platform = (IPlatform)platformType.GetConstructor(Type.EmptyTypes).Invoke(null);
                    Renderer = new Renderer(platform, Settings.Graphics);
                    Sound    = new Sound(platform, Settings.Sound);

                    break;
                }
                catch (Exception e)
                {
                    Log.Write("graphics", "{0}", e);
                    Console.WriteLine("Renderer initialization failed. Check graphics.log for details.");

                    if (Renderer != null)
                    {
                        Renderer.Dispose();
                    }

                    if (Sound != null)
                    {
                        Sound.Dispose();
                    }
                }
            }

            GeoIP.Initialize();

            if (!Settings.Server.DiscoverNatDevices)
            {
                Settings.Server.AllowPortForward = false;
            }
            else
            {
                discoverNat = UPnP.DiscoverNatDevices(Settings.Server.NatDiscoveryTimeout);
                Settings.Server.AllowPortForward = true;
            }

            GlobalChat = new GlobalChat();

            Mods = new InstalledMods(customModPath);
            Console.WriteLine("Available mods:");
            foreach (var mod in Mods)
            {
                Console.WriteLine("\t{0}: {1} ({2})", mod.Key, mod.Value.Metadata.Title, mod.Value.Metadata.Version);
            }

            InitializeMod(Settings.Game.Mod, args);
        }
Пример #30
0
        internal static void Initialize(Arguments args)
        {
            Console.WriteLine("Platform is {0}", Platform.CurrentPlatform);

            InitializeSettings(args);

            Log.AddChannel("perf", "perf.log");
            Log.AddChannel("debug", "debug.log");
            Log.AddChannel("sync", "syncreport.log");
            Log.AddChannel("server", "server.log");
            Log.AddChannel("sound", "sound.log");
            Log.AddChannel("graphics", "graphics.log");
            Log.AddChannel("geoip", "geoip.log");
            Log.AddChannel("irc", "irc.log");

            if (Settings.Server.DiscoverNatDevices)
            {
                UPnP.TryNatDiscovery();
            }
            else
            {
                Settings.Server.NatDeviceAvailable = false;
                Settings.Server.AllowPortForward   = false;
            }

            GeoIP.Initialize();

            var renderers = new[] { Settings.Graphics.Renderer, "Default", null };

            foreach (var r in renderers)
            {
                if (r == null)
                {
                    throw new InvalidOperationException("No suitable renderers were found. Check graphics.log for details.");
                }

                Settings.Graphics.Renderer = r;
                try
                {
                    Renderer = new Renderer(Settings.Graphics, Settings.Server);
                    break;
                }
                catch (Exception e)
                {
                    Log.Write("graphics", "{0}", e);
                    Console.WriteLine("Renderer initialization failed. Fallback in place. Check graphics.log for details.");
                }
            }

            Sound = new Sound(Settings.Sound.Engine);

            GlobalChat = new GlobalChat();

            Console.WriteLine("Available mods:");
            foreach (var mod in ModMetadata.AllMods)
            {
                Console.WriteLine("\t{0}: {1} ({2})", mod.Key, mod.Value.Title, mod.Value.Version);
            }

            InitializeMod(Settings.Game.Mod, args);

            if (Settings.Server.DiscoverNatDevices)
            {
                RunAfterDelay(Settings.Server.NatDiscoveryTimeout, UPnP.StoppingNatDiscovery);
            }
        }
Пример #31
0
        public ClientTooltipLogic(Widget widget, TooltipContainerWidget tooltipContainer, OrderManager orderManager, int clientIndex)
        {
            var admin     = widget.Get <LabelWidget>("ADMIN");
            var adminFont = Game.Renderer.Fonts[admin.Font];

            var latency = widget.GetOrNull <LabelWidget>("LATENCY");

            if (latency != null)
            {
                latencyFont = Game.Renderer.Fonts[latency.Font];
            }

            var latencyPrefix = widget.GetOrNull <LabelWidget>("LATENCY_PREFIX");

            if (latencyPrefix != null)
            {
                latencyPrefixFont = Game.Renderer.Fonts[latencyPrefix.Font];
            }

            var ip          = widget.Get <LabelWidget>("IP");
            var addressFont = Game.Renderer.Fonts[ip.Font];

            var location     = widget.Get <LabelWidget>("LOCATION");
            var locationFont = Game.Renderer.Fonts[location.Font];

            var locationOffset = location.Bounds.Y;
            var addressOffset  = ip.Bounds.Y;
            var latencyOffset  = latency == null ? 0 : latency.Bounds.Y;
            var tooltipHeight  = widget.Bounds.Height;

            var margin = widget.Bounds.Width;

            widget.IsVisible = () => (orderManager.LobbyInfo.ClientWithIndex(clientIndex) != null);
            tooltipContainer.BeforeRender = () =>
            {
                if (!widget.IsVisible())
                {
                    return;
                }

                var latencyPrefixSize = latencyPrefix == null ? 0 : latencyPrefix.Bounds.X + latencyPrefixFont.Measure(latencyPrefix.GetText() + " ").X;
                var locationWidth     = locationFont.Measure(location.GetText()).X;
                var adminWidth        = adminFont.Measure(admin.GetText()).X;
                var addressWidth      = addressFont.Measure(ip.GetText()).X;
                var latencyWidth      = latencyFont == null ? 0 : latencyPrefixSize + latencyFont.Measure(latency.GetText()).X;
                var width             = Math.Max(locationWidth, Math.Max(adminWidth, Math.Max(addressWidth, latencyWidth)));
                widget.Bounds.Width = width + 2 * margin;
                if (latency != null)
                {
                    latency.Bounds.Width = widget.Bounds.Width;
                }
                ip.Bounds.Width       = widget.Bounds.Width;
                admin.Bounds.Width    = widget.Bounds.Width;
                location.Bounds.Width = widget.Bounds.Width;

                ip.Bounds.Y = addressOffset;
                if (latency != null)
                {
                    latency.Bounds.Y = latencyOffset;
                }
                location.Bounds.Y    = locationOffset;
                widget.Bounds.Height = tooltipHeight;

                if (admin.IsVisible())
                {
                    ip.Bounds.Y += admin.Bounds.Height;
                    if (latency != null)
                    {
                        latency.Bounds.Y += admin.Bounds.Height;
                    }
                    location.Bounds.Y    += admin.Bounds.Height;
                    widget.Bounds.Height += admin.Bounds.Height;
                }

                if (latencyPrefix != null)
                {
                    latencyPrefix.Bounds.Y = latency.Bounds.Y;
                }
                if (latency != null)
                {
                    latency.Bounds.X = latencyPrefixSize;
                }
            };

            admin.IsVisible = () => orderManager.LobbyInfo.ClientWithIndex(clientIndex).IsAdmin;
            var client = orderManager.LobbyInfo.ClientWithIndex(clientIndex);
            var ping   = orderManager.LobbyInfo.PingFromClient(client);

            if (latency != null)
            {
                latency.GetText  = () => LobbyUtils.LatencyDescription(ping);
                latency.GetColor = () => LobbyUtils.LatencyColor(ping);
            }

            var address             = LobbyUtils.GetExternalIP(clientIndex, orderManager);
            var cachedDescriptiveIP = LobbyUtils.DescriptiveIpAddress(address);

            ip.GetText = () => cachedDescriptiveIP;
            var cachedCountryLookup = GeoIP.LookupCountry(address);

            location.GetText = () => cachedCountryLookup;
        }