Changeset 387


Ignore:
Timestamp:
Aug 6, 2022, 11:32:32 PM (2 years ago)
Author:
alloc
Message:

Big refactoring in Web to pass around a Context instead of a bunch of individual arguments all the time

Location:
binary-improvements2/MapRendering
Files:
2 added
30 edited
1 moved

Legend:

Unmodified
Added
Removed

  • binary-improvements2/MapRendering/Web/API/AbsWebAPI.cs

    r386 r387  
    1 using System.Text;
    2 using AllocsFixes.JSON;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    5 
    61namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public abstract class WebAPI {
     2        public abstract class AbsWebAPI {
    83                public readonly string Name;
    94
    10                 protected WebAPI (string _name = null) {
     5                protected AbsWebAPI (string _name = null) {
    116                        Name = _name ?? GetType ().Name;
    127                }
    138
    14 #if ENABLE_PROFILER
    15                 private static readonly UnityEngine.Profiling.CustomSampler jsonSerializeSampler = UnityEngine.Profiling.CustomSampler.Create ("JSON_Serialize");
    16                 private static readonly UnityEngine.Profiling.CustomSampler netWriteSampler = UnityEngine.Profiling.CustomSampler.Create ("JSON_Write");
    17 #endif
    18 
    19                 public static void WriteJSON (HttpListenerResponse _resp, JSONNode _root) {
    20 #if ENABLE_PROFILER
    21                         jsonSerializeSampler.Begin ();
    22 #endif
    23                         StringBuilder sb = new StringBuilder ();
    24                         _root.ToString (sb);
    25 #if ENABLE_PROFILER
    26                         jsonSerializeSampler.End ();
    27                         netWriteSampler.Begin ();
    28 #endif
    29                         byte[] buf = Encoding.UTF8.GetBytes (sb.ToString ());
    30                         _resp.ContentLength64 = buf.Length;
    31                         _resp.ContentType = "application/json";
    32                         _resp.ContentEncoding = Encoding.UTF8;
    33                         _resp.OutputStream.Write (buf, 0, buf.Length);
    34 #if ENABLE_PROFILER
    35                         netWriteSampler.End ();
    36 #endif
    37                 }
    38 
    39                 public static void WriteText (HttpListenerResponse _resp, string _text) {
    40                         byte[] buf = Encoding.UTF8.GetBytes (_text);
    41                         _resp.ContentLength64 = buf.Length;
    42                         _resp.ContentType = "text/plain";
    43                         _resp.ContentEncoding = Encoding.UTF8;
    44                         _resp.OutputStream.Write (buf, 0, buf.Length);
    45                 }
    46 
    47                 public abstract void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp,
    48                         WebConnection _user, int _permissionLevel);
     9                public abstract void HandleRequest (RequestContext _context);
    4910
    5011                public virtual int DefaultPermissionLevel () {

  • binary-improvements2/MapRendering/Web/API/ExecuteConsoleCommand.cs

    r382 r387  
    11using System;
    22using System.Net;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class ExecuteConsoleCommand : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
    10                         if (string.IsNullOrEmpty (_req.QueryString ["command"])) {
    11                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    12                                 Web.SetResponseTextContent (_resp, "No command given");
     5        public class ExecuteConsoleCommand : AbsWebAPI {
     6                public override void HandleRequest (RequestContext _context) {
     7                        if (string.IsNullOrEmpty (_context.Request.QueryString ["command"])) {
     8                                WebUtils.WriteText (_context.Response, "No command given", HttpStatusCode.BadRequest);
    139                                return;
    1410                        }
    1511
    1612                        WebCommandResult.ResultType responseType =
    17                                 _req.QueryString ["raw"] != null
     13                                _context.Request.QueryString ["raw"] != null
    1814                                        ? WebCommandResult.ResultType.Raw
    19                                         : (_req.QueryString ["simple"] != null
     15                                        : (_context.Request.QueryString ["simple"] != null
    2016                                                ? WebCommandResult.ResultType.ResultOnly
    2117                                                : WebCommandResult.ResultType.Full);
    2218
    23                         string commandline = _req.QueryString ["command"];
     19                        string commandline = _context.Request.QueryString ["command"];
    2420                        string commandPart = commandline.Split (' ') [0];
    2521                        string argumentsPart = commandline.Substring (Math.Min (commandline.Length, commandPart.Length + 1));
    … …  
    2824
    2925                        if (command == null) {
    30                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
    31                                 Web.SetResponseTextContent (_resp, "Unknown command");
     26                                WebUtils.WriteText (_context.Response, "Unknown command", HttpStatusCode.NotFound);
    3227                                return;
    3328                        }
    … …  
    3530                        int commandPermissionLevel = GameManager.Instance.adminTools.GetCommandPermissionLevel (command.GetCommands ());
    3631
    37                         if (_permissionLevel > commandPermissionLevel) {
    38                                 _resp.StatusCode = (int) HttpStatusCode.Forbidden;
    39                                 Web.SetResponseTextContent (_resp, "You are not allowed to execute this command");
     32                        if (_context.PermissionLevel > commandPermissionLevel) {
     33                                WebUtils.WriteText (_context.Response, "You are not allowed to execute this command", HttpStatusCode.Forbidden);
    4034                                return;
    4135                        }
    4236
    43                         _resp.SendChunked = true;
    44                         WebCommandResult wcr = new WebCommandResult (commandPart, argumentsPart, responseType, _resp);
     37                        _context.Response.SendChunked = true;
     38                        WebCommandResult wcr = new WebCommandResult (commandPart, argumentsPart, responseType, _context.Response);
    4539                        SdtdConsole.Instance.ExecuteAsync (commandline, wcr);
    4640                }

  • binary-improvements2/MapRendering/Web/API/GetAllowedCommands.cs

    r383 r387  
    11using AllocsFixes.JSON;
    2 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    3 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    42
    53namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class GetAllowedCommands : WebAPI {
    7                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    8                         int _permissionLevel) {
     4        public class GetAllowedCommands : AbsWebAPI {
     5                public override void HandleRequest (RequestContext _context) {
    96                        JSONObject result = new JSONObject ();
    107                        JSONArray entries = new JSONArray ();
    118                        foreach (IConsoleCommand cc in SdtdConsole.Instance.GetCommands ()) {
    129                                int commandPermissionLevel = GameManager.Instance.adminTools.GetCommandPermissionLevel (cc.GetCommands ());
    13                                 if (_permissionLevel <= commandPermissionLevel) {
     10                                if (_context.PermissionLevel <= commandPermissionLevel) {
    1411                                        string cmd = string.Empty;
    1512                                        foreach (string s in cc.GetCommands ()) {
    … …  
    2926                        result.Add ("commands", entries);
    3027
    31                         WriteJSON (_resp, result);
     28                        WebUtils.WriteJson (_context.Response, result);
    3229                }
    3330

  • binary-improvements2/MapRendering/Web/API/GetAnimalsLocation.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.LiveData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         internal class GetAnimalsLocation : WebAPI {
     6        internal class GetAnimalsLocation : AbsWebAPI {
    97                private readonly List<EntityAnimal> animals = new List<EntityAnimal> ();
    108
    11                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    12                         int _permissionLevel) {
     9                public override void HandleRequest (RequestContext _context) {
    1310                        JSONArray animalsJsResult = new JSONArray ();
    1411
    … …  
    3734                        }
    3835
    39                         WriteJSON (_resp, animalsJsResult);
     36                        WebUtils.WriteJson (_context.Response, animalsJsResult);
    4037                }
    4138        }

  • binary-improvements2/MapRendering/Web/API/GetHostileLocation.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.LiveData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         internal class GetHostileLocation : WebAPI {
     6        internal class GetHostileLocation : AbsWebAPI {
    97                private readonly List<EntityEnemy> enemies = new List<EntityEnemy> ();
    108
    11                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    12                         int _permissionLevel) {
     9                public override void HandleRequest (RequestContext _context) {
    1310                        JSONArray hostilesJsResult = new JSONArray ();
    1411
    … …  
    3734                        }
    3835
    39                         WriteJSON (_resp, hostilesJsResult);
     36                        WebUtils.WriteJson (_context.Response, hostilesJsResult);
    4037                }
    4138        }

  • binary-improvements2/MapRendering/Web/API/GetLandClaims.cs

    r382 r387  
    33using AllocsFixes.JSON;
    44using AllocsFixes.PersistentData;
    5 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    6 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    75
    86namespace AllocsFixes.NetConnections.Servers.Web.API {
    9         public class GetLandClaims : WebAPI {
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    11                         int _permissionLevel) {
     7        public class GetLandClaims : AbsWebAPI {
     8                public override void HandleRequest (RequestContext _context) {
    129                        PlatformUserIdentifierAbs requestedUserId = null;
    13                         if (_req.QueryString ["userid"] != null) {
    14                                 if (!PlatformUserIdentifierAbs.TryFromCombinedString (_req.QueryString ["userid"], out requestedUserId)) {
    15                                         _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    16                                         Web.SetResponseTextContent (_resp, "Invalid user id given");
     10                        if (_context.Request.QueryString ["userid"] != null) {
     11                                if (!PlatformUserIdentifierAbs.TryFromCombinedString (_context.Request.QueryString ["userid"], out requestedUserId)) {
     12                                        WebUtils.WriteText (_context.Response, "Invalid user id given", HttpStatusCode.BadRequest);
    1713                                        return;
    1814                                }
    … …  
    2016
    2117                        // default user, cheap way to avoid 'null reference exception'
    22                         PlatformUserIdentifierAbs userId = _user?.UserId;
     18                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
    2319
    24                         bool bViewAll = WebConnection.CanViewAllClaims (_permissionLevel);
     20                        bool bViewAll = WebConnection.CanViewAllClaims (_context.PermissionLevel);
    2521
    2622                        JSONObject result = new JSONObject ();
    … …  
    7470                        }
    7571
    76                         WriteJSON (_resp, result);
     72                        WebUtils.WriteJson (_context.Response, result);
    7773                }
    7874        }

  • binary-improvements2/MapRendering/Web/API/GetLog.cs

    r383 r387  
    11using System.Collections.Generic;
    22using AllocsFixes.JSON;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetLog : WebAPI {
     5        public class GetLog : AbsWebAPI {
    86                private const int MAX_COUNT = 1000;
    97               
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    11                         int _permissionLevel) {
    12                         if (_req.QueryString ["count"] == null || !int.TryParse (_req.QueryString ["count"], out int count)) {
     8                public override void HandleRequest (RequestContext _context) {
     9                        if (_context.Request.QueryString ["count"] == null || !int.TryParse (_context.Request.QueryString ["count"], out int count)) {
    1310                                count = 50;
    1411                        }
    … …  
    2623                        }
    2724
    28                         if (_req.QueryString ["firstLine"] == null || !int.TryParse (_req.QueryString ["firstLine"], out int firstLine)) {
     25                        if (_context.Request.QueryString ["firstLine"] == null || !int.TryParse (_context.Request.QueryString ["firstLine"], out int firstLine)) {
    2926                                firstLine = count > 0 ? LogBuffer.Instance.OldestLine : LogBuffer.Instance.LatestLine;
    3027                        }
    … …  
    3734                        foreach (LogBuffer.LogEntry logEntry in logEntries) {
    3835                                JSONObject entry = new JSONObject ();
    39                                 entry.Add ("date", new JSONString (logEntry.date));
    40                                 entry.Add ("time", new JSONString (logEntry.time));
    4136                                entry.Add ("isotime", new JSONString (logEntry.isoTime));
    4237                                entry.Add ("uptime", new JSONString (logEntry.uptime.ToString ()));
    … …  
    5146                        result.Add ("entries", entries);
    5247
    53                         WriteJSON (_resp, result);
     48                        WebUtils.WriteJson (_context.Response, result);
    5449                }
    5550        }

  • binary-improvements2/MapRendering/Web/API/GetPlayerInventories.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.PersistentData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         public class GetPlayerInventories : WebAPI {
    9                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    10                         int _permissionLevel) {
    11                         GetPlayerInventory.GetInventoryArguments (_req, out bool showIconColor, out bool showIconName);
     6        public class GetPlayerInventories : AbsWebAPI {
     7                public override void HandleRequest (RequestContext _context) {
     8                        GetPlayerInventory.GetInventoryArguments (_context.Request, out bool showIconColor, out bool showIconName);
    129
    1310                        JSONArray AllInventoriesResult = new JSONArray ();
    … …  
    2522                        }
    2623
    27                         WriteJSON (_resp, AllInventoriesResult);
     24                        WebUtils.WriteJson (_context.Response, AllInventoriesResult);
    2825                }
    2926        }

  • binary-improvements2/MapRendering/Web/API/GetPlayerInventory.cs

    r382 r387  
    44using AllocsFixes.PersistentData;
    55using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    6 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    76
    87namespace AllocsFixes.NetConnections.Servers.Web.API {
    9         public class GetPlayerInventory : WebAPI {
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp,
    11                         WebConnection _user, int _permissionLevel) {
    12                         if (_req.QueryString ["userid"] == null) {
    13                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    14                                 Web.SetResponseTextContent (_resp, "No user id given");
     8        public class GetPlayerInventory : AbsWebAPI {
     9                public override void HandleRequest (RequestContext _context) {
     10                        if (_context.Request.QueryString ["userid"] == null) {
     11                                WebUtils.WriteText (_context.Response, "No user id given", HttpStatusCode.BadRequest);
    1512                                return;
    1613                        }
    1714
    18                         string userIdString = _req.QueryString ["userid"];
     15                        string userIdString = _context.Request.QueryString ["userid"];
    1916                        if (!PlatformUserIdentifierAbs.TryFromCombinedString (userIdString, out PlatformUserIdentifierAbs userId)) {
    20                                 _resp.StatusCode = (int) HttpStatusCode.BadRequest;
    21                                 Web.SetResponseTextContent (_resp, "Invalid user id given");
     17                                WebUtils.WriteText (_context.Response, "Invalid user id given", HttpStatusCode.BadRequest);
    2218                                return;
    2319                        }
    … …  
    2521                        Player p = PersistentContainer.Instance.Players [userId, false];
    2622                        if (p == null) {
    27                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
    28                                 Web.SetResponseTextContent (_resp, "Unknown user id given");
     23                                WebUtils.WriteText (_context.Response, "Unknown user id given", HttpStatusCode.NotFound);
    2924                                return;
    3025                        }
    3126
    32                         GetInventoryArguments (_req, out bool showIconColor, out bool showIconName);
     27                        GetInventoryArguments (_context.Request, out bool showIconColor, out bool showIconName);
    3328
    3429                        JSONObject result = DoPlayer (userIdString, p, showIconColor, showIconName);
    3530
    36                         WriteJSON (_resp, result);
     31                        WebUtils.WriteJson (_context.Response, result);
    3732                }
    3833

  • binary-improvements2/MapRendering/Web/API/GetPlayerList.cs

    r383 r387  
    55using AllocsFixes.JSON;
    66using AllocsFixes.PersistentData;
    7 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    8 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    97
    108namespace AllocsFixes.NetConnections.Servers.Web.API {
    11         public class GetPlayerList : WebAPI {
     9        public class GetPlayerList : AbsWebAPI {
    1210                private static readonly Regex numberFilterMatcher =
    1311                        new Regex (@"^(>=|=>|>|<=|=<|<|==|=)?\s*([0-9]+(\.[0-9]*)?)$");
    … …  
    1715#endif
    1816
    19                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    20                         int _permissionLevel) {
     17                public override void HandleRequest (RequestContext _context) {
    2118                        AdminTools admTools = GameManager.Instance.adminTools;
    22                         PlatformUserIdentifierAbs userId = _user?.UserId;
    23 
    24                         bool bViewAll = WebConnection.CanViewAllPlayers (_permissionLevel);
     19                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
     20
     21                        bool bViewAll = WebConnection.CanViewAllPlayers (_context.PermissionLevel);
    2522
    2623                        // TODO: Sort (and filter?) prior to converting to JSON ... hard as how to get the correct column's data? (i.e. column name matches JSON object field names, not source data)
    2724
    2825                        int rowsPerPage = 25;
    29                         if (_req.QueryString ["rowsperpage"] != null) {
    30                                 int.TryParse (_req.QueryString ["rowsperpage"], out rowsPerPage);
     26                        if (_context.Request.QueryString ["rowsperpage"] != null) {
     27                                int.TryParse (_context.Request.QueryString ["rowsperpage"], out rowsPerPage);
    3128                        }
    3229
    3330                        int page = 0;
    34                         if (_req.QueryString ["page"] != null) {
    35                                 int.TryParse (_req.QueryString ["page"], out page);
     31                        if (_context.Request.QueryString ["page"] != null) {
     32                                int.TryParse (_context.Request.QueryString ["page"], out page);
    3633                        }
    3734
    … …  
    8380                        IEnumerable<JSONObject> list = playerList;
    8481
    85                         foreach (string key in _req.QueryString.AllKeys) {
     82                        foreach (string key in _context.Request.QueryString.AllKeys) {
    8683                                if (!string.IsNullOrEmpty (key) && key.StartsWith ("filter[")) {
    8784                                        string filterCol = key.Substring (key.IndexOf ('[') + 1);
    8885                                        filterCol = filterCol.Substring (0, filterCol.Length - 1);
    89                                         string filterVal = _req.QueryString.Get (key).Trim ();
     86                                        string filterVal = _context.Request.QueryString.Get (key).Trim ();
    9087
    9188                                        list = ExecuteFilter (list, filterCol, filterVal);
    … …  
    9592                        int totalAfterFilter = list.Count ();
    9693
    97                         foreach (string key in _req.QueryString.AllKeys) {
     94                        foreach (string key in _context.Request.QueryString.AllKeys) {
    9895                                if (!string.IsNullOrEmpty (key) && key.StartsWith ("sort[")) {
    9996                                        string sortCol = key.Substring (key.IndexOf ('[') + 1);
    10097                                        sortCol = sortCol.Substring (0, sortCol.Length - 1);
    101                                         string sortVal = _req.QueryString.Get (key);
     98                                        string sortVal = _context.Request.QueryString.Get (key);
    10299
    103100                                        list = ExecuteSort (list, sortCol, sortVal == "0");
    … …  
    120117                        result.Add ("players", playersJsResult);
    121118
    122                         WriteJSON (_resp, result);
     119                        WebUtils.WriteJson (_context.Response, result);
    123120                }
    124121

  • binary-improvements2/MapRendering/Web/API/GetPlayersLocation.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.PersistentData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         public class GetPlayersLocation : WebAPI {
    9                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    10                         int _permissionLevel) {
     6        public class GetPlayersLocation : AbsWebAPI {
     7                public override void HandleRequest (RequestContext _context) {
    118                        AdminTools admTools = GameManager.Instance.adminTools;
    12                         PlatformUserIdentifierAbs userId = _user?.UserId;
     9                        PlatformUserIdentifierAbs userId = _context.Connection?.UserId;
    1310
    1411                        bool listOffline = false;
    15                         if (_req.QueryString ["offline"] != null) {
    16                                 bool.TryParse (_req.QueryString ["offline"], out listOffline);
     12                        if (_context.Request.QueryString ["offline"] != null) {
     13                                bool.TryParse (_context.Request.QueryString ["offline"], out listOffline);
    1714                        }
    1815
    19                         bool bViewAll = WebConnection.CanViewAllPlayers (_permissionLevel);
     16                        bool bViewAll = WebConnection.CanViewAllPlayers (_context.PermissionLevel);
    2017
    2118                        JSONArray playersJsResult = new JSONArray ();
    … …  
    5754                        }
    5855
    59                         WriteJSON (_resp, playersJsResult);
     56                        WebUtils.WriteJson (_context.Response, playersJsResult);
    6057                }
    6158        }

  • binary-improvements2/MapRendering/Web/API/GetPlayersOnline.cs

    r383 r387  
    22using AllocsFixes.JSON;
    33using AllocsFixes.PersistentData;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.API {
    8         public class GetPlayersOnline : WebAPI {
    9                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    10                         int _permissionLevel) {
     6        public class GetPlayersOnline : AbsWebAPI {
     7                public override void HandleRequest (RequestContext _context) {
    118                        JSONArray players = new JSONArray ();
    129
    … …  
    4441                        }
    4542
    46                         WriteJSON (_resp, players);
     43                        WebUtils.WriteJson (_context.Response, players);
    4744                }
    4845        }

  • binary-improvements2/MapRendering/Web/API/GetServerInfo.cs

    r383 r387  
    11using System;
    22using AllocsFixes.JSON;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetServerInfo : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     5        public class GetServerInfo : AbsWebAPI {
     6                public override void HandleRequest (RequestContext _context) {
    107                        JSONObject serverInfo = new JSONObject ();
    118
    … …  
    4340
    4441
    45                         WriteJSON (_resp, serverInfo);
     42                        WebUtils.WriteJson (_context.Response, serverInfo);
    4643                }
    4744        }

  • binary-improvements2/MapRendering/Web/API/GetStats.cs

    r383 r387  
    11using AllocsFixes.JSON;
    22using AllocsFixes.LiveData;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetStats : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     5        public class GetStats : AbsWebAPI {
     6                public override void HandleRequest (RequestContext _context) {
    107                        JSONObject result = new JSONObject ();
    118
    … …  
    2017                        result.Add ("animals", new JSONNumber (Animals.Instance.GetCount ()));
    2118
    22                         WriteJSON (_resp, result);
     19                        WebUtils.WriteJson (_context.Response, result);
    2320                }
    2421

  • binary-improvements2/MapRendering/Web/API/GetWebMods.cs

    r384 r387  
    11using AllocsFixes.JSON;
    2 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    3 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    42
    53namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class GetWebMods : WebAPI {
     4        public class GetWebMods : AbsWebAPI {
    75                private readonly JSONArray loadedWebMods = new JSONArray ();
    86
    … …  
    2725                }
    2826
    29                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    30                         int _permissionLevel) {
    31 
    32                         WriteJSON (_resp, loadedWebMods);
     27                public override void HandleRequest (RequestContext _context) {
     28                        WebUtils.WriteJson (_context.Response, loadedWebMods);
    3329                }
    3430

  • binary-improvements2/MapRendering/Web/API/GetWebUIUpdates.cs

    r383 r387  
    11using AllocsFixes.JSON;
    22using AllocsFixes.LiveData;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    53
    64namespace AllocsFixes.NetConnections.Servers.Web.API {
    7         public class GetWebUIUpdates : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    9                         int _permissionLevel) {
     5        public class GetWebUIUpdates : AbsWebAPI {
     6                public override void HandleRequest (RequestContext _context) {
    107                        int latestLine;
    11                         if (_req.QueryString ["latestLine"] == null ||
    12                             !int.TryParse (_req.QueryString ["latestLine"], out latestLine)) {
     8                        if (_context.Request.QueryString ["latestLine"] == null ||
     9                            !int.TryParse (_context.Request.QueryString ["latestLine"], out latestLine)) {
    1310                                latestLine = 0;
    1411                        }
    … …  
    2825                        result.Add ("newlogs", new JSONNumber (LogBuffer.Instance.LatestLine - latestLine));
    2926
    30                         WriteJSON (_resp, result);
     27                        WebUtils.WriteJson (_context.Response, result);
    3128                }
    3229

  • binary-improvements2/MapRendering/Web/API/Null.cs

    r383 r387  
    11using System.Text;
    2 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    3 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    42
    53namespace AllocsFixes.NetConnections.Servers.Web.API {
    6         public class Null : WebAPI {
     4        public class Null : AbsWebAPI {
    75                public Null (string _name) : base(_name) {
    86                }
    97               
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
    11                         int _permissionLevel) {
    12                         _resp.ContentLength64 = 0;
    13                         _resp.ContentType = "text/plain";
    14                         _resp.ContentEncoding = Encoding.ASCII;
    15                         _resp.OutputStream.Write (new byte[] { }, 0, 0);
     8                public override void HandleRequest (RequestContext _context) {
     9                        _context.Response.ContentLength64 = 0;
     10                        _context.Response.ContentType = "text/plain";
     11                        _context.Response.ContentEncoding = Encoding.ASCII;
     12                        _context.Response.OutputStream.Write (new byte[] { }, 0, 0);
    1613                }
    1714        }

  • binary-improvements2/MapRendering/Web/Handlers/AbsHandler.cs

    r383 r387  
    1 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    2 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    3 
    41namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    52        public abstract class AbsHandler {
    … …  
    1613                }
    1714
    18                 public abstract void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    19                         int _permissionLevel);
     15                public abstract void HandleRequest (RequestContext _context);
    2016
    2117                public virtual bool IsAuthorizedForHandler (WebConnection _user, int _permissionLevel) {

  • binary-improvements2/MapRendering/Web/Handlers/ApiHandler.cs

    r384 r387  
    44using System.Reflection;
    55using AllocsFixes.NetConnections.Servers.Web.API;
    6 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    7 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    86
    97namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    108        public class ApiHandler : AbsHandler {
    11                 private readonly Dictionary<string, WebAPI> apis = new CaseInsensitiveStringDictionary<WebAPI> ();
     9                private readonly Dictionary<string, AbsWebAPI> apis = new CaseInsensitiveStringDictionary<AbsWebAPI> ();
    1210
    1311                public ApiHandler () : base (null) {
    … …  
    2523                       
    2624                        foreach (Type t in Assembly.GetExecutingAssembly ().GetTypes ()) {
    27                                 if (!t.IsAbstract && t.IsSubclassOf (typeof (WebAPI))) {
     25                                if (!t.IsAbstract && t.IsSubclassOf (typeof (AbsWebAPI))) {
    2826                                        ConstructorInfo ctor = t.GetConstructor (apiWithParentCtorTypes);
    2927                                        if (ctor != null) {
    30                                                 WebAPI apiInstance = (WebAPI) ctor.Invoke (apiWithParentCtorArgs);
     28                                                AbsWebAPI apiInstance = (AbsWebAPI) ctor.Invoke (apiWithParentCtorArgs);
    3129                                                addApi (apiInstance);
    3230                                                continue;
    … …  
    3533                                        ctor = t.GetConstructor (apiEmptyCtorTypes);
    3634                                        if (ctor != null) {
    37                                                 WebAPI apiInstance = (WebAPI) ctor.Invoke (apiEmptyCtorArgs);
     35                                                AbsWebAPI apiInstance = (AbsWebAPI) ctor.Invoke (apiEmptyCtorArgs);
    3836                                                addApi (apiInstance);
    3937                                        }
    … …  
    4644                }
    4745
    48                 private void addApi (WebAPI _api) {
     46                private void addApi (AbsWebAPI _api) {
    4947                        apis.Add (_api.Name, _api);
    5048                        WebPermissions.Instance.AddKnownModule ("webapi." + _api.Name, _api.DefaultPermissionLevel ());
    … …  
    5553#endif
    5654
    57                 public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    58                         int _permissionLevel) {
    59                         string apiName = _requestPath.Remove (0, urlBasePath.Length);
     55                public override void HandleRequest (RequestContext _context) {
    6056
    61                         if (!apis.TryGetValue (apiName, out WebAPI api)) {
     57                        string apiName;
     58                        string subPath = null;
     59
     60                        int pathSeparatorIndex = _context.RequestPath.IndexOf ('/', urlBasePath.Length);
     61                        if (pathSeparatorIndex >= 0) {
     62                                apiName = _context.RequestPath.Substring (urlBasePath.Length, pathSeparatorIndex - urlBasePath.Length);
     63                                subPath = _context.RequestPath.Substring (pathSeparatorIndex + 1);
     64                        } else {
     65                                apiName = _context.RequestPath.Substring (urlBasePath.Length);
     66                        }
     67                       
     68                        if (!apis.TryGetValue (apiName, out AbsWebAPI api)) {
    6269                                Log.Out ($"Error in {nameof(ApiHandler)}.HandleRequest(): No handler found for API \"{apiName}\"");
    63                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
     70                                _context.Response.StatusCode = (int) HttpStatusCode.NotFound;
    6471                                return;
    6572                        }
    6673
    67                         if (!AuthorizeForApi (apiName, _permissionLevel)) {
    68                                 _resp.StatusCode = (int) HttpStatusCode.Forbidden;
    69                                 if (_con != null) {
     74                        if (!AuthorizeForApi (apiName, _context.PermissionLevel)) {
     75                                _context.Response.StatusCode = (int) HttpStatusCode.Forbidden;
     76                                if (_context.Connection != null) {
    7077                                        //Log.Out ($"{nameof(ApiHandler)}: user '{user.SteamID}' not allowed to execute '{apiName}'");
    7178                                }
    … …  
    7481                        }
    7582
     83                        _context.RequestPath = subPath;
     84
    7685                        try {
    7786#if ENABLE_PROFILER
    7887                                apiHandlerSampler.Begin ();
    7988#endif
    80                                 api.HandleRequest (_req, _resp, _con, _permissionLevel);
     89                                api.HandleRequest (_context);
    8190#if ENABLE_PROFILER
    8291                                apiHandlerSampler.End ();
    … …  
    8594                                Log.Error ($"Error in {nameof(ApiHandler)}.HandleRequest(): Handler {api.Name} threw an exception:");
    8695                                Log.Exception (e);
    87                                 _resp.StatusCode = (int) HttpStatusCode.InternalServerError;
     96                                _context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
    8897                        }
    8998                }

  • binary-improvements2/MapRendering/Web/Handlers/ItemIconHandler.cs

    r382 r387  
    44using System.Net;
    55using UnityEngine;
    6 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    7 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    86using Object = UnityEngine.Object;
    97
    … …  
    2624                public static ItemIconHandler Instance { get; private set; }
    2725
    28                 public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    29                         int _permissionLevel) {
     26                public override void HandleRequest (RequestContext _context) {
    3027                        if (!loaded) {
    31                                 _resp.StatusCode = (int) HttpStatusCode.InternalServerError;
     28                                _context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
    3229                                Log.Out ("Web:IconHandler: Icons not loaded");
    3330                                return;
    3431                        }
    3532
    36                         string requestFileName = _requestPath.Remove (0, urlBasePath.Length);
     33                        string requestFileName = _context.RequestPath.Remove (0, urlBasePath.Length);
    3734                        requestFileName = requestFileName.Remove (requestFileName.LastIndexOf ('.'));
    3835
    39                         if (icons.ContainsKey (requestFileName) && _requestPath.EndsWith (".png", StringComparison.OrdinalIgnoreCase)) {
    40                                 _resp.ContentType = MimeType.GetMimeType (".png");
     36                        if (icons.ContainsKey (requestFileName) && _context.RequestPath.EndsWith (".png", StringComparison.OrdinalIgnoreCase)) {
     37                                _context.Response.ContentType = MimeType.GetMimeType (".png");
    4138
    4239                                byte[] itemIconData = icons [requestFileName];
    4340
    44                                 _resp.ContentLength64 = itemIconData.Length;
    45                                 _resp.OutputStream.Write (itemIconData, 0, itemIconData.Length);
     41                                _context.Response.ContentLength64 = itemIconData.Length;
     42                                _context.Response.OutputStream.Write (itemIconData, 0, itemIconData.Length);
    4643                        } else {
    47                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
     44                                _context.Response.StatusCode = (int) HttpStatusCode.NotFound;
    4845                                if (logMissingFiles) {
    49                                         Log.Out ("Web:IconHandler:FileNotFound: \"" + _requestPath + "\" ");
     46                                        Log.Out ("Web:IconHandler:FileNotFound: \"" + _context.RequestPath + "\" ");
    5047                                }
    5148                        }

  • binary-improvements2/MapRendering/Web/Handlers/RewriteHandler.cs

    r382 r387  
    1 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    2 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    3 
    41namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    52        public class RewriteHandler : AbsHandler {
    … …  
    129                }
    1310
    14                 public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    15                         int _permissionLevel) {
    16                         string newRequestPath = fixedTarget ? target : target + _requestPath.Remove (0, urlBasePath.Length);
    17                         parent.ApplyPathHandler (newRequestPath, _req, _resp, _con, _permissionLevel);
     11                public override void HandleRequest (RequestContext _context) {
     12                        _context.RequestPath = fixedTarget ? target : target + _context.RequestPath.Remove (0, urlBasePath.Length);
     13                        parent.ApplyPathHandler (_context);
    1814                }
    1915        }

  • binary-improvements2/MapRendering/Web/Handlers/SessionHandler.cs

    r382 r387  
    33using System.Net;
    44using System.Text;
    5 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    6 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    75
    86namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    … …  
    2927                }
    3028
    31                 public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    32                         int _permissionLevel) {
     29                public override void HandleRequest (RequestContext _context) {
    3330                       
    34                         IPEndPoint reqRemoteEndPoint = _req.RemoteEndPoint;
     31                        IPEndPoint reqRemoteEndPoint = _context.Request.RemoteEndPoint;
    3532                        if (reqRemoteEndPoint == null) {
    36                                 _resp.Redirect (pageBasePath);
     33                                _context.Response.Redirect (pageBasePath);
    3734                                return;
    3835                        }
    3936
    40                         string subpath = _requestPath.Remove (0, urlBasePath.Length);
     37                        string subpath = _context.RequestPath.Remove (0, urlBasePath.Length);
    4138
    4239                        StringBuilder result = new StringBuilder ();
    … …  
    4744
    4845                                try {
    49                                         ulong id = OpenID.Validate (_req);
     46                                        ulong id = OpenID.Validate (_context.Request);
    5047                                        if (id > 0) {
    5148                                                WebConnection con = connectionHandler.LogIn (id, reqRemoteEndPoint.Address);
    … …  
    6057                                                        Secure = false
    6158                                                };
    62                                                 _resp.AppendCookie (cookie);
    63                                                 _resp.Redirect (pageBasePath);
     59                                                _context.Response.AppendCookie (cookie);
     60                                                _context.Response.Redirect (pageBasePath);
    6461
    6562                                                return;
    … …  
    7370                                result.Append ($"<h1>Login failed, <a href=\"{pageBasePath}\">click to return to main page</a>.</h1>");
    7471                        } else if (subpath.StartsWith ("logout")) {
    75                                 if (_con != null) {
    76                                         connectionHandler.LogOut (_con.SessionID);
     72                                if (_context.Connection != null) {
     73                                        connectionHandler.LogOut (_context.Connection.SessionID);
    7774                                        Cookie cookie = new Cookie ("sid", "", "/") {
    7875                                                Expired = true
    7976                                        };
    80                                         _resp.AppendCookie (cookie);
    81                                         _resp.Redirect (pageBasePath);
     77                                        _context.Response.AppendCookie (cookie);
     78                                        _context.Response.Redirect (pageBasePath);
    8279                                        return;
    8380                                }
    … …  
    8582                                result.Append ($"<h1>Not logged in, <a href=\"{pageBasePath}\">click to return to main page</a>.</h1>");
    8683                        } else if (subpath.StartsWith (steamLoginUrl)) {
    87                                 string host = (Web.IsSslRedirected (_req) ? "https://" : "http://") + _req.UserHostName;
     84                                string host = (Web.IsSslRedirected (_context.Request) ? "https://" : "http://") + _context.Request.UserHostName;
    8885                                string url = OpenID.GetOpenIdLoginUrl (host, host + urlBasePath + steamOpenIdVerifyUrl);
    89                                 _resp.Redirect (url);
     86                                _context.Response.Redirect (url);
    9087                                return;
    9188                        } else {
    … …  
    9592                        result.Append (footer);
    9693
    97                         _resp.ContentType = MimeType.GetMimeType (".html");
    98                         _resp.ContentEncoding = Encoding.UTF8;
    99                         byte[] buf = Encoding.UTF8.GetBytes (result.ToString ());
    100                         _resp.ContentLength64 = buf.Length;
    101                         _resp.OutputStream.Write (buf, 0, buf.Length);
     94                        WebUtils.WriteText (_context.Response, result.ToString (), _mimeType: WebUtils.MimeHtml);
    10295                }
    10396        }

  • binary-improvements2/MapRendering/Web/Handlers/SimpleRedirectHandler.cs

    r383 r387  
    1 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    2 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    3 
    41namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    52        public class SimpleRedirectHandler : AbsHandler {
    … …  
    107                }
    118
    12                 public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    13                         int _permissionLevel) {
    14                         _resp.Redirect (target);
     9                public override void HandleRequest (RequestContext _context) {
     10                        _context.Response.Redirect (target);
    1511                }
    1612        }

  • binary-improvements2/MapRendering/Web/Handlers/StaticHandler.cs

    r382 r387  
    22using System.Net;
    33using AllocsFixes.FileCache;
    4 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    5 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    64
    75namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    … …  
    1816                }
    1917
    20                 public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    21                         int _permissionLevel) {
    22                         string fn = _requestPath.Remove (0, urlBasePath.Length);
     18                public override void HandleRequest (RequestContext _context) {
     19                        string fn = _context.RequestPath.Remove (0, urlBasePath.Length);
    2320
    2421                        byte[] content = cache.GetFileContent (datapath + fn);
    2522
    2623                        if (content != null) {
    27                                 _resp.ContentType = MimeType.GetMimeType (Path.GetExtension (fn));
    28                                 _resp.ContentLength64 = content.Length;
    29                                 _resp.OutputStream.Write (content, 0, content.Length);
     24                                _context.Response.ContentType = MimeType.GetMimeType (Path.GetExtension (fn));
     25                                _context.Response.ContentLength64 = content.Length;
     26                                _context.Response.OutputStream.Write (content, 0, content.Length);
    3027                        } else {
    31                                 _resp.StatusCode = (int) HttpStatusCode.NotFound;
     28                                _context.Response.StatusCode = (int) HttpStatusCode.NotFound;
    3229                                if (logMissingFiles) {
    33                                         Log.Out ("Web:Static:FileNotFound: \"" + _requestPath + "\" @ \"" + datapath + fn + "\"");
     30                                        Log.Out ("Web:Static:FileNotFound: \"" + _context.RequestPath + "\" @ \"" + datapath + fn + "\"");
    3431                                }
    3532                        }

  • binary-improvements2/MapRendering/Web/Handlers/UserStatusHandler.cs

    r382 r387  
    11using AllocsFixes.JSON;
    2 using AllocsFixes.NetConnections.Servers.Web.API;
    3 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    4 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    52
    63namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    … …  
    96                }
    107
    11                 public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    12                         int _permissionLevel) {
     8                public override void HandleRequest (RequestContext _context) {
    139                        JSONObject result = new JSONObject ();
    1410
    15                         result.Add ("loggedin", new JSONBoolean (_con != null));
    16                         result.Add ("username", new JSONString (_con != null ? _con.UserId.ToString () : string.Empty));
     11                        result.Add ("loggedin", new JSONBoolean (_context.Connection != null));
     12                        result.Add ("username", new JSONString (_context.Connection != null ? _context.Connection.UserId.ToString () : string.Empty));
    1713
    1814                        JSONArray perms = new JSONArray ();
    … …  
    2016                                JSONObject permObj = new JSONObject ();
    2117                                permObj.Add ("module", new JSONString (perm.module));
    22                                 permObj.Add ("allowed", new JSONBoolean (perm.permissionLevel >= _permissionLevel));
     18                                permObj.Add ("allowed", new JSONBoolean (perm.permissionLevel >= _context.PermissionLevel));
    2319                                perms.Add (permObj);
    2420                        }
    … …  
    2622                        result.Add ("permissions", perms);
    2723
    28                         WebAPI.WriteJSON (_resp, result);
     24                        WebUtils.WriteJson (_context.Response, result);
    2925                }
    3026        }

  • binary-improvements2/MapRendering/Web/LogBuffer.cs

    r382 r387  
    127127                public class LogEntry {
    128128                        public readonly DateTime timestamp;
    129                         public readonly string date;
    130                         public readonly string time;
    131129                        public readonly string isoTime;
    132130                        public readonly string message;
    … …  
    137135                        public LogEntry (DateTime _timestamp, string _message, string _trace, LogType _type, long _uptime) {
    138136                                timestamp = _timestamp;
    139                                 date = $"{_timestamp.Year:0000}-{_timestamp.Month:00}-{_timestamp.Day:00}";
    140                                 time = $"{_timestamp.Hour:00}:{_timestamp.Minute:00}:{_timestamp.Second:00}";
    141137                                isoTime = _timestamp.ToString ("o");
    142138

  • binary-improvements2/MapRendering/Web/SSE/EventLog.cs

    r382 r387  
    1010
    1111                private void LogCallback (string _formattedMsg, string _plainMsg, string _trace, LogType _type, DateTime _timestamp, long _uptime) {
    12                         string date = $"{_timestamp.Year:0000}-{_timestamp.Month:00}-{_timestamp.Day:00}";
    13                         string time = $"{_timestamp.Hour:00}:{_timestamp.Minute:00}:{_timestamp.Second:00}";
    1412                        string isotime = _timestamp.ToString ("o");
    1513                        string uptime = _uptime.ToString ();
    … …  
    2018                        data.Add ("type", new JSONString (_type.ToStringCached ()));
    2119                        data.Add ("trace", new JSONString (_trace));
    22                         data.Add ("date", new JSONString (date));
    23                         data.Add ("time", new JSONString (time));
    2420                        data.Add ("isotime", new JSONString (isotime));
    2521                        data.Add ("uptime", new JSONString (uptime));

  • binary-improvements2/MapRendering/Web/SSE/SseHandler.cs

    r382 r387  
    55using System.Threading;
    66using AllocsFixes.NetConnections.Servers.Web.Handlers;
    7 using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
    8 using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    97
    108// Implemented following HTML spec
    … …  
    5250                }
    5351
    54                 public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    55                         int _permissionLevel) {
    56                         string eventName = _requestPath.Remove (0, urlBasePath.Length);
     52                public override void HandleRequest (RequestContext _context) {
     53                        string eventName = _context.RequestPath.Remove (0, urlBasePath.Length);
    5754
    5855                        if (!events.TryGetValue (eventName, out EventBase eventInstance)) {
    5956                                Log.Out ($"Error in {nameof (SseHandler)}.HandleRequest(): No handler found for event \"{eventName}\"");
    60                                 _resp.StatusCode = (int)HttpStatusCode.NotFound;
     57                                _context.Response.StatusCode = (int)HttpStatusCode.NotFound;
    6158                                return;
    6259                        }
    6360
    64                         if (!IsAuthorizedForEvent (eventName, _permissionLevel)) {
    65                                 _resp.StatusCode = (int)HttpStatusCode.Forbidden;
    66                                 if (_con != null) {
     61                        if (!IsAuthorizedForEvent (eventName, _context.PermissionLevel)) {
     62                                _context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
     63                                if (_context.Connection != null) {
    6764                                        //Log.Out ($"{nameof(SseHandler)}: user '{user.SteamID}' not allowed to access '{eventName}'");
    6865                                }
    … …  
    7269
    7370                        try {
    74                                 eventInstance.AddListener (_resp);
     71                                eventInstance.AddListener (_context.Response);
    7572
    7673                                // Keep the request open
    77                                 _resp.SendChunked = true;
     74                                _context.Response.SendChunked = true;
    7875
    79                                 _resp.AddHeader ("Content-Type", "text/event-stream");
    80                                 _resp.OutputStream.Flush ();
     76                                _context.Response.AddHeader ("Content-Type", "text/event-stream");
     77                                _context.Response.OutputStream.Flush ();
    8178                        } catch (Exception e) {
    8279                                Log.Error ($"Error in {nameof (SseHandler)}.HandleRequest(): Handler {eventInstance.Name} threw an exception:");
    8380                                Log.Exception (e);
    84                                 _resp.StatusCode = (int)HttpStatusCode.InternalServerError;
     81                                _context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
    8582                        }
    8683                }

  • binary-improvements2/MapRendering/Web/Web.cs

    r384 r387  
    66using HttpStatusCode = System.Net.HttpStatusCode;
    77using IPEndPoint = System.Net.IPEndPoint;
    8 using System.Text;
    98using System.Threading;
    109using AllocsFixes.FileCache;
    … …  
    226225                                        return;
    227226                                }
    228                                
    229                                 ApplyPathHandler (requestPath, request, response, conn, permissionLevel);
     227
     228                                RequestContext context = new RequestContext (requestPath, request, response, conn, permissionLevel);
     229                               
     230                                ApplyPathHandler (context);
    230231
    231232                        } catch (IOException e) {
    … …  
    252253                }
    253254
    254                 public void ApplyPathHandler (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    255                         int _permissionLevel) {
     255                public void ApplyPathHandler (RequestContext _context) {
    256256                        for (int i = handlers.Count - 1; i >= 0; i--) {
    257257                                AbsHandler handler = handlers [i];
    258258                               
    259                                 if (_requestPath.StartsWith (handler.UrlBasePath)) {
    260                                         if (!handler.IsAuthorizedForHandler (_con, _permissionLevel)) {
    261                                                 _resp.StatusCode = (int)HttpStatusCode.Forbidden;
    262                                                 if (_con != null) {
     259                                if (_context.RequestPath.StartsWith (handler.UrlBasePath)) {
     260                                        if (!handler.IsAuthorizedForHandler (_context.Connection, _context.PermissionLevel)) {
     261                                                _context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
     262                                                if (_context.Connection != null) {
    263263                                                        //Log.Out ("Web.HandleRequest: user '{0}' not allowed to access '{1}'", _con.SteamID, handler.ModuleName);
    264264                                                }
    … …  
    267267                                                handlerSampler.Begin ();
    268268#endif
    269                                                 handler.HandleRequest (_requestPath, _req, _resp, _con, _permissionLevel);
     269                                                handler.HandleRequest (_context);
    270270#if ENABLE_PROFILER
    271271                                                handlerSampler.End ();
    … …  
    279279                        // Not really relevant for non-debugging purposes:
    280280                        //Log.Out ("Error in Web.HandleRequest(): No handler found for path \"" + _requestPath + "\"");
    281                         _resp.StatusCode = (int) HttpStatusCode.NotFound;
     281                        _context.Response.StatusCode = (int) HttpStatusCode.NotFound;
    282282                }
    283283
    … …  
    314314                        return guestPermissionLevel;
    315315                }
    316 
    317                 public static void SetResponseTextContent (HttpListenerResponse _resp, string _text) {
    318                         byte[] buf = Encoding.UTF8.GetBytes (_text);
    319                         _resp.ContentLength64 = buf.Length;
    320                         _resp.ContentType = "text/html";
    321                         _resp.ContentEncoding = Encoding.UTF8;
    322                         _resp.OutputStream.Write (buf, 0, buf.Length);
    323                 }
    324316        }
    325317}

  • binary-improvements2/MapRendering/Web/WebCommandResult.cs

    r382 r387  
    4949
    5050                                if (responseType == ResultType.Raw) {
    51                                         WebAPI.WriteText (response, sb.ToString ());
     51                                        WebUtils.WriteText (response, sb.ToString ());
    5252                                } else {
    5353                                        JSONNode result;
    … …  
    6464                                        }
    6565
    66                                         WebAPI.WriteJSON (response, result);
     66                                        WebUtils.WriteJson (response, result);
    6767                                }
    6868                        } catch (IOException e) {

  • binary-improvements2/MapRendering/WebAndMapRendering.csproj

    r386 r387  
    1111    <AssemblyName>MapRendering</AssemblyName>
    1212    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     13    <LangVersion>8</LangVersion>
    1314  </PropertyGroup>
    1415  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    … …  
    8687    <Compile Include="Commands\EnableRendering.cs" />
    8788    <Compile Include="API.cs" />
     89    <Compile Include="Web\API\AbsRestApi.cs" />
    8890    <Compile Include="Web\API\GetAnimalsLocation.cs" />
    8991    <Compile Include="Web\API\GetHostileLocation.cs" />
    9092    <Compile Include="Web\API\GetWebMods.cs" />
     93    <Compile Include="Web\API\Markers.cs" />
    9194    <Compile Include="Web\API\Null.cs" />
    9295    <Compile Include="Web\Handlers\RewriteHandler.cs" />
     96    <Compile Include="Web\RequestContext.cs" />
    9397    <Compile Include="Web\SSE\EventLog.cs" />
    9498    <Compile Include="Web\SSE\SseHandler.cs" />
    … …  
    97101    <Compile Include="Web\MimeType.cs" />
    98102    <Compile Include="Web\API\GetPlayersOnline.cs" />
    99     <Compile Include="Web\API\WebAPI.cs" />
     103    <Compile Include="Web\API\AbsWebAPI.cs" />
    100104    <Compile Include="Web\API\GetPlayersLocation.cs" />
    101105    <Compile Include="Web\API\GetPlayerInventory.cs" />
    … …  
    128132    <Compile Include="Commands\EnableOpenIDDebug.cs" />
    129133    <Compile Include="Web\API\GetPlayerInventories.cs" />
     134    <Compile Include="Web\WebUtils.cs" />
    130135  </ItemGroup>
    131136  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
Note: See TracChangeset for help on using the changeset viewer.