Ignore:
Timestamp:
Jul 28, 2023, 8:11:39 PM (16 months ago)
Author:
alloc
Message:

21.1.9 release, updated Sessions handler to be more flexible

Location:
TFP-WebServer/WebServer/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • TFP-WebServer/WebServer/src/UrlHandlers/ApiHandler.cs

    r418 r453  
    3030
    3131                private void apiFoundCallback (Type _type) {
    32                         ConstructorInfo ctor = _type.GetConstructor (apiWithParentCtorTypes);
     32                        ConstructorInfo ctor = _type.GetConstructor (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, (Binder)null,
     33                                apiWithParentCtorTypes, (ParameterModifier[])null);
    3334                        if (ctor != null) {
    3435                                AbsWebAPI apiInstance = (AbsWebAPI)ctor.Invoke (apiWithParentCtorArgs);
    … …  
    3738                        }
    3839
    39                         ctor = _type.GetConstructor (apiEmptyCtorTypes);
     40                        ctor = _type.GetConstructor (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, (Binder)null,
     41                                apiEmptyCtorTypes, (ParameterModifier[])null);
    4042                        if (ctor != null) {
    4143                                AbsWebAPI apiInstance = (AbsWebAPI)ctor.Invoke (apiEmptyCtorArgs);

  • TFP-WebServer/WebServer/src/UrlHandlers/SessionHandler.cs

    r433 r453  
    99namespace Webserver.UrlHandlers {
    1010        public class SessionHandler : AbsHandler {
     11               
    1112                private const string pageBasePath = "/app";
    1213                private const string pageErrorPath = "/app/error/";
    … …  
    1415                private const string steamOpenIdVerifyUrl = "verifysteamopenid";
    1516                private const string steamLoginUrl = "loginsteam";
     17                private const string steamLoginName = "Steam OpenID";
    1618                private const string steamLoginFailedPage = "SteamLoginFailed";
    1719
    1820                private const string userPassLoginUrl = "login";
    1921                public const string userPassLoginName = "User/pass";
    20                 public const string userPassErrorPage = "UserPassLoginFailed";
     22                private const string userPassErrorPage = "UserPassLoginFailed";
    2123
    22                 private readonly ConnectionHandler connectionHandler;
    23 
    24                 public SessionHandler (ConnectionHandler _connectionHandler) : base (null) {
    25                         connectionHandler = _connectionHandler;
     24                public SessionHandler () : base (null) {
    2625                }
    27 
    2826                public override void HandleRequest (RequestContext _context) {
    2927                        if (_context.Request.RemoteEndPoint == null) {
    30                                 _context.Response.Redirect (pageErrorPath + "NoRemoteEndpoint");
     28                                WebUtils.WriteText (_context.Response, "NoRemoteEndpoint", HttpStatusCode.BadRequest);
    3129                                return;
    3230                        }
    … …  
    3735
    3836                        if (subpath.StartsWith (steamOpenIdVerifyUrl)) {
    39                                 HandleSteamVerification (_context, remoteEndpointString);
     37                                if (HandleSteamVerification (parent.ConnectionHandler, _context, remoteEndpointString)) {
     38                                        _context.Response.Redirect (pageBasePath);
     39                                } else {
     40                                        _context.Response.Redirect (pageErrorPath + steamLoginFailedPage);
     41                                }
    4042                                return;
    4143                        }
    4244
    4345                        if (subpath.StartsWith ("logout")) {
    44                                 HandleLogout (_context);
     46                                HandleLogout (parent.ConnectionHandler, _context, pageBasePath);
    4547                                return;
    4648                        }
    4749
    4850                        if (subpath.StartsWith (steamLoginUrl)) {
    49                                 HandleSteamLogin (_context);
     51                                HandleSteamLogin (_context, $"{urlBasePath}{steamOpenIdVerifyUrl}");
    5052                                return;
    5153                        }
    5254
    5355                        if (subpath.StartsWith (userPassLoginUrl)) {
    54                                 HandleUserPassLogin (_context, remoteEndpointString);
     56                                HandleUserPassLogin (parent.ConnectionHandler, _context, remoteEndpointString);
    5557                                return;
    5658                        }
    5759
    58                         _context.Response.Redirect (pageErrorPath + "InvalidSessionsCommand");
     60                        WebUtils.WriteText (_context.Response, "InvalidSessionsCommand", HttpStatusCode.BadRequest);
    5961                }
    6062
    61                 private void HandleUserPassLogin (RequestContext _context, string _remoteEndpointString) {
     63                public static bool HandleUserPassLogin (ConnectionHandler _connectionHandler, RequestContext _context, string _remoteEndpointString) {
    6264                        if (!_context.Request.HasEntityBody) {
    6365                                WebUtils.WriteText (_context.Response, "NoLoginData", HttpStatusCode.BadRequest);
    64                                 return;
     66                                return false;
    6567                        }
    6668
    … …  
    7779                                Log.Exception (e);
    7880                                WebUtils.WriteText (_context.Response, "InvalidLoginJson", HttpStatusCode.BadRequest);
    79                                 return;
     81                                return false;
    8082                        }
    8183
    8284                        if (!inputJson.TryGetValue ("username", out object fieldNode) || fieldNode is not string username) {
    8385                                WebUtils.WriteText (_context.Response, "InvalidLoginJson", HttpStatusCode.BadRequest);
    84                                 return;
     86                                return false;
    8587                        }
    8688
    8789                        if (!inputJson.TryGetValue ("password", out fieldNode) || fieldNode is not string password) {
    8890                                WebUtils.WriteText (_context.Response, "InvalidLoginJson", HttpStatusCode.BadRequest);
    89                                 return;
     91                                return false;
    9092                        }
    9193
    9294                        if (!AdminWebUsers.Instance.TryGetUser (username, password, out AdminWebUsers.WebUser webUser)) {
     95                                WebUtils.WriteText (_context.Response, "UserPassInvalid", HttpStatusCode.Unauthorized);
    9396                                Log.Out ($"[Web] User/pass login failed from {_remoteEndpointString}");
    94                                 WebUtils.WriteText (_context.Response, "UserPassInvalid", HttpStatusCode.Unauthorized);
    95                                 return;
     97                                return false;
    9698                        }
    9799
    98                         HandleUserIdLogin (connectionHandler, _context, _remoteEndpointString, userPassLoginName, userPassErrorPage, webUser.Name, webUser.PlatformUser, webUser.CrossPlatformUser);
     100                        var loginResult = HandleUserIdLogin (_connectionHandler, _context, _remoteEndpointString, userPassLoginName, webUser.Name, webUser.PlatformUser, webUser.CrossPlatformUser);
     101                        if (loginResult) {
     102                                WebUtils.WriteText (_context.Response, "");
     103                        } else {
     104                                WebUtils.WriteText (_context.Response, "LoginError", HttpStatusCode.InternalServerError);
     105                        }
     106
     107                        return loginResult;
    99108                }
    100109
    101                 private void HandleSteamLogin (RequestContext _context) {
     110                public static void HandleSteamLogin (RequestContext _context, string _verificationCallbackUrl) {
    102111                        string host = $"{(WebUtils.IsSslRedirected (_context.Request) ? "https://" : "http://")}{_context.Request.UserHostName}";
    103                         string url = OpenID.GetOpenIdLoginUrl (host, $"{host}{urlBasePath}{steamOpenIdVerifyUrl}");
     112                        string url = OpenID.GetOpenIdLoginUrl (host, $"{host}{_verificationCallbackUrl}");
    104113                        _context.Response.Redirect (url);
    105114                }
    106115
    107                 private void HandleLogout (RequestContext _context) {
     116                public static bool HandleLogout (ConnectionHandler _connectionHandler, RequestContext _context, string _pageBase) {
    108117                        Cookie cookie = new Cookie ("sid", "", "/") {
    109118                                Expired = true
    … …  
    112121
    113122                        if (_context.Connection == null) {
    114                                 _context.Response.Redirect (pageErrorPath + "NotLoggedIn");
    115                                 return;
     123                                _context.Response.Redirect (_pageBase);
     124                                return false;
    116125                        }
    117126
    118                         connectionHandler.LogOut (_context.Connection.SessionID);
    119                         _context.Response.Redirect (pageBasePath);
     127                        _connectionHandler.LogOut (_context.Connection.SessionID);
     128                        _context.Response.Redirect (_pageBase);
     129                        return true;
    120130                }
    121131
    122                 private void HandleSteamVerification (RequestContext _context, string _remoteEndpointString) {
     132                public static bool HandleSteamVerification (ConnectionHandler _connectionHandler, RequestContext _context, string _remoteEndpointString) {
    123133                        ulong id;
    124134                        try {
    … …  
    127137                                Log.Error ($"[Web] Error validating Steam login from {_remoteEndpointString}:");
    128138                                Log.Exception (e);
    129                                 _context.Response.Redirect (pageErrorPath + steamLoginFailedPage);
    130                                 return;
     139                                return false;
    131140                        }
    132141
    133142                        if (id <= 0) {
    134143                                Log.Out ($"[Web] Steam OpenID login failed (invalid ID) from {_remoteEndpointString}");
    135                                 _context.Response.Redirect (pageErrorPath + steamLoginFailedPage);
    136                                 return;
     144                                return false;
    137145                        }
    138146
    139147                        UserIdentifierSteam userId = new UserIdentifierSteam (id);
    140                         HandleUserIdLogin (connectionHandler, _context, _remoteEndpointString, "Steam OpenID", steamLoginFailedPage, userId.ToString (), userId);
     148                        return HandleUserIdLogin (_connectionHandler, _context, _remoteEndpointString, steamLoginName, userId.ToString (), userId);
    141149                }
    142150
    143                 public static void HandleUserIdLogin (ConnectionHandler _connectionHandler, RequestContext _context, string _remoteEndpointString,
    144                         string _loginName, string _errorPage, string _username, PlatformUserIdentifierAbs _userId, PlatformUserIdentifierAbs _crossUserId = null, bool _sendResponse = true) {
     151                public static bool HandleUserIdLogin (ConnectionHandler _connectionHandler, RequestContext _context, string _remoteEndpointString,
     152                        string _loginName, string _username, PlatformUserIdentifierAbs _userId, PlatformUserIdentifierAbs _crossUserId = null) {
    145153                        try {
    146154                                WebConnection con = _connectionHandler.LogIn (_context.Request.RemoteEndPoint!.Address, _username, _userId, _crossUserId);
    … …  
    154162                                int higherLevel = Math.Min (level1, level2);
    155163
    156                                 Log.Out ($"[Web] {_loginName} login from {_remoteEndpointString}, name {_username} with ID {_userId}, CID {(_crossUserId != null ? _crossUserId : "none")}, permission level {higherLevel}");
     164                                Log.Out ($"[Web] {_loginName} login from {_remoteEndpointString}, name {_username} with ID {_userId}, CID {(_crossUserId != null ? _crossUserId.ToString () : "none")}, permission level {higherLevel}");
    157165                                Cookie cookie = new Cookie ("sid", con.SessionID, "/") {
    158166                                        Expired = false,
    … …  
    163171                                _context.Response.AppendCookie (cookie);
    164172
    165                                 if (_sendResponse) {
    166                                         WebUtils.WriteText (_context.Response, "");
    167                                 }
     173                                return true;
    168174                        } catch (Exception e) {
    169175                                Log.Error ($"[Web] Error during {_loginName} login:");
    170176                                Log.Exception (e);
    171                                 if (_sendResponse) {
    172                                         WebUtils.WriteText (_context.Response, "LoginError", HttpStatusCode.InternalServerError);
    173                                 }
    174177                        }
     178
     179                        return false;
    175180                }
     181
    176182        }
    177183}

  • TFP-WebServer/WebServer/src/Web.cs

    r440 r453  
    8585                        RegisterWebMods (useCacheForStatic);
    8686
    87                         RegisterPathHandler ("/session/", new SessionHandler (ConnectionHandler));
     87                        RegisterPathHandler ("/session/", new SessionHandler ());
    8888                        RegisterPathHandler ("/userstatus", new UserStatusHandler ());
    8989                        RegisterPathHandler ("/sse/", new SseHandler ());

  • TFP-WebServer/WebServer/src/WebAPI/APIs/Permissions/RegisterUser.cs

    r434 r453  
    110110                        string remoteEndpointString = _context.Request.RemoteEndPoint!.ToString ();
    111111                        SessionHandler.HandleUserIdLogin (ParentWeb.ConnectionHandler, _context, remoteEndpointString, SessionHandler.userPassLoginName,
    112                                 SessionHandler.userPassErrorPage, username, regData.PlatformUserId, regData.CrossPlatformUserId, false);
     112                                username, regData.PlatformUserId, regData.CrossPlatformUserId);
    113113
    114114                        _context.Response.StatusCode = (int)HttpStatusCode.Created;
Note: See TracChangeset for help on using the changeset viewer.