Changeset 453 for TFP-WebServer/WebServer/src/UrlHandlers/SessionHandler.cs

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

File:

• TFP-WebServer/WebServer/src/UrlHandlers/SessionHandler.cs (modified) (8 diffs)

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

@@ -9 +9 @@
 namespace Webserver.UrlHandlers {
         public class SessionHandler : AbsHandler {
+                
                 private const string pageBasePath = "/app";
                 private const string pageErrorPath = "/app/error/";
@@ -14 +15 @@
                 private const string steamOpenIdVerifyUrl = "verifysteamopenid";
                 private const string steamLoginUrl = "loginsteam";
+                private const string steamLoginName = "Steam OpenID";
                 private const string steamLoginFailedPage = "SteamLoginFailed";
 
                 private const string userPassLoginUrl = "login";
                 public const string userPassLoginName = "User/pass";
-                public const string userPassErrorPage = "UserPassLoginFailed";
+                private const string userPassErrorPage = "UserPassLoginFailed";
 
-                private readonly ConnectionHandler connectionHandler;
-
-                public SessionHandler (ConnectionHandler _connectionHandler) : base (null) {
-                        connectionHandler = _connectionHandler;
+                public SessionHandler () : base (null) {
                 }
-
                 public override void HandleRequest (RequestContext _context) {
                         if (_context.Request.RemoteEndPoint == null) {
-                                _context.Response.Redirect (pageErrorPath + "NoRemoteEndpoint");
+                                WebUtils.WriteText (_context.Response, "NoRemoteEndpoint", HttpStatusCode.BadRequest);
                                 return;
                         }
@@ -37 +35 @@
 
                         if (subpath.StartsWith (steamOpenIdVerifyUrl)) {
-                                HandleSteamVerification (_context, remoteEndpointString);
+                                if (HandleSteamVerification (parent.ConnectionHandler, _context, remoteEndpointString)) {
+                                        _context.Response.Redirect (pageBasePath);
+                                } else {
+                                        _context.Response.Redirect (pageErrorPath + steamLoginFailedPage);
+                                }
                                 return;
                         }
 
                         if (subpath.StartsWith ("logout")) {
-                                HandleLogout (_context);
+                                HandleLogout (parent.ConnectionHandler, _context, pageBasePath);
                                 return;
                         }
 
                         if (subpath.StartsWith (steamLoginUrl)) {
-                                HandleSteamLogin (_context);
+                                HandleSteamLogin (_context, $"{urlBasePath}{steamOpenIdVerifyUrl}");
                                 return;
                         }
 
                         if (subpath.StartsWith (userPassLoginUrl)) {
-                                HandleUserPassLogin (_context, remoteEndpointString);
+                                HandleUserPassLogin (parent.ConnectionHandler, _context, remoteEndpointString);
                                 return;
                         }
 
-                        _context.Response.Redirect (pageErrorPath + "InvalidSessionsCommand");
+                        WebUtils.WriteText (_context.Response, "InvalidSessionsCommand", HttpStatusCode.BadRequest);
                 }
 
-                private void HandleUserPassLogin (RequestContext _context, string _remoteEndpointString) {
+                public static bool HandleUserPassLogin (ConnectionHandler _connectionHandler, RequestContext _context, string _remoteEndpointString) {
                         if (!_context.Request.HasEntityBody) {
                                 WebUtils.WriteText (_context.Response, "NoLoginData", HttpStatusCode.BadRequest);
-                                return;
+                                return false;
                         }
 
@@ -77 +79 @@
                                 Log.Exception (e);
                                 WebUtils.WriteText (_context.Response, "InvalidLoginJson", HttpStatusCode.BadRequest);
-                                return;
+                                return false;
                         }
 
                         if (!inputJson.TryGetValue ("username", out object fieldNode) || fieldNode is not string username) {
                                 WebUtils.WriteText (_context.Response, "InvalidLoginJson", HttpStatusCode.BadRequest);
-                                return;
+                                return false;
                         }
 
                         if (!inputJson.TryGetValue ("password", out fieldNode) || fieldNode is not string password) {
                                 WebUtils.WriteText (_context.Response, "InvalidLoginJson", HttpStatusCode.BadRequest);
-                                return;
+                                return false;
                         }
 
                         if (!AdminWebUsers.Instance.TryGetUser (username, password, out AdminWebUsers.WebUser webUser)) {
+                                WebUtils.WriteText (_context.Response, "UserPassInvalid", HttpStatusCode.Unauthorized);
                                 Log.Out ($"[Web] User/pass login failed from {_remoteEndpointString}");
-                                WebUtils.WriteText (_context.Response, "UserPassInvalid", HttpStatusCode.Unauthorized);
-                                return;
+                                return false;
                         }
 
-                        HandleUserIdLogin (connectionHandler, _context, _remoteEndpointString, userPassLoginName, userPassErrorPage, webUser.Name, webUser.PlatformUser, webUser.CrossPlatformUser);
+                        var loginResult = HandleUserIdLogin (_connectionHandler, _context, _remoteEndpointString, userPassLoginName, webUser.Name, webUser.PlatformUser, webUser.CrossPlatformUser);
+                        if (loginResult) {
+                                WebUtils.WriteText (_context.Response, "");
+                        } else {
+                                WebUtils.WriteText (_context.Response, "LoginError", HttpStatusCode.InternalServerError);
+                        }
+
+                        return loginResult;
                 }
 
-                private void HandleSteamLogin (RequestContext _context) {
+                public static void HandleSteamLogin (RequestContext _context, string _verificationCallbackUrl) {
                         string host = $"{(WebUtils.IsSslRedirected (_context.Request) ? "https://" : "http://")}{_context.Request.UserHostName}";
-                        string url = OpenID.GetOpenIdLoginUrl (host, $"{host}{urlBasePath}{steamOpenIdVerifyUrl}");
+                        string url = OpenID.GetOpenIdLoginUrl (host, $"{host}{_verificationCallbackUrl}");
                         _context.Response.Redirect (url);
                 }
 
-                private void HandleLogout (RequestContext _context) {
+                public static bool HandleLogout (ConnectionHandler _connectionHandler, RequestContext _context, string _pageBase) {
                         Cookie cookie = new Cookie ("sid", "", "/") {
                                 Expired = true
@@ -112 +121 @@
 
                         if (_context.Connection == null) {
-                                _context.Response.Redirect (pageErrorPath + "NotLoggedIn");
-                                return;
+                                _context.Response.Redirect (_pageBase);
+                                return false;
                         }
 
-                        connectionHandler.LogOut (_context.Connection.SessionID);
-                        _context.Response.Redirect (pageBasePath);
+                        _connectionHandler.LogOut (_context.Connection.SessionID);
+                        _context.Response.Redirect (_pageBase);
+                        return true;
                 }
 
-                private void HandleSteamVerification (RequestContext _context, string _remoteEndpointString) {
+                public static bool HandleSteamVerification (ConnectionHandler _connectionHandler, RequestContext _context, string _remoteEndpointString) {
                         ulong id;
                         try {
@@ -127 +137 @@
                                 Log.Error ($"[Web] Error validating Steam login from {_remoteEndpointString}:");
                                 Log.Exception (e);
-                                _context.Response.Redirect (pageErrorPath + steamLoginFailedPage);
-                                return;
+                                return false;
                         }
 
                         if (id <= 0) {
                                 Log.Out ($"[Web] Steam OpenID login failed (invalid ID) from {_remoteEndpointString}");
-                                _context.Response.Redirect (pageErrorPath + steamLoginFailedPage);
-                                return;
+                                return false;
                         }
 
                         UserIdentifierSteam userId = new UserIdentifierSteam (id);
-                        HandleUserIdLogin (connectionHandler, _context, _remoteEndpointString, "Steam OpenID", steamLoginFailedPage, userId.ToString (), userId);
+                        return HandleUserIdLogin (_connectionHandler, _context, _remoteEndpointString, steamLoginName, userId.ToString (), userId);
                 }
 
-                public static void HandleUserIdLogin (ConnectionHandler _connectionHandler, RequestContext _context, string _remoteEndpointString,
-                        string _loginName, string _errorPage, string _username, PlatformUserIdentifierAbs _userId, PlatformUserIdentifierAbs _crossUserId = null, bool _sendResponse = true) {
+                public static bool HandleUserIdLogin (ConnectionHandler _connectionHandler, RequestContext _context, string _remoteEndpointString,
+                        string _loginName, string _username, PlatformUserIdentifierAbs _userId, PlatformUserIdentifierAbs _crossUserId = null) {
                         try {
                                 WebConnection con = _connectionHandler.LogIn (_context.Request.RemoteEndPoint!.Address, _username, _userId, _crossUserId);
@@ -154 +162 @@
                                 int higherLevel = Math.Min (level1, level2);
 
-                                Log.Out ($"[Web] {_loginName} login from {_remoteEndpointString}, name {_username} with ID {_userId}, CID {(_crossUserId != null ? _crossUserId : "none")}, permission level {higherLevel}");
+                                Log.Out ($"[Web] {_loginName} login from {_remoteEndpointString}, name {_username} with ID {_userId}, CID {(_crossUserId != null ? _crossUserId.ToString () : "none")}, permission level {higherLevel}");
                                 Cookie cookie = new Cookie ("sid", con.SessionID, "/") {
                                         Expired = false,
@@ -163 +171 @@
                                 _context.Response.AppendCookie (cookie);
 
-                                if (_sendResponse) {
-                                        WebUtils.WriteText (_context.Response, "");
-                                }
+                                return true;
                         } catch (Exception e) {
                                 Log.Error ($"[Web] Error during {_loginName} login:");
                                 Log.Exception (e);
-                                if (_sendResponse) {
-                                        WebUtils.WriteText (_context.Response, "LoginError", HttpStatusCode.InternalServerError);
-                                }
                         }
+
+                        return false;
                 }
+
         }
 }