Mercurial > hg > webserver / file diff

--- a/src/server/daemon/keyfile_auth.c	Wed Nov 02 19:19:01 2022 +0100
+++ b/src/server/daemon/keyfile_auth.c	Sun Nov 06 15:53:32 2022 +0100
@@ -41,28 +41,30 @@
 #include "../util/atomic.h"
 #include "../util/util.h"
 
+#include <cx/hash_map.h>
+
 #include "keyfile_auth.h"
 
-Keyfile* keyfile_new(UcxAllocator *a) {
-    Keyfile *keyfile = alcalloc(a, 1, sizeof(Keyfile));
+Keyfile* keyfile_new(CxAllocator *a) {
+    Keyfile *keyfile = cxCalloc(a, 1, sizeof(Keyfile));
     if(!keyfile) {
         return NULL;
     }
     keyfile->authdb.get_user = keyfile_get_user;
     keyfile->authdb.use_cache = 0;
-    keyfile->users = ucx_map_new_a(a, 16);
+    keyfile->users = cxHashMapCreate(a, 16);
     return keyfile;
 }
 
 int keyfile_add_user(
         Keyfile *keyfile,
-        sstr_t name,
+        cxmutstr name,
         enum KeyfileHashType hash_type,
-        sstr_t hash,
-        sstr_t *groups,
+        cxmutstr hash,
+        cxmutstr *groups,
         size_t ngroups)
 {
-    UcxAllocator *a = keyfile->users->allocator;
+    CxAllocator *a = keyfile->users->allocator;
     
     if(hash.length < 12) {
         // hash too short
@@ -70,8 +72,8 @@
         return -1;
     }
     
-    KeyfileUser *user = almalloc(a, sizeof(KeyfileUser));
-    user->user.name = sstrdup_a(a, name).ptr;
+    KeyfileUser *user = cxMalloc(a, sizeof(KeyfileUser));
+    user->user.name = cx_strdup_a(a, cx_strcast(name)).ptr;
     user->user.uid = -1;
     user->user.gid = -1;
     user->user.verify_password = keyfile_user_verify_password;
@@ -79,7 +81,7 @@
     user->user.free = keyfile_user_free;
     
     user->hash_type = hash_type;
-    user->hash = almalloc(a, hash.length + 1);
+    user->hash = cxMalloc(a, hash.length + 1);
     
     if(!user->user.name || !user->hash) {
         return -1;
@@ -88,12 +90,12 @@
     user->hashlen = util_base64decode(hash.ptr, hash.length, user->hash);
     
     if(ngroups > 0) {
-        user->groups = alcalloc(a, ngroups, sizeof(sstr_t));
+        user->groups = cxCalloc(a, ngroups, sizeof(cxmutstr));
         if(!user->groups) {
             return -1;
         }
         for(int i=0;i<ngroups;i++) {
-            user->groups[i] = sstrdup_a(a, groups[i]);
+            user->groups[i] = cx_strdup_a(a, cx_strcast(groups[i]));
         }
         
     } else {
@@ -101,26 +103,26 @@
     }
     
     // add to keyfile
-    return ucx_map_sstr_put(keyfile->users, name, user);
+    return cxMapPut(keyfile->users, cx_hash_key(name.ptr, name.length), user);
 }
 
 // authdb functions
 
-User* keyfile_get_user(AuthDB *db, char *user) {
+User* keyfile_get_user(AuthDB *db, const char *user) {
     Keyfile *keyfile = (Keyfile*)db;
-    return ucx_map_cstr_get(keyfile->users, user);
+    return cxMapGet(keyfile->users, cx_hash_key_str(user));
 }
 
-int keyfile_user_verify_password(User *user, char *password) {
+int keyfile_user_verify_password(User *user, const char *password) {
     KeyfileUser *usr = (KeyfileUser*)user;
     return ssha_verify(usr, password);
 }
 
-int keyfile_user_check_group(User *user, char *group) {
+int keyfile_user_check_group(User *user, const char *group) {
     KeyfileUser *usr = (KeyfileUser*)user;
-    sstr_t grp = sstr(group);
+    cxstring grp = cx_str(group);
     for(int i=0;i<usr->numgroups;i++) {
-        if(!sstrcmp(usr->groups[i], grp)) {
+        if(!cx_strcmp(cx_strcast(usr->groups[i]), grp)) {
             return 1;
         }
     }
@@ -132,7 +134,7 @@
 }
 
 
-int ssha_verify(KeyfileUser *user, char *password) {
+int ssha_verify(KeyfileUser *user, const char *password) {
     /*
      * SSHA: SHA(pw + salt) + salt
      * user->hash is already base64 decoded