diff -r a569148841ff -r efbd59642577 libidav/resource.c
--- a/libidav/resource.c	Sun Apr 16 14:12:24 2023 +0200
+++ b/libidav/resource.c	Fri Apr 21 21:25:32 2023 +0200
@@ -36,8 +36,12 @@
 #include "session.h"
 #include "methods.h"
 #include "crypto.h"
-#include "ucx/buffer.h"
-#include "ucx/utils.h"
+#include <cx/buffer.h>
+#include <cx/utils.h>
+#include <cx/hash_map.h>
+#include <cx/printf.h>
+#include <cx/basic_mempool.h>
+#include <cx/array_list.h>
 
 #include "resource.h"
 #include "xml.h"
@@ -45,11 +49,11 @@
 
 #define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b)
 
-DavResource* dav_resource_new(DavSession *sn, char *path) {
+DavResource* dav_resource_new(DavSession *sn, const char *path) {
     //char *href = util_url_path(url);
     //DavResource *res = dav_resource_new_href(sn, href);
     char *parent = util_parent_path(path);
-    char *name = util_resource_name(path); 
+    const char *name = util_resource_name(path); 
     char *href = dav_session_create_plain_href(sn, path);
     
     DavResource *res = dav_resource_new_full(sn, parent, name, href);
@@ -57,7 +61,7 @@
     return res;
 }
 
-DavResource* dav_resource_new_child(DavSession *sn, DavResource *parent, char *name) {
+DavResource* dav_resource_new_child(DavSession *sn, DavResource *parent, const char *name) {
     char *path = util_concat_path(parent->path, name);
     char *href = dav_session_create_plain_href(sn, path);
     DavResource *res = dav_resource_new_full(sn, parent->path, name, href);
@@ -66,8 +70,8 @@
 }
 
 
-DavResource* dav_resource_new_href(DavSession *sn, char *href) {  
-    DavResource *res = ucx_mempool_calloc(sn->mp, 1, sizeof(DavResource));
+DavResource* dav_resource_new_href(DavSession *sn, const char *href) {  
+    DavResource *res = cxCalloc(sn->mp->allocator, 1, sizeof(DavResource));
     res->session = sn;
     
     // set name, path and href
@@ -79,14 +83,14 @@
     return res;
 }
 
-DavResource* dav_resource_new_full(DavSession *sn, char *parent_path, char *name, char *href) {
-    sstr_t n = sstr(name);
+DavResource* dav_resource_new_full(DavSession *sn, const char *parent_path, const char *name, char *href) {
+    cxstring n = cx_str(name);
     // the name must not contain path separators
     if(n.length > 0 && href) {
         for(int i=0;i<n.length-1;i++) {
             char c = n.ptr[i];
             if(c == '/' || c == '\\') {
-                n = sstr(util_resource_name(href));
+                n = cx_str(util_resource_name(href));
                 break;
             }
         }
@@ -96,11 +100,11 @@
         n.length--;
     }
     
-    DavResource *res = ucx_mempool_calloc(sn->mp, 1, sizeof(DavResource));
+    DavResource *res = cxCalloc(sn->mp->allocator, 1, sizeof(DavResource));
     res->session = sn;
     
     // set name, path and href
-    res->name = sstrdup_a(sn->mp->allocator, n).ptr;
+    res->name = cx_strdup_a(sn->mp->allocator, n).ptr;
     
     char *path = util_concat_path(parent_path, name); 
     res->path = dav_session_strdup(sn, path);
@@ -112,23 +116,23 @@
     
     // cache href/path
     if(href) {
-        dav_session_cache_path(sn, sstr(path), sstr(href));
+        dav_session_cache_path(sn, cx_str(path), cx_str(href));
     }
     free(path);
     
     return res;
 }
 
-void resource_free_properties(DavSession *sn, UcxMap *properties) {
+void resource_free_properties(DavSession *sn, CxMap *properties) {
     if(!properties) return;
     
-    UcxMapIterator i = ucx_map_iterator(properties);
+    CxIterator i = cxMapIteratorValues(properties);
     DavProperty *property;
-    UCX_MAP_FOREACH(key, property, i) {
+    cx_foreach(DavProperty*, property, i) {
         // TODO: free everything
         dav_session_free(sn, property);
     }
-    ucx_map_free(properties);
+    cxMapDestroy(properties);
 }
 
 void dav_resource_free(DavResource *res) {
@@ -144,29 +148,62 @@
     resource_free_properties(sn, data->properties);
     resource_free_properties(sn, data->crypto_properties);
     
-    UCX_FOREACH(elm, data->set) {
-        DavProperty *p = elm->data;
-        dav_session_free(sn, p->ns->name);
-        if(p->ns->prefix) {
-            dav_session_free(sn, p->ns->prefix);
+    if(data->set) {
+        CxIterator i = cxListIterator(data->set);
+        cx_foreach(DavProperty *, p, i) {
+            dav_session_free(sn, p->ns->name);
+            if(p->ns->prefix) {
+                dav_session_free(sn, p->ns->prefix);
+            }
+            dav_session_free(sn, p->ns);
+
+            dav_session_free(sn, p->name);
+            dav_free_xml_node_sn(sn, p->value);
+            dav_session_free(sn, p);
         }
-        dav_session_free(sn, p->ns);
-        
-        dav_session_free(sn, p->name);
-        dav_free_xml_node_sn(sn, p->value);
-        dav_session_free(sn, p);
     }
     
-    UCX_FOREACH(elm, data->remove) {
-        DavProperty *p = elm->data;
-        dav_session_free(sn, p->ns->name);
-        if(p->ns->prefix) {
-            dav_session_free(sn, p->ns->prefix);
+    if(data->remove) {
+        CxIterator i = cxListIterator(data->remove);
+        cx_foreach(DavProperty *, p, i) {
+            dav_session_free(sn, p->ns->name);
+            if(p->ns->prefix) {
+                dav_session_free(sn, p->ns->prefix);
+            }
+            dav_session_free(sn, p->ns);
+
+            dav_session_free(sn, p->name);
+            dav_session_free(sn, p);
         }
-        dav_session_free(sn, p->ns);
-        
-        dav_session_free(sn, p->name);
-        dav_session_free(sn, p);
+    }
+    
+    if(data->crypto_set) {
+        CxIterator i = cxListIterator(data->crypto_set);
+        cx_foreach(DavProperty *, p, i) {
+            dav_session_free(sn, p->ns->name);
+            if(p->ns->prefix) {
+                dav_session_free(sn, p->ns->prefix);
+            }
+            dav_session_free(sn, p->ns);
+
+            dav_session_free(sn, p->name);
+            dav_free_xml_node_sn(sn, p->value);
+            dav_session_free(sn, p);
+        }
+    }
+    
+    if(data->crypto_remove) {
+        CxIterator i = cxListIterator(data->crypto_remove);
+        cx_foreach(DavProperty *, p, i) {
+            dav_session_free(sn, p->ns->name);
+            if(p->ns->prefix) {
+                dav_session_free(sn, p->ns->prefix);
+            }
+            dav_session_free(sn, p->ns);
+
+            dav_session_free(sn, p->name);
+            dav_session_free(sn, p);
+        }
     }
     
     if(!data->read && data->content) {
@@ -187,20 +224,20 @@
     }
 }
 
-void resource_set_href(DavResource *res, sstr_t href) {
-    res->href = sstrdup_a(res->session->mp->allocator, href).ptr;
+void resource_set_href(DavResource *res, cxstring href) {
+    res->href = cx_strdup_a(res->session->mp->allocator, href).ptr;
 }
 
-void resource_set_info(DavResource *res, char *href_str) {
+void resource_set_info(DavResource *res, const char *href_str) {
     char *url_str = NULL;
     curl_easy_getinfo(res->session->handle, CURLINFO_EFFECTIVE_URL, &url_str);
-    sstr_t name = sstr(util_resource_name(href_str));
-    sstr_t href = sstr(href_str);
+    cxstring name = cx_str(util_resource_name(href_str));
+    cxstring href = cx_str(href_str);
     
-    sstr_t base_href = sstr(util_url_path(res->session->base_url));
-    sstr_t path = sstrsubs(href, base_href.length - 1);
+    cxstring base_href = cx_str(util_url_path(res->session->base_url));
+    cxstring path = cx_strsubs(href, base_href.length - 1);
     
-    UcxAllocator *a = res->session->mp->allocator;
+    const CxAllocator *a = res->session->mp->allocator;
     CURL *handle = res->session->handle;
     
     int nlen = 0;
@@ -208,22 +245,22 @@
     int plen = 0;
     char *upath = curl_easy_unescape(handle, path.ptr, path.length, &plen); 
     
-    res->name = sstrdup_a(a, sstrn(uname, nlen)).ptr;
-    res->href = sstrdup_a(a, href).ptr;
-    res->path = sstrdup_a(a, sstrn(upath, plen)).ptr;
+    res->name = cx_strdup_a(a, cx_strn(uname, nlen)).ptr;
+    res->href = cx_strdup_a(a, href).ptr;
+    res->path = cx_strdup_a(a, cx_strn(upath, plen)).ptr;
     
     curl_free(uname);
     curl_free(upath);
 }
 
 DavResourceData* resource_data_new(DavSession *sn) {
-    DavResourceData *data = ucx_mempool_malloc(
-            sn->mp,
+    DavResourceData *data = cxMalloc(
+            sn->mp->allocator,
             sizeof(DavResourceData));
     if(!data) {
         return NULL;
     }
-    data->properties = ucx_map_new_a(sn->mp->allocator, 32);
+    data->properties = cxHashMapCreate(sn->mp->allocator, CX_STORE_POINTERS, 32);
     data->crypto_properties = NULL;
     data->set = NULL;
     data->remove = NULL;
@@ -257,9 +294,10 @@
     prop->ns = namespace;
     prop->value = val;
     
-    sstr_t key = dav_property_key(ns, name);
-    ucx_map_sstr_put(((DavResourceData*)res->data)->properties, key, prop);
-    free(key.ptr);
+    cxmutstr keystr = dav_property_key(ns, name);
+    CxHashKey key = cx_hash_key(keystr.ptr, keystr.length);
+    cxMapPut(((DavResourceData*)res->data)->properties, key, prop);
+    free(keystr.ptr);
 }
 
 void resource_add_property(DavResource *res, const char *ns, const char *name, xmlNode *val) {
@@ -278,15 +316,15 @@
     resource_add_prop(res, ns, name, dav_text_node(res->session, val));
 }
 
-void resource_set_crypto_properties(DavResource *res, UcxMap *cprops) {
+void resource_set_crypto_properties(DavResource *res, CxMap *cprops) {
     DavResourceData *data = res->data;
     resource_free_properties(res->session, data->crypto_properties);
     data->crypto_properties = cprops;
 }
 
 DavXmlNode* resource_get_property(DavResource *res, const char *ns, const char *name) {
-    sstr_t keystr = dav_property_key(ns, name);
-    UcxKey key = ucx_key(keystr.ptr, keystr.length);
+    cxmutstr keystr = dav_property_key(ns, name);
+    CxHashKey key = cx_hash_key(keystr.ptr, keystr.length);
     DavXmlNode *ret = resource_get_property_k(res, key);
     free(keystr.ptr);
     
@@ -294,37 +332,37 @@
 }
 
 DavXmlNode* resource_get_encrypted_property(DavResource *res, const char *ns, const char *name) {
-    sstr_t keystr = dav_property_key(ns, name);
-    UcxKey key = ucx_key(keystr.ptr, keystr.length);
+    cxmutstr keystr = dav_property_key(ns, name);
+    CxHashKey key = cx_hash_key(keystr.ptr, keystr.length);
     DavXmlNode *ret = resource_get_encrypted_property_k(res, key);
     free(keystr.ptr);
     
     return ret;
 }
 
-DavXmlNode* resource_get_property_k(DavResource *res, UcxKey key) {
+DavXmlNode* resource_get_property_k(DavResource *res, CxHashKey key) {
     DavResourceData *data = (DavResourceData*)res->data;
-    DavProperty *property = ucx_map_get(data->properties, key);
+    DavProperty *property = cxMapGet(data->properties, key);
     
     return property ? property->value : NULL;
 }
 
-DavXmlNode* resource_get_encrypted_property_k(DavResource *res, UcxKey key) {
+DavXmlNode* resource_get_encrypted_property_k(DavResource *res, CxHashKey key) {
     DavResourceData *data = (DavResourceData*)res->data;
-    DavProperty *property = ucx_map_get(data->crypto_properties, key);
+    DavProperty *property = cxMapGet(data->crypto_properties, key);
     
     return property ? property->value : NULL;
 }
 
-sstr_t dav_property_key(const char *ns, const char *name) {
-    return dav_property_key_a(ucx_default_allocator(), ns, name);
+cxmutstr dav_property_key(const char *ns, const char *name) {
+    return dav_property_key_a(cxDefaultAllocator, ns, name);
 }
 
-sstr_t dav_property_key_a(UcxAllocator *a, const char *ns, const char *name) {
-    scstr_t ns_str = scstr(ns);
-    scstr_t name_str = scstr(name);
+cxmutstr dav_property_key_a(const CxAllocator *a, const char *ns, const char *name) {
+    cxstring ns_str = cx_str(ns);
+    cxstring name_str = cx_str(name);
     
-    return sstrcat_a(a, 4, ns_str, S("\0"), name_str, S("\0"));
+    return cx_strcat_a(a, 4, ns_str, CX_STR("\0"), name_str, CX_STR("\0"));
 }
 
 
@@ -411,7 +449,7 @@
     return cr->descending ? -ret : ret;
 }
 
-void resource_add_ordered_child(DavResource *parent, DavResource *child, UcxList *ordercr) {
+void resource_add_ordered_child(DavResource *parent, DavResource *child, CxList *ordercr) {
     if(!ordercr) {
         resource_add_child(parent, child);
         return;
@@ -427,8 +465,8 @@
         DavResource *resource = parent->children;
         while(resource) {
             int r = 0;
-            UCX_FOREACH(elm, ordercr) {
-                DavOrderCriterion *cr = elm->data;
+            CxIterator i = cxListIterator(ordercr);
+            cx_foreach(DavOrderCriterion*, cr, i) {
                 r = resource_cmp(child, resource, cr);
                 if(r != 0) {
                     break;
@@ -495,8 +533,8 @@
     DavResourceData *data = res->data;
     
     DavXmlNode *property = NULL;
-    UcxList *remove_list = NULL;
-    UcxList *set_list = NULL;
+    CxList *remove_list = NULL;
+    CxList *set_list = NULL;
     
     if(encrypted) {
         // check if crypto_properties because it will only be created
@@ -515,23 +553,27 @@
     
     // resource_get_property only returns persistent properties
     // check the remove and set list
-    if(property) {
+    if(property && remove_list) {
         // if the property is in the remove list, we return NULL
-        UCX_FOREACH(elm, remove_list) {
-            DavProperty *p = elm->data;
+        CxIterator i = cxListIterator(remove_list);
+        cx_foreach(DavProperty*, p, i) {
             if(!strcmp(p->name, name) && !strcmp(p->ns->name, ns)) {
                 return NULL;
             }
         }
     }
+    
     // the set list contains property updates
     // we return an updated property if possible
-    UCX_FOREACH(elm, set_list) {
-        DavProperty *p = elm->data;
-        if(!strcmp(p->name, name) && !strcmp(p->ns->name, ns)) {
-            return p->value; // TODO: fix
+    if(set_list) {
+        CxIterator i = cxListIterator(set_list);
+        cx_foreach(DavProperty*, p, i) {
+            if(!strcmp(p->name, name) && !strcmp(p->ns->name, ns)) {
+                return p->value; // TODO: fix
+            }
         }
     }
+    
     // no property update
     
     return property;
@@ -572,18 +614,30 @@
     dav_set_string_property_ns(res, pns, pname, value);
 }
 
+static int add2propertylist(const CxAllocator *a, CxList **list, DavProperty *property) {
+    if(!*list) {
+        CxList *newlist = cxLinkedListCreate(a, NULL, CX_STORE_POINTERS);
+        if(!newlist) {
+            return 1;
+        }
+        *list = newlist;
+    }
+    cxListAdd(*list, property);
+    return 0;
+}
+
 void dav_set_string_property_ns(DavResource *res, char *ns, char *name, char *value) {
     DavSession *sn = res->session;
-    UcxAllocator *a = res->session->mp->allocator;
+    const CxAllocator *a = res->session->mp->allocator;
     DavResourceData *data = res->data;
     
     DavProperty *property = createprop(res->session, ns, name);
     property->value = dav_text_node(res->session, value);
     
     if(DAV_ENCRYPT_PROPERTIES(sn) && dav_namespace_is_encrypted(sn->context, ns)) {
-        data->crypto_set = ucx_list_append_a(a, data->crypto_set, property);
+        add2propertylist(a, &data->crypto_set, property);
     } else {
-        data->set = ucx_list_append_a(a, data->set, property);
+        add2propertylist(a, &data->set, property);
     }
 }
 
@@ -596,7 +650,7 @@
 
 void dav_set_property_ns(DavResource *res, char *ns, char *name, DavXmlNode *value) {
     DavSession *sn = res->session;
-    UcxAllocator *a = sn->mp->allocator; 
+    const CxAllocator *a = sn->mp->allocator; 
     DavResourceData *data = res->data;
     
     DavProperty *property = createprop(sn, ns, name);
@@ -605,9 +659,9 @@
     property->value = value;
     
     if(DAV_ENCRYPT_PROPERTIES(sn) && dav_namespace_is_encrypted(sn->context, ns)) {
-        data->crypto_set = ucx_list_append_a(a, data->crypto_set, property);
+        add2propertylist(a, &data->crypto_set, property);
     } else {
-        data->set = ucx_list_append_a(a, data->set, property);
+        add2propertylist(a, &data->set, property);
     }
 }
 
@@ -621,44 +675,44 @@
 void dav_remove_property_ns(DavResource *res, char *ns, char *name) {
     DavSession *sn = res->session;
     DavResourceData *data = res->data;
-    UcxAllocator *a = res->session->mp->allocator;
+    const CxAllocator *a = res->session->mp->allocator;
     
     DavProperty *property = createprop(res->session, ns, name);
     
     if(DAV_ENCRYPT_PROPERTIES(sn) && dav_namespace_is_encrypted(sn->context, ns)) {
-        data->crypto_remove = ucx_list_append_a(a, data->crypto_remove, property);
+        add2propertylist(a, &data->crypto_remove, property);
     } else {
-        data->remove = ucx_list_append_a(a, data->remove, property);
+        add2propertylist(a, &data->remove, property);
     }
 }
 
 void dav_set_encrypted_property_ns(DavResource *res, char *ns, char *name, DavXmlNode *value) {
-    UcxAllocator *a = res->session->mp->allocator;
+    const CxAllocator *a = res->session->mp->allocator;
     DavResourceData *data = res->data;
     
     DavProperty *property = createprop(res->session, ns, name);
     property->value = value; // TODO: copy node?
     
-    data->crypto_set = ucx_list_append_a(a, data->crypto_set, property);
+    add2propertylist(a, &data->crypto_set, property);
 }
 
 void dav_set_encrypted_string_property_ns(DavResource *res, char *ns, char *name, char *value) {
-    UcxAllocator *a = res->session->mp->allocator;
+    const CxAllocator *a = res->session->mp->allocator;
     DavResourceData *data = res->data;
     
     DavProperty *property = createprop(res->session, ns, name);
     property->value = dav_text_node(res->session, value);
     
-    data->crypto_set = ucx_list_append_a(a, data->crypto_set, property);
+    add2propertylist(a, &data->crypto_set, property);
 }
 
 void dav_remove_encrypted_property_ns(DavResource *res, char *ns, char *name) {
     DavResourceData *data = res->data;
-    UcxAllocator *a = res->session->mp->allocator;
+    const CxAllocator *a = res->session->mp->allocator;
     
     DavProperty *property = createprop(res->session, ns, name);
     
-    data->crypto_remove = ucx_list_append_a(a, data->crypto_remove, property);
+    add2propertylist(a, &data->crypto_remove, property);
 }
 
 static int compare_propname(const void *a, const void *b) {
@@ -676,17 +730,17 @@
 DavPropName* dav_get_property_names(DavResource *res, size_t *count) {
     DavResourceData *data = res->data;
     
-    *count = data->properties->count;
+    *count = data->properties->size;
     DavPropName *names = dav_session_calloc(
             res->session,
             *count,
             sizeof(DavPropName));
     
     
-    UcxMapIterator i = ucx_map_iterator(data->properties);
+    CxIterator i = cxMapIteratorValues(data->properties);
     DavProperty *value;
     int j = 0;
-    UCX_MAP_FOREACH(key, value, i) {
+    cx_foreach(DavProperty*, value, i) {
         DavPropName *name = &names[j];
         
         name->ns = value->ns->name;
@@ -726,34 +780,35 @@
 
 
 int dav_load(DavResource *res) {
-    UcxBuffer *rqbuf = create_allprop_propfind_request();
+    CxBuffer *rqbuf = create_allprop_propfind_request();
     int ret = dav_propfind(res->session, res, rqbuf);
-    ucx_buffer_free(rqbuf);
+    cxBufferFree(rqbuf);
     return ret;
 }
 
 int dav_load_prop(DavResource *res, DavPropName *properties, size_t numprop) {
-    UcxMempool *mp = ucx_mempool_new(64);
+    CxMempool *mp = cxBasicMempoolCreate(64);
+    const CxAllocator *a = mp->allocator;
     
-    UcxList *proplist = NULL;
+    CxList *proplist = cxArrayListCreate(a, NULL, sizeof(DavProperty), numprop);
     for(size_t i=0;i<numprop;i++) {
-        DavProperty *p = ucx_mempool_malloc(mp, sizeof(DavProperty));
-        p->name = properties[i].name;
-        p->ns = ucx_mempool_malloc(mp, sizeof(DavNamespace));
-        p->ns->name = properties[i].ns;
+        DavProperty p;
+        p.name = properties[i].name;
+        p.ns = cxMalloc(a, sizeof(DavNamespace));
+        p.ns->name = properties[i].ns;
         if(!strcmp(properties[i].ns, "DAV:")) {
-            p->ns->prefix = "D";
+            p.ns->prefix = "D";
         } else {
-            p->ns->prefix = ucx_asprintf(mp->allocator, "x%d", i).ptr;
+            p.ns->prefix = cx_asprintf_a(a, "x%d", (int)i).ptr;
         }
-        p->value = NULL;
-        proplist = ucx_list_append_a(mp->allocator, proplist, p);
+        p.value = NULL;
+        cxListAdd(proplist, &p);
     }
     
-    UcxBuffer *rqbuf = create_propfind_request(res->session, proplist, "propfind", 0);
+    CxBuffer *rqbuf = create_propfind_request(res->session, proplist, "propfind", 0);
     int ret = dav_propfind(res->session, res, rqbuf);
-    ucx_buffer_free(rqbuf);
-    ucx_mempool_destroy(mp);
+    cxBufferFree(rqbuf);
+    cxMempoolDestroy(mp);
     return ret;
 }
 
@@ -805,7 +860,7 @@
         CURLcode ret;
         if(encryption) {
             AESEncrypter *enc = NULL;
-            UcxBuffer *buf = NULL;
+            CxBuffer *buf = NULL;
             if(data->read) {
                 enc = aes_encrypter_new(
                         sn->key,
@@ -813,13 +868,13 @@
                         data->read,
                         data->seek);
             } else {
-                buf = ucx_buffer_new(data->content, data->length, 0);
+                buf = cxBufferCreate(data->content, data->length, cxDefaultAllocator, 0);
                 buf->size = data->length;
                 enc = aes_encrypter_new(
                         sn->key,
                         buf,
-                        (dav_read_func)ucx_buffer_read,
-                        (dav_seek_func)dav_buffer_seek);
+                        (dav_read_func)cxBufferRead,
+                        (dav_seek_func)cxBufferSeek);
             }
               
             // put resource
@@ -838,7 +893,7 @@
             
             aes_encrypter_close(enc);
             if(buf) {
-                ucx_buffer_free(buf);
+                cxBufferFree(buf);
             }
             
             // add crypto properties
@@ -851,15 +906,15 @@
             free(enc_hash);
         } else if((sn->flags & DAV_SESSION_STORE_HASH) == DAV_SESSION_STORE_HASH) {
             HashStream hstr;
-            UcxBuffer *iobuf = NULL;
+            CxBuffer *iobuf = NULL;
             if(!data->read) {
-                iobuf = ucx_buffer_new(data->content, data->length, 0);
+                iobuf = cxBufferCreate(data->content, data->length, cxDefaultAllocator, 0);
                 iobuf->size = data->length;
                 init_hash_stream(
                         &hstr,
                         iobuf,
-                        (dav_read_func)ucx_buffer_read,
-                        (dav_seek_func)ucx_buffer_seek);
+                        (dav_read_func)cxBufferRead,
+                        (dav_seek_func)cxBufferSeek);
             } else {
                 init_hash_stream(
                         &hstr,
@@ -900,7 +955,7 @@
             res->session->error = 0;
             // cleanup node data
             if(!data->read) {
-                ucx_mempool_free(sn->mp, data->content);
+                cxFree(sn->mp->allocator, data->content);
             }
             data->content = NULL;
             data->read = NULL;
@@ -917,51 +972,56 @@
         int ret = 1;
         
         if(crypto_res) {
-            UcxBuffer *rqbuf = create_cryptoprop_propfind_request();
+            CxBuffer *rqbuf = create_cryptoprop_propfind_request();
             ret = dav_propfind(res->session, res, rqbuf);
-            ucx_buffer_free(rqbuf);
+            cxBufferFree(rqbuf);
         }
         
         if(!ret) {
             DavXmlNode *crypto_prop_node = dav_get_property_ns(crypto_res, DAV_NS, "crypto-prop");
-            UcxMap *crypto_props = parse_crypto_prop(sn, sn->key, crypto_prop_node);
+            CxMap *crypto_props = parse_crypto_prop(sn, sn->key, crypto_prop_node);
             if(!crypto_props) {
                 // resource hasn't encrypted properties yet
-                crypto_props = ucx_map_new(32); // create new map
+                crypto_props = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 32); // create new map
             }
             
             // remove all properties
-            UCX_FOREACH(elm, data->crypto_remove) {
-                if(crypto_props->count == 0) {
-                    break; // map already empty, can't remove any more
+            if(data->crypto_remove) {
+                CxIterator i = cxListIterator(data->crypto_remove);
+                cx_foreach(DavProperty *, property, i) {
+                    if(crypto_props->size == 0) {
+                        break; // map already empty, can't remove any more
+                    }
+
+                    cxmutstr key = dav_property_key(property->ns->name, property->name);
+                    DavProperty *existing_prop = cxMapGet(crypto_props, cx_hash_key(key.ptr, key.length));
+                    if(existing_prop) {
+                        // TODO: free existing_prop
+                    }                
+                    free(key.ptr);
                 }
-                
-                DavProperty *property = elm->data;
-                sstr_t key = dav_property_key(property->ns->name, property->name);
-                DavProperty *existing_prop = ucx_map_sstr_remove(crypto_props, key);
-                if(existing_prop) {
-                    // TODO: free existing_prop
-                }                
-                free(key.ptr);
             }
             
             // set properties
-            UCX_FOREACH(elm, data->crypto_set) {
-                DavProperty *property = elm->data;
-                sstr_t key = dav_property_key(property->ns->name, property->name);
-                DavProperty *existing_prop = ucx_map_sstr_remove(crypto_props, key);
-                ucx_map_sstr_put(crypto_props, key, property);
-                if(existing_prop) {
-                    // TODO: free existing_prop
-                }  
-                free(key.ptr);
+            if(data->crypto_set) {
+                CxIterator i = cxListIterator(data->crypto_set);
+                cx_foreach(DavProperty *, property, i) {
+                    cxmutstr keystr = dav_property_key(property->ns->name, property->name);
+                    CxHashKey key = cx_hash_key(keystr.ptr, keystr.length);
+                    DavProperty *existing_prop = cxMapRemoveAndGet(crypto_props, key);
+                    cxMapPut(crypto_props, key, property);
+                    if(existing_prop) {
+                        // TODO: free existing_prop
+                    }  
+                    free(keystr.ptr);
+                }
             }
             
             DavXmlNode *crypto_prop_value = create_crypto_prop(sn, crypto_props);
             if(crypto_prop_value) {
                 DavProperty *new_crypto_prop = createprop(sn, DAV_NS, "crypto-prop");
                 new_crypto_prop->value = crypto_prop_value;
-                data->set = ucx_list_prepend_a(sn->mp->allocator, data->set, new_crypto_prop);
+                add2propertylist(sn->mp->allocator, &data->set, new_crypto_prop);
             }
             
             dav_resource_free(crypto_res);
@@ -976,8 +1036,8 @@
     int r = 0;
     sn->error = DAV_OK;
     if(data->set || data->remove) {
-        UcxBuffer *request = create_proppatch_request(data);
-        UcxBuffer *response = ucx_buffer_new(NULL, 1024, UCX_BUFFER_AUTOEXTEND);
+        CxBuffer *request = create_proppatch_request(data);
+        CxBuffer *response = cxBufferCreate(NULL, 1024, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
         //printf("request:\n%.*s\n\n", request->pos, request->space);
 
         CURLcode ret = do_proppatch_request(sn, locktoken, request, response);
@@ -994,8 +1054,8 @@
             r = -1;
         }
         
-        ucx_buffer_free(request);
-        ucx_buffer_free(response);
+        cxBufferFree(request);
+        cxBufferFree(response);
     }
      
     return r;
@@ -1129,7 +1189,7 @@
     DavLock *lock = dav_get_lock(res->session, res->path);
     char *locktoken = lock ? lock->token : NULL;
     
-    UcxBuffer *response = ucx_buffer_new(NULL, 4096, UCX_BUFFER_AUTOEXTEND);
+    CxBuffer *response = cxBufferCreate(NULL, 4096, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
     CURLcode ret = do_delete_request(res->session, locktoken, response);
     long status = 0;
     curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
@@ -1145,7 +1205,7 @@
         r = 1;
     }
     
-    ucx_buffer_free(response);
+    cxBufferFree(response);
     return r;
 }
 
@@ -1172,7 +1232,7 @@
         curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &status);
         if(status == 201) {
             // resource successfully created
-            char *name = util_resource_name(p);
+            char *name = (char*)util_resource_name(p);
             int len = strlen(name);
             if(name[len - 1] == '/') {
                 name[len - 1] = '\0';
@@ -1225,9 +1285,9 @@
         // if the session has encrypted file names, add crypto infos
         if(!resource_add_crypto_info(sn, res->href, res->name, NULL)) {
             // do a minimal propfind request
-            UcxBuffer *rqbuf = create_propfind_request(sn, NULL, "propfind", 0);
+            CxBuffer *rqbuf = create_propfind_request(sn, NULL, "propfind", 0);
             int ret = dav_propfind(sn, res, rqbuf);
-            ucx_buffer_free(rqbuf);
+            cxBufferFree(rqbuf);
             return ret;
         } else {
             return 1;
@@ -1331,26 +1391,26 @@
     CURL *handle = sn->handle;
     util_set_url(sn, dav_resource_get_href(res));
     
-    UcxBuffer *request = create_lock_request();
-    UcxBuffer *response = ucx_buffer_new(NULL, 512, UCX_BUFFER_AUTOEXTEND);
+    CxBuffer *request = create_lock_request();
+    CxBuffer *response = cxBufferCreate(NULL, 512, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
     CURLcode ret = do_lock_request(sn, request, response, timeout);
     
     //printf("\nlock\n");
     //printf("%.*s\n\n", request->size, request->space);
     //printf("%.*s\n\n", response->size, response->space);
     
-    ucx_buffer_free(request);
+    cxBufferFree(request);
     
     long status = 0;
     curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
     if(ret == CURLE_OK && (status >= 200 && status < 300)) {
         LockDiscovery lock;
-        if(parse_lock_response(sn, response, &lock)) {
+        int parse_error = parse_lock_response(sn, response, &lock);
+        cxBufferFree(response);
+        if(parse_error) {
             sn->error = DAV_ERROR;
-            ucx_buffer_free(response);
             return -1;
         }
-        ucx_buffer_free(response);
         
         DavLock *l = dav_create_lock(sn, lock.locktoken, lock.timeout);
         free(lock.locktoken);
@@ -1373,7 +1433,7 @@
         }
     } else {
         dav_session_set_error(sn, ret, status);
-        ucx_buffer_free(response);
+        cxBufferFree(response);
         return -1;
     }
 }
@@ -1408,46 +1468,47 @@
         return 0;
     }
     
-    UcxBuffer *request = create_crypto_proppatch_request(sn, sn->key, name, hash);
-    UcxBuffer *response = ucx_buffer_new(NULL, 1024, UCX_BUFFER_AUTOEXTEND);
+    CxBuffer *request = create_crypto_proppatch_request(sn, sn->key, name, hash);
+    CxBuffer *response = cxBufferCreate(NULL, 1024, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
     
     util_set_url(sn, href);
     // TODO: lock
     CURLcode ret = do_proppatch_request(sn, NULL, request, response);
-    ucx_buffer_free(request);
+    cxBufferFree(request);
     long status = 0;
     curl_easy_getinfo (sn->handle, CURLINFO_RESPONSE_CODE, &status);
     if(ret == CURLE_OK && status == 207) {
         // TODO: parse response
         sn->error = DAV_OK;   
-        ucx_buffer_free(response);
+        cxBufferFree(response);
         return 0;
     } else {
         dav_session_set_error(sn, ret, status);
-        ucx_buffer_free(response);
+        cxBufferFree(response);
         return 1;
     }
 }
 
 /* ----------------------------- crypto-prop  ----------------------------- */
 
-DavXmlNode* create_crypto_prop(DavSession *sn, UcxMap *properties) {
+DavXmlNode* create_crypto_prop(DavSession *sn, CxMap *properties) {
     if(!sn->key) {
         return NULL;
     }
     
-    UcxBuffer *content = ucx_buffer_new(NULL, 2048, UCX_BUFFER_AUTOEXTEND);
+    CxBuffer *content = cxBufferCreate(NULL, 2048, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
     
     // create an xml document containing all properties
-    UcxMap *nsmap = ucx_map_new(8);
-    ucx_map_cstr_put(nsmap, "DAV:", strdup("D"));
+    CxMap *nsmap = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 8);
+    nsmap->simple_destructor = free;
+    cxMapPut(nsmap, cx_hash_key_str("DAV:"), strdup("D"));
     
-    ucx_buffer_puts(content, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
-    ucx_buffer_puts(content, "<D:prop xmlns:D=\"DAV:\">\n");
+    cxBufferPutString(content, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+    cxBufferPutString(content, "<D:prop xmlns:D=\"DAV:\">\n");
     
-    UcxMapIterator i = ucx_map_iterator(properties);
+    CxIterator i = cxMapIteratorValues(properties);
     DavProperty *prop;
-    UCX_MAP_FOREACH(key, prop, i) {
+    cx_foreach(DavProperty*, prop, i) {
         DavXmlNode pnode;
         pnode.type = DAV_XML_ELEMENT;
         pnode.namespace = prop->ns->name;
@@ -1460,18 +1521,17 @@
         pnode.content = NULL;
         pnode.contentlength = 0;
         
-        dav_print_node(content, (write_func)ucx_buffer_write, nsmap, &pnode);
-        ucx_buffer_putc(content, '\n');
+        dav_print_node(content, (cx_write_func)cxBufferWrite, nsmap, &pnode);
+        cxBufferPut(content, '\n');
     }
     
-    ucx_buffer_puts(content, "</D:prop>");
+    cxBufferPutString(content, "</D:prop>");
     
-    ucx_map_free_content(nsmap, (ucx_destructor)free);
-    ucx_map_free(nsmap);
+    cxMapDestroy(nsmap);
     
     // encrypt xml document
     char *crypto_prop_content = aes_encrypt(content->space, content->size, sn->key);
-    ucx_buffer_free(content);
+    cxBufferDestroy(content);
     
     DavXmlNode *ret = NULL;
     if(crypto_prop_content) {
@@ -1481,7 +1541,7 @@
     return ret;
 }
 
-UcxMap* parse_crypto_prop(DavSession *sn, DavKey *key, DavXmlNode *node) {
+CxMap* parse_crypto_prop(DavSession *sn, DavKey *key, DavXmlNode *node) {
     if(!node || node->type != DAV_XML_TEXT || node->contentlength == 0) {
         return NULL;
     }
@@ -1489,7 +1549,7 @@
     return parse_crypto_prop_str(sn, key, node->content);
 }
 
-UcxMap* parse_crypto_prop_str(DavSession *sn, DavKey *key, const char *content) {
+CxMap* parse_crypto_prop_str(DavSession *sn, DavKey *key, const char *content) {
     size_t len = 0;
     char *dec_str = aes_decrypt(content, &len, key);
     
@@ -1519,7 +1579,7 @@
     }
     
     // ready to get the properties
-    UcxMap *map = ucx_map_new(32);
+    CxMap *map = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 32);
     xmlNode *n = xml_root->children;
     while(n) {
         if(n->type == XML_ELEMENT_NODE && n->ns && n->ns->href) {
@@ -1531,16 +1591,16 @@
                     dav_session_strdup(sn, (const char*)n->ns->prefix) : NULL;
             property->value = n->children ? dav_convert_xml(sn, n->children) : NULL;
             
-            sstr_t key = dav_property_key(property->ns->name, property->name);
-            ucx_map_sstr_put(map, key, property);
+            cxmutstr key = dav_property_key(property->ns->name, property->name);
+            cxMapPut(map, cx_hash_key(key.ptr, key.length), property);
             free(key.ptr);
         }
         n = n->next;
     }
     
     xmlFreeDoc(doc);
-    if(map->count == 0) {
-        ucx_map_free(map);
+    if(map->size == 0) {
+        cxMapDestroy(map);
         return NULL;
     }
     return map;