Ignore:
Timestamp:
Aug 1, 2022, 12:54:31 PM (2 years ago)
Author:
alloc
Message:

Switched to use SpaceWizards.HttpListener

Location:
binary-improvements2/MapRendering/Web/Handlers
Files:
1 added
6 edited
1 moved

Legend:

Unmodified
Added
Removed
  • binary-improvements2/MapRendering/Web/Handlers/AbsHandler.cs

    r381 r382  
    11using System.Net;
     2using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
     3using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    24
    35namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    4         public abstract class PathHandler {
     6        public abstract class AbsHandler {
    57                protected readonly string moduleName;
    68                protected string urlBasePath;
    79                protected Web parent;
    810
    9                 protected PathHandler (string _moduleName, int _defaultPermissionLevel = 0) {
     11                public string ModuleName => moduleName;
     12                public string UrlBasePath => urlBasePath;
     13
     14                protected AbsHandler (string _moduleName, int _defaultPermissionLevel = 0) {
    1015                        moduleName = _moduleName;
    1116                        WebPermissions.Instance.AddKnownModule (_moduleName, _defaultPermissionLevel);
    1217                }
    1318
    14                 public string ModuleName => moduleName;
    15 
    16                 public abstract void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     19                public abstract void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    1720                        int _permissionLevel);
    1821
  • binary-improvements2/MapRendering/Web/Handlers/ApiHandler.cs

    r367 r382  
    44using System.Reflection;
    55using AllocsFixes.NetConnections.Servers.Web.API;
     6using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
     7using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    68
    79namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    8         public class ApiHandler : PathHandler {
     10        public class ApiHandler : AbsHandler {
    911                private readonly Dictionary<string, WebAPI> apis = new CaseInsensitiveStringDictionary<WebAPI> ();
    1012
     
    3537#endif
    3638
    37                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     39                public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    3840                        int _permissionLevel) {
    39                         string apiName = _req.Url.AbsolutePath.Remove (0, urlBasePath.Length);
     41                        string apiName = _requestPath.Remove (0, urlBasePath.Length);
    4042
    4143                        if (!apis.TryGetValue (apiName, out WebAPI api)) {
     
    4749                        if (!AuthorizeForApi (apiName, _permissionLevel)) {
    4850                                _resp.StatusCode = (int) HttpStatusCode.Forbidden;
    49                                 if (_user != null) {
     51                                if (_con != null) {
    5052                                        //Log.Out ($"{nameof(ApiHandler)}: user '{user.SteamID}' not allowed to execute '{apiName}'");
    5153                                }
     
    5860                                apiHandlerSampler.Begin ();
    5961#endif
    60                                 api.HandleRequest (_req, _resp, _user, _permissionLevel);
     62                                api.HandleRequest (_req, _resp, _con, _permissionLevel);
    6163#if ENABLE_PROFILER
    6264                                apiHandlerSampler.End ();
  • binary-improvements2/MapRendering/Web/Handlers/ItemIconHandler.cs

    r369 r382  
    44using System.Net;
    55using UnityEngine;
     6using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
     7using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    68using Object = UnityEngine.Object;
    79
    810namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    9         public class ItemIconHandler : PathHandler {
     11        public class ItemIconHandler : AbsHandler {
    1012                private readonly Dictionary<string, byte[]> icons = new Dictionary<string, byte[]> ();
    1113                private readonly bool logMissingFiles;
     
    2426                public static ItemIconHandler Instance { get; private set; }
    2527
    26                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     28                public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    2729                        int _permissionLevel) {
    2830                        if (!loaded) {
     
    3234                        }
    3335
    34                         string requestFileName = _req.Url.AbsolutePath.Remove (0, urlBasePath.Length);
     36                        string requestFileName = _requestPath.Remove (0, urlBasePath.Length);
    3537                        requestFileName = requestFileName.Remove (requestFileName.LastIndexOf ('.'));
    3638
    37                         if (icons.ContainsKey (requestFileName) && _req.Url.AbsolutePath.EndsWith (".png", StringComparison.OrdinalIgnoreCase)) {
     39                        if (icons.ContainsKey (requestFileName) && _requestPath.EndsWith (".png", StringComparison.OrdinalIgnoreCase)) {
    3840                                _resp.ContentType = MimeType.GetMimeType (".png");
    3941
     
    4547                                _resp.StatusCode = (int) HttpStatusCode.NotFound;
    4648                                if (logMissingFiles) {
    47                                         Log.Out ("Web:IconHandler:FileNotFound: \"" + _req.Url.AbsolutePath + "\" ");
     49                                        Log.Out ("Web:IconHandler:FileNotFound: \"" + _requestPath + "\" ");
    4850                                }
    4951                        }
  • binary-improvements2/MapRendering/Web/Handlers/SessionHandler.cs

    r367 r382  
     1using System;
    12using System.IO;
    23using System.Net;
    34using System.Text;
     5using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
     6using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    47
    58namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    6         public class SessionHandler : PathHandler {
     9        public class SessionHandler : AbsHandler {
     10                private const string pageBasePath = "/";
     11                private const string steamOpenIdVerifyUrl = "verifysteamopenid";
     12                private const string steamLoginUrl = "loginsteam";
     13               
    714                private readonly string footer = "";
    815                private readonly string header = "";
    916
    10                 public SessionHandler (string _dataFolder, string _moduleName = null) : base (_moduleName) {
     17                private readonly ConnectionHandler connectionHandler;
     18
     19                public SessionHandler (string _dataFolder, ConnectionHandler _connectionHandler) : base (null) {
     20                        connectionHandler = _connectionHandler;
     21                       
    1122                        if (File.Exists (_dataFolder + "/sessionheader.tmpl")) {
    1223                                header = File.ReadAllText (_dataFolder + "/sessionheader.tmpl");
     
    1829                }
    1930
    20                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     31                public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    2132                        int _permissionLevel) {
    22                         string subpath = _req.Url.AbsolutePath.Remove (0, urlBasePath.Length);
     33                       
     34                        IPEndPoint reqRemoteEndPoint = _req.RemoteEndPoint;
     35                        if (reqRemoteEndPoint == null) {
     36                                _resp.Redirect (pageBasePath);
     37                                return;
     38                        }
     39
     40                        string subpath = _requestPath.Remove (0, urlBasePath.Length);
    2341
    2442                        StringBuilder result = new StringBuilder ();
    2543                        result.Append (header);
    2644
    27                         if (subpath.StartsWith ("verify")) {
    28                                 if (_user != null) {
    29                                         _resp.Redirect ("/static/index.html");
     45                        if (subpath.StartsWith (steamOpenIdVerifyUrl)) {
     46                                string remoteEndpointString = reqRemoteEndPoint.ToString ();
     47
     48                                try {
     49                                        ulong id = OpenID.Validate (_req);
     50                                        if (id > 0) {
     51                                                WebConnection con = connectionHandler.LogIn (id, reqRemoteEndPoint.Address);
     52                                                int level = GameManager.Instance.adminTools.GetUserPermissionLevel (con.UserId);
     53                                                Log.Out ("Steam OpenID login from {0} with ID {1}, permission level {2}",
     54                                                        remoteEndpointString, con.UserId, level);
     55                                               
     56                                                Cookie cookie = new Cookie ("sid", con.SessionID, "/") {
     57                                                        Expired = false,
     58                                                        Expires = DateTime.MinValue,
     59                                                        HttpOnly = true,
     60                                                        Secure = false
     61                                                };
     62                                                _resp.AppendCookie (cookie);
     63                                                _resp.Redirect (pageBasePath);
     64
     65                                                return;
     66                                        }
     67                                } catch (Exception e) {
     68                                        Log.Error ("Error validating login:");
     69                                        Log.Exception (e);
     70                                }
     71
     72                                Log.Out ($"Steam OpenID login failed from {remoteEndpointString}");
     73                                result.Append ($"<h1>Login failed, <a href=\"{pageBasePath}\">click to return to main page</a>.</h1>");
     74                        } else if (subpath.StartsWith ("logout")) {
     75                                if (_con != null) {
     76                                        connectionHandler.LogOut (_con.SessionID);
     77                                        Cookie cookie = new Cookie ("sid", "", "/") {
     78                                                Expired = true
     79                                        };
     80                                        _resp.AppendCookie (cookie);
     81                                        _resp.Redirect (pageBasePath);
    3082                                        return;
    3183                                }
    3284
    33                                 result.Append (
    34                                         "<h1>Login failed, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    35                         } else if (subpath.StartsWith ("logout")) {
    36                                 if (_user != null) {
    37                                         parent.connectionHandler.LogOut (_user.SessionID);
    38                                         Cookie cookie = new Cookie ("sid", "", "/");
    39                                         cookie.Expired = true;
    40                                         _resp.AppendCookie (cookie);
    41                                         _resp.Redirect ("/static/index.html");
    42                                         return;
    43                                 }
    44 
    45                                 result.Append (
    46                                         "<h1>Not logged in, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    47                         } else if (subpath.StartsWith ("login")) {
     85                                result.Append ($"<h1>Not logged in, <a href=\"{pageBasePath}\">click to return to main page</a>.</h1>");
     86                        } else if (subpath.StartsWith (steamLoginUrl)) {
    4887                                string host = (Web.IsSslRedirected (_req) ? "https://" : "http://") + _req.UserHostName;
    49                                 string url = OpenID.GetOpenIdLoginUrl (host, host + "/session/verify");
     88                                string url = OpenID.GetOpenIdLoginUrl (host, host + urlBasePath + steamOpenIdVerifyUrl);
    5089                                _resp.Redirect (url);
    5190                                return;
    5291                        } else {
    53                                 result.Append (
    54                                         "<h1>Unknown command, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
     92                                result.Append ($"<h1>Unknown command, <a href=\"{pageBasePath}\">click to return to main page</a>.</h1>");
    5593                        }
    5694
  • binary-improvements2/MapRendering/Web/Handlers/SimpleRedirectHandler.cs

    r351 r382  
    11using System.Net;
     2using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
     3using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    24
    35namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    4         public class SimpleRedirectHandler : PathHandler {
     6        public class SimpleRedirectHandler : AbsHandler {
    57                private readonly string target;
    68
    7                 public SimpleRedirectHandler (string _target, string _moduleName = null) : base (_moduleName) {
     9                public SimpleRedirectHandler (string _target) : base (null) {
    810                        target = _target;
    911                }
    1012
    11                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     13                public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    1214                        int _permissionLevel) {
    1315                        _resp.Redirect (target);
  • binary-improvements2/MapRendering/Web/Handlers/StaticHandler.cs

    r367 r382  
    22using System.Net;
    33using AllocsFixes.FileCache;
     4using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
     5using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    46
    57namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    6         public class StaticHandler : PathHandler {
     8        public class StaticHandler : AbsHandler {
    79                private readonly AbstractCache cache;
    810                private readonly string datapath;
     
    1618                }
    1719
    18                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     20                public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    1921                        int _permissionLevel) {
    20                         string fn = _req.Url.AbsolutePath.Remove (0, urlBasePath.Length);
     22                        string fn = _requestPath.Remove (0, urlBasePath.Length);
    2123
    2224                        byte[] content = cache.GetFileContent (datapath + fn);
     
    2931                                _resp.StatusCode = (int) HttpStatusCode.NotFound;
    3032                                if (logMissingFiles) {
    31                                         Log.Out ("Web:Static:FileNotFound: \"" + _req.Url.AbsolutePath + "\" @ \"" + datapath + fn + "\"");
     33                                        Log.Out ("Web:Static:FileNotFound: \"" + _requestPath + "\" @ \"" + datapath + fn + "\"");
    3234                                }
    3335                        }
  • binary-improvements2/MapRendering/Web/Handlers/UserStatusHandler.cs

    r369 r382  
    1 using System.Net;
    21using AllocsFixes.JSON;
    32using AllocsFixes.NetConnections.Servers.Web.API;
     3using HttpListenerRequest = SpaceWizards.HttpListener.HttpListenerRequest;
     4using HttpListenerResponse = SpaceWizards.HttpListener.HttpListenerResponse;
    45
    56namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    6         public class UserStatusHandler : PathHandler {
     7        public class UserStatusHandler : AbsHandler {
    78                public UserStatusHandler (string _moduleName = null) : base (_moduleName) {
    89                }
    910
    10                 public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     11                public override void HandleRequest (string _requestPath, HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _con,
    1112                        int _permissionLevel) {
    1213                        JSONObject result = new JSONObject ();
    1314
    14                         result.Add ("loggedin", new JSONBoolean (_user != null));
    15                         result.Add ("username", new JSONString (_user != null ? _user.UserId.ToString () : string.Empty));
     15                        result.Add ("loggedin", new JSONBoolean (_con != null));
     16                        result.Add ("username", new JSONString (_con != null ? _con.UserId.ToString () : string.Empty));
    1617
    1718                        JSONArray perms = new JSONArray ();
Note: See TracChangeset for help on using the changeset viewer.