Reworked and unified admin authentication and registration functions to eDBadminAuthenticate()

eDBadminAuth(), eDBadminValidateSession(), eDBadminRegisterLogin() and
eDBadminLogout() are now unfied into one admin function, eDBadminAuthenticate().
This function receives all input as eurephia XML documents.

1 files changed, 127 insertions, 20 deletions

diff --git a/eurephiadm/eurephiadm.c b/eurephiadm/eurephiadm.c
index 518f8a5..203b7e2 100644
--- a/eurephiadm/eurephiadm.c
+++ b/eurephiadm/eurephiadm.c
@@ -35,10 +35,13 @@
 #include <assert.h>
 #include <libgen.h>
 
+#include <libxml/tree.h>
+
 #include <eurephia_nullsafe.h>
 #include <eurephia_context.h>
 #include <eurephia_log.h>
 #include <eurephia_values.h>
+#include <eurephia_xml.h>
 #include <eurephiadb_driver.h>
 #include <eurephiadb_session_common.h>
 #include <eurephiadb.h>
@@ -153,10 +156,34 @@ int cmd_Help(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg, int a
  * @return returns 0 on success, otherwise 1.
  */
 int cmd_Logout(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg, int argc, char **argv) {
+        xmlDoc *logoutxml = NULL, *resxml = NULL;
+        xmlNode *logout_n = NULL;
+        eurephiaRESULT *res = NULL;
         int rc = 0;
-        rc = eDBadminLogout(ctx, argv[0]);
-        fprintf(stdout, "%s\n", (rc == 1 ? "Logged out successfully" : "Logout failed."));
-        return (rc == 0);
+
+        eurephiaXML_CreateDoc(ctx, 1, "Register", &logoutxml, &logout_n);
+        assert( (logoutxml != NULL) && (logout_n != NULL) );
+        xmlNewProp(logout_n, (xmlChar *) "mode", (xmlChar *) "logout");
+        xmlAddChild(logout_n, xmlNewText((xmlChar *) argv[0])); // A dirty hack, but the sesskey is here
+
+        resxml = eDBadminAuthenticate(ctx, logoutxml);
+        xmlFreeDoc(logoutxml);
+        if( !eurephiaXML_IsResultMsg(ctx, resxml) ) {
+                eurephia_log(ctx, LOG_FATAL, 0, "Failed to logout session");
+                rc = 1;
+        } else {
+                res = eurephiaXML_ParseResultMsg(ctx, resxml);
+                if( res->resultType == exmlERROR ) {
+                        fprintf(stderr, "%s: %s\n", MODULE, res->message);
+                        rc = 1;
+                } else {
+                        fprintf(stdout, "%s: %s\n", MODULE, res->message);
+                        rc = 0;
+                }
+        }
+        xmlFreeDoc(resxml);
+        free_nullsafe(ctx, res);
+        return rc;
 }
 
 
@@ -248,10 +275,12 @@ int eurephia_ConnectDB(eurephiaCTX *ctx, const char *argstr) {
  *
  * @return Returns a eurephiaSESSION pointer to the authenticated user session on success, otherwise NULL.
  */
-eurephiaSESSION *do_login(eurephiaCTX *ctx, eurephiaVALUES *cfg, const char *req_access) {
+static eurephiaSESSION *do_login(eurephiaCTX *ctx, eurephiaVALUES *cfg, const char *req_access) {
+        xmlDoc *loginxml = NULL, *resxml = NULL;
+        xmlNode *login_n = NULL;
+        eurephiaRESULT *res = NULL;
         eurephiaSESSION *session = NULL;
         char username[33], password[33], *tmp = NULL;
-        int uid = 0;
 
         memset(&username, 0, 33);
         memset(&password, 0, 33);
@@ -263,17 +292,36 @@ eurephiaSESSION *do_login(eurephiaCTX *ctx, eurephiaVALUES *cfg, const char *req
         }
         get_console_input(password, 32, "Password:", 1);
 
-        if( (uid = eDBadminAuth(ctx, req_access, username, password)) < 1 ) {
-                // Register failure
-                memset(username, 0, 33);
-                memset(password, 0, 33);
-                return NULL;
-        }
+        eurephiaXML_CreateDoc(ctx, 1, "Authenticate", &loginxml, &login_n);
+        assert( (loginxml != NULL) && (login_n != NULL) );
+        xmlNewProp(login_n, (xmlChar *) "mode", (xmlChar *) "user");
+
+        xmlNewChild(login_n, NULL, (xmlChar *) "username", (xmlChar *) username);
+        xmlNewChild(login_n, NULL, (xmlChar *) "password", (xmlChar *) password);
+        xmlNewChild(login_n, NULL, (xmlChar *) "accesslevel", (xmlChar *) req_access);
+        resxml = eDBadminAuthenticate(ctx, loginxml);
+        xmlFreeDoc(loginxml);
         memset(username, 0, 33);
         memset(password, 0, 33);
+        if( !eurephiaXML_IsResultMsg(ctx, resxml)  ) {
+                return NULL;
+        }
+
+        res = eurephiaXML_ParseResultMsg(ctx, resxml);
+        if( res->resultType == exmlERROR ) {
+                fprintf(stderr, "%s: %s\n", MODULE, res->message);
+                free_nullsafe(ctx, res);
+                xmlFreeDoc(resxml);
+                return NULL;
+        }
 
         session = create_session(ctx, NULL);
-        snprintf(username, 30, "%i", uid); // Borrow username for converting uid to a string
+        login_n = xmlFindNode(res->details, "UserAccount");
+
+        // Borrow username for converting uid to a string
+        snprintf(username, 30, "%s", xmlGetAttrValue(login_n->properties, "uid"));
+        xmlFreeDoc(resxml);
+        free_nullsafe(ctx, res);
 
         if( !eDBset_session_value(ctx, session, "uid", username) ) {
                 eurephia_log(ctx, LOG_FATAL, 0, "Could not update session variables (uid)");
@@ -281,17 +329,82 @@ eurephiaSESSION *do_login(eurephiaCTX *ctx, eurephiaVALUES *cfg, const char *req
                 return NULL;
         };
 
-        if( !eDBadminRegisterLogin(ctx, session) ) {
+
+        // Register the session as logged in
+        eurephiaXML_CreateDoc(ctx, 1, "Register", &loginxml, &login_n);
+        assert( (loginxml != NULL) && (login_n != NULL) );
+        xmlNewProp(login_n, (xmlChar *) "mode", (xmlChar *) "login");
+        xmlNewProp(login_n, (xmlChar *) "uid", (xmlChar *) username);
+        xmlAddChild(login_n, xmlNewText((xmlChar *) session->sessionkey));
+
+        resxml = eDBadminAuthenticate(ctx, loginxml);
+        xmlFreeDoc(loginxml);
+        if( !eurephiaXML_IsResultMsg(ctx, resxml) ) {
                 eurephia_log(ctx, LOG_FATAL, 0, "Could not register login");
                 eDBfree_session(ctx, session);
+                xmlFreeDoc(resxml);
+                return NULL;
+        }
+
+        res = eurephiaXML_ParseResultMsg(ctx, resxml);
+        if( res->resultType == exmlERROR ) {
+                fprintf(stderr, "%s: %s\n", MODULE, res->message);
+                free_nullsafe(ctx, res);
+                xmlFreeDoc(resxml);
+                eDBfree_session(ctx, session);
                 return NULL;
         }
+        xmlFreeDoc(resxml);
+        free_nullsafe(ctx, res);
 
         return session;
 }
 
 
 /**
+ * Validates an exisiting session key against a requested access level
+ *
+ * @param ctx        eurephiaCTX
+ * @param sesskey    String containing the session key
+ * @param accesslvl  String containing the requested access level
+ *
+ * @return Returns 1 if session is valid and access level is granted to the session, otherwise 0
+ */
+static int validate_session(eurephiaCTX *ctx, const char *sesskey, const char *accesslvl) {
+        xmlDoc *sessxml = NULL, *resxml = NULL;
+        xmlNode *sess_n = NULL;
+        int ret = 0;
+
+        eurephiaXML_CreateDoc(ctx, 1, "Authenticate", &sessxml, &sess_n);
+        assert( (sessxml != NULL) && (sess_n != NULL) );
+        xmlNewProp(sess_n, (xmlChar *) "mode", (xmlChar *) "session");
+
+        xmlNewChild(sess_n, NULL, (xmlChar *) "sessionkey", (xmlChar *) sesskey);
+        xmlNewChild(sess_n, NULL, (xmlChar *) "accesslevel", (xmlChar *) accesslvl);
+
+        resxml = eDBadminAuthenticate(ctx, sessxml);
+        xmlFreeDoc(sessxml);
+        if( !eurephiaXML_IsResultMsg(ctx, resxml)  ) {
+                ret = 0;
+        } else {
+                eurephiaRESULT *res = NULL;
+
+                res = eurephiaXML_ParseResultMsg(ctx, resxml);
+                if( res->resultType == exmlERROR ) {
+                        fprintf(stderr, "%s: %s\n", MODULE, res->message);
+                        ret = 0;
+                } else {
+                        ret = 1;
+                }
+                free_nullsafe(ctx, res);
+        }
+        if( resxml ) {
+                xmlFreeDoc(resxml);
+        }
+        return ret;
+}
+
+/**
  * Converts a argument table (char **) into a space separated string (char *)
  *
  * @param argc argument counter
@@ -458,9 +571,6 @@ int main(int argc, char **argv) {
                         goto exit;
                 }
                 session = do_login(ctx, cfg, call_fnc->accesslvl);
-                if( session == NULL ) {
-                        fprintf(stderr, "Login failed\n");
-                }
         } else {
                 // If we are logging out, do so here - without checking the session
                 if( strcmp(call_fnc->command, "logout") == 0) {
@@ -472,16 +582,13 @@ int main(int argc, char **argv) {
                 }
 
                 // Session file found, check if it still is a valid session
-                if( eDBadminValidateSession(ctx, sesskey_file, call_fnc->accesslvl) ) {;
+                if( validate_session(ctx, sesskey_file, call_fnc->accesslvl) ) {;
                         // If valid, load this session
                         session = create_session(ctx, sesskey_file);
                 } else {
                         // If not valid, remove session file and go to login
                         remove_session_file(ctx);
                         session = do_login(ctx, cfg, call_fnc->accesslvl);
-                        if( session == NULL ) {
-                                fprintf(stderr, "Login failed\n");
-                        }
                 }
         }
         free_nullsafe(ctx, sesskey_file);