diff -r 99a34860c105 -r d938228c382e src/server/config/acl.c
--- a/src/server/config/acl.c	Wed Nov 02 19:19:01 2022 +0100
+++ b/src/server/config/acl.c	Sun Nov 06 15:53:32 2022 +0100
@@ -32,7 +32,7 @@
 
 #include "acl.h"
 
-ACLFile* load_acl_file(char *file) {
+ACLFile* load_acl_file(const char *file) {
     FILE *in = fopen(file, "r");
     if(in == NULL) {
         return NULL;
@@ -40,9 +40,9 @@
     
     ACLFile *conf = malloc(sizeof(ACLFile));
     conf->parser.parse = acl_parse;
-    conf->namedACLs = NULL;
-    conf->uriACLs = NULL;
-    conf->pathACLs = NULL;
+    conf->namedACLs = cxPointerLinkedListCreate(cxDefaultAllocator, cx_cmp_ptr);
+    conf->uriACLs = cxPointerLinkedListCreate(cxDefaultAllocator, cx_cmp_ptr);
+    conf->pathACLs = cxPointerLinkedListCreate(cxDefaultAllocator, cx_cmp_ptr);
     
     int r = cfg_parse_basic_file((ConfigParser*)conf, in);
     if(r != 0) {
@@ -56,45 +56,45 @@
 }
 
 void free_acl_file(ACLFile *conf) {
-    ucx_mempool_destroy(conf->parser.mp->pool);
+    //ucx_mempool_destroy(conf->parser.mp->pool);
     free(conf);
 }
 
-int acl_parse(void *p, ConfigLine *begin, ConfigLine *end, sstr_t line) {
+int acl_parse(void *p, ConfigLine *begin, ConfigLine *end, cxmutstr line) {
     ACLFile *aclf = p;
-    UcxAllocator *mp = aclf->parser.mp;
+    CxAllocator *mp = aclf->parser.mp;
     
-    if(sstrprefix(line, sstr("ACL "))) {
-        sstr_t param = sstrsubs(line, 4);
-        UcxList *plist = cfg_param_list(param, mp); 
+    if(cx_strprefix(cx_strcast(line), cx_str("ACL "))) {
+        cxmutstr param = cx_strsubs_m(line, 4);
+        ConfigParam *plist = cfg_param_list(param, mp); 
         ACLConfig *acl = OBJ_NEW(mp, ACLConfig);
         acl->type.ptr = NULL;
         acl->authparam = NULL;
         acl->entries = NULL;
         aclf->cur = acl;
         
-        sstr_t type = cfg_param_get(plist, sstr("type"));
-        sstr_t name = cfg_param_get(plist, sstr("name"));
-        sstr_t path = cfg_param_get(plist, sstr("path"));
-        sstr_t uri  = cfg_param_get(plist, sstr("uri"));
+        cxmutstr type = cfg_param_get(plist, cx_str("type"));
+        cxmutstr name = cfg_param_get(plist, cx_str("name"));
+        cxmutstr path = cfg_param_get(plist, cx_str("path"));
+        cxmutstr uri  = cfg_param_get(plist, cx_str("uri"));
         
         if(name.ptr) {
             acl->id = name;
-            aclf->namedACLs = ucx_list_append_a(mp, aclf->namedACLs, acl);
+            cxListAdd(aclf->namedACLs, acl);
         } else if(path.ptr) {
             acl->id = path;
-            aclf->pathACLs = ucx_list_append_a(mp, aclf->pathACLs, acl);
+            cxListAdd(aclf->pathACLs, acl);
         } else if(uri.ptr) {
             acl->id = uri;
-            aclf->uriACLs = ucx_list_append_a(mp, aclf->uriACLs, acl);
+            cxListAdd(aclf->uriACLs, acl);
         }
         
         if(type.ptr) {
             acl->type = type;
         }
-    } else if(sstrprefix(line, sstr("Authenticate "))) {
-        sstr_t param = sstrsubs(line, 13);
-        UcxList *plist = cfg_param_list(param, mp); 
+    } else if(cx_strprefix(cx_strcast(line), cx_str("Authenticate "))) {
+        cxmutstr param = cx_strsubs_m(line, 13);
+        ConfigParam *plist = cfg_param_list(param, mp); 
         aclf->cur->authparam = plist;
     } else {
         if(parse_ace(aclf, line)) {
@@ -106,14 +106,16 @@
     return 0;
 }
 
-int parse_ace(ACLFile *f, sstr_t line) {
+#define ACE_MAX_TOKENS 2048
+
+int parse_ace(ACLFile *f, cxmutstr line) {
     ACLConfig *cur = f->cur;
-    UcxAllocator *mp = f->parser.mp;
+    CxAllocator *mp = f->parser.mp;
     
-    ssize_t tkn = 0;
-    sstr_t *tk = sstrsplit(line, sstr(":"), &tkn);
+    cxstring *tk = NULL; 
+    ssize_t tkn = cx_strsplit_a(mp, cx_strcast(line), cx_str(":"), ACE_MAX_TOKENS, &tk);
     if(!tk || tkn < 3) {
-        log_ereport(LOG_FAILURE, "parse_ace: to few tokens");
+        log_ereport(LOG_FAILURE, "parse_ace: to few tokens: %.*s", (int)line.length, line.ptr);
         return 1;
     }
     
@@ -124,28 +126,28 @@
      * first step: determine who is affected by this ace
      */
     int n = 0;
-    sstr_t s = tk[0];
+    cxstring s = tk[0];
     
-    if(!sstrcmp(s, sstr("user"))) {
+    if(!cx_strcmp(s, cx_str("user"))) {
         // next token is the user name
         s = tk[1];
         n++;
-        ace->who = sstrdup_a(mp, s);
-    } else if(!sstrcmp(s, sstr("group"))) {
+        ace->who = cx_strdup_a(mp, s);
+    } else if(!cx_strcmp(s, cx_str("group"))) {
         // next token is the group name
         s = tk[1];
         n++;
-        ace->who = sstrdup_a(mp, s);
+        ace->who = cx_strdup_a(mp, s);
         ace->flags = ACLCFG_IDENTIFIER_GROUP;
-    } else if(!sstrcmp(s, sstr("owner@"))) {
+    } else if(!cx_strcmp(s, cx_str("owner@"))) {
         ace->flags = ACLCFG_OWNER;
-    } else if(!sstrcmp(s, sstr("group@"))) {
+    } else if(!cx_strcmp(s, cx_str("group@"))) {
         ace->flags = ACLCFG_GROUP;
-    } else if(!sstrcmp(s, sstr("everyone@"))) {
+    } else if(!cx_strcmp(s, cx_str("everyone@"))) {
         ace->flags = ACLCFG_EVERYONE;
     } else {
         // you can specify only the user name in the ace
-        ace->who = sstrdup_a(mp, s);
+        ace->who = cx_strdup_a(mp, s);
     }
     
     n++; //next token
@@ -161,13 +163,13 @@
     }
     s = tk[n];
     
-    ssize_t maskn = 0;
-    sstr_t *accessmask = sstrsplit(s, sstr(","), &maskn);
+    cxstring *accessmask = NULL;
+    ssize_t maskn = cx_strsplit_a(mp, s, cx_str(","), ACE_MAX_TOKENS, &accessmask);
     for(int i=0;i<maskn;i++) {
-        sstr_t access = accessmask[i];
+        cxstring access = accessmask[i];
         ace->access_mask = ace->access_mask | accstr2int(access);
     }
-    free(accessmask);
+    cxFree(mp, accessmask);
     n++; // next token
     
     /*
@@ -177,31 +179,31 @@
     int complete = 0;
     while(n < tkn) {
         s = tk[n];
-        if(!sstrcmp(s, sstr("allow"))) {
+        if(!cx_strcmp(s, cx_str("allow"))) {
             ace->type = ACLCFG_TYPE_ALLOWED;
             complete = 1;
             break;
-        } else if(!sstrcmp(s, sstr("deny"))) {
+        } else if(!cx_strcmp(s, cx_str("deny"))) {
             ace->type = ACLCFG_TYPE_DENIED;
             complete = 1;
             break;
-        } else if(!sstrcmp(s, sstr("audit"))) {
+        } else if(!cx_strcmp(s, cx_str("audit"))) {
             ace->type = ACLCFG_TYPE_AUDIT;
             complete = 1;
             break;
-        } else if(!sstrcmp(s, sstr("alarm"))) {
+        } else if(!cx_strcmp(s, cx_str("alarm"))) {
             ace->type = ACLCFG_TYPE_ALARM;
             complete = 1;
             break;
         } else {
             // set flags
-            ssize_t fln = 0;
-            sstr_t *flags = sstrsplit(s, sstr(","), &fln);
+            cxstring *flags = NULL;
+            ssize_t fln = cx_strsplit_a(mp, s, cx_str(","), ACE_MAX_TOKENS, &flags);
             for(int i=0;i<fln;i++) {
-                sstr_t flag = flags[i];
-                if(!sstrcmp(flag, sstr("successful_access_flag"))) {
+                cxstring flag = flags[i];
+                if(!cx_strcmp(flag, cx_str("successful_access_flag"))) {
                     ace->flags = ace->flags | ACLCFG_SUCCESSFUL_ACCESS_FLAG;
-                } else if(!sstrcmp(flag, sstr("failed_access_flag"))) {
+                } else if(!cx_strcmp(flag, cx_str("failed_access_flag"))) {
                     ace->flags = ace->flags | ACLCFG_FAILED_ACCESS_ACE_FLAG;
                 }
                 // TODO: other flags
@@ -216,52 +218,52 @@
         return 1;
     }
     
-    cur->entries = ucx_list_append_a(mp, cur->entries, ace);
+    CFG_ACE_ADD(&cur->entries, ace);
     
     return 0;
 }
 
-uint32_t accstr2int(sstr_t access) {
+uint32_t accstr2int(cxstring access) {
     uint32_t val = 0;
-    if(!sstrcmp(access, sstr("read"))) {
+    if(!cx_strcmp(access, cx_str("read"))) {
         val = ACLCFG_READ;
-    } else if(!sstrcmp(access, sstr("write"))) {
+    } else if(!cx_strcmp(access, cx_str("write"))) {
         val = ACLCFG_WRITE;
-    } else if(!sstrcmp(access, sstr("read_data"))) {
+    } else if(!cx_strcmp(access, cx_str("read_data"))) {
         val = ACLCFG_READ_DATA;
-    } else if(!sstrcmp(access, sstr("write_data"))) {
+    } else if(!cx_strcmp(access, cx_str("write_data"))) {
         val = ACLCFG_WRITE_DATA;
-    } else if(!sstrcmp(access, sstr("append"))) {
+    } else if(!cx_strcmp(access, cx_str("append"))) {
         val = ACLCFG_APPEND;
-    } else if(!sstrcmp(access, sstr("add"))) {
+    } else if(!cx_strcmp(access, cx_str("add"))) {
         val = ACLCFG_ADD_FILE;
-    } else if(!sstrcmp(access, sstr("add_file"))) {
+    } else if(!cx_strcmp(access, cx_str("add_file"))) {
         val = ACLCFG_ADD_FILE;
-    } else if(!sstrcmp(access, sstr("add_subdirectory"))) {
+    } else if(!cx_strcmp(access, cx_str("add_subdirectory"))) {
         val = ACLCFG_ADD_SUBDIRECTORY;
-    } else if(!sstrcmp(access, sstr("read_xattr"))) {
+    } else if(!cx_strcmp(access, cx_str("read_xattr"))) {
         val = ACLCFG_READ_XATTR;
-    } else if(!sstrcmp(access, sstr("write_xattr"))) {
+    } else if(!cx_strcmp(access, cx_str("write_xattr"))) {
         val = ACLCFG_WRITE_XATTR;
-    } else if(!sstrcmp(access, sstr("execute"))) {
+    } else if(!cx_strcmp(access, cx_str("execute"))) {
         val = ACLCFG_EXECUTE;
-    } else if(!sstrcmp(access, sstr("delete_child"))) {
+    } else if(!cx_strcmp(access, cx_str("delete_child"))) {
         val = ACLCFG_DELETE_CHILD;
-    } else if(!sstrcmp(access, sstr("delete"))) {
+    } else if(!cx_strcmp(access, cx_str("delete"))) {
         val = ACLCFG_DELETE;
-    } else if(!sstrcmp(access, sstr("read_attributes"))) {
+    } else if(!cx_strcmp(access, cx_str("read_attributes"))) {
         val = ACLCFG_READ_ATTRIBUTES;
-    } else if(!sstrcmp(access, sstr("write_attributes"))) {
+    } else if(!cx_strcmp(access, cx_str("write_attributes"))) {
         val = ACLCFG_WRITE_ATTRIBUTES;
-    } else if(!sstrcmp(access, sstr("list"))) {
+    } else if(!cx_strcmp(access, cx_str("list"))) {
         val = ACLCFG_LIST;
-    } else if(!sstrcmp(access, sstr("read_acl"))) {
+    } else if(!cx_strcmp(access, cx_str("read_acl"))) {
         val = ACLCFG_READ_ACL;
-    } else if(!sstrcmp(access, sstr("write_acl"))) {
+    } else if(!cx_strcmp(access, cx_str("write_acl"))) {
         val = ACLCFG_WRITE_ACL;
-    } else if(!sstrcmp(access, sstr("write_owner"))) {
+    } else if(!cx_strcmp(access, cx_str("write_owner"))) {
         val = ACLCFG_WRITE_OWNER;
-    } else if(!sstrcmp(access, sstr("synchronize"))) {
+    } else if(!cx_strcmp(access, cx_str("synchronize"))) {
         val = ACLCFG_SYNCHRONIZE;
     }
     return val;