webserver: comparison src/server/webdav/xml.c

-:99a34860c105
+:d938228c382e
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ucx/string.h>
+#include <cx/string.h>
-#include <ucx/map.h>
+#include <cx/map.h>
-#include <ucx/buffer.h>
+#include <cx/hash_map.h>
+#include <cx/buffer.h>
+#include <cx/linked_list.h>
 #include "../util/util.h"
 #include "../util/pool.h"
 #include "xml.h"
 /*
 * generates a string key for an xml namespace
 * format: prefix '\0' href
 */
-static sstr_t xml_namespace_key(UcxAllocator *a, WSNamespace *ns) {
+static CxHashKey xml_namespace_key(CxAllocator *a, WSNamespace *ns) {
-sstr_t key = sstrcat_a(a, 3,
+cxmutstr key_data = cx_strcat_a(a, 3,
-ns->prefix ? sstr((char*)ns->prefix) : S("\0"),
+ns->prefix ? cx_str((char*)ns->prefix) : cx_strn("\0", 1),
-S("\0"),
+cx_strn("\0", 1),
-sstr((char*)ns->href));
+cx_str((char*)ns->href));
-return key;
+return cx_hash_key_bytes((unsigned char*)key_data.ptr, key_data.length);
 }
 /*****************************************************************************
 *    Public functions
 }
 /* ------------------- wsxml_get_required_namespaces ------------------- */
 typedef struct WSNsCollector {
-UcxAllocator *a;
+CxAllocator *a;
-UcxMap *nsmap;
+CxMap *nsmap;
 WebdavNSList *def;
 int error;
 } WSNsCollector;
 static int nslist_node_begin(xmlNode *node, void *userdata) {
 WSNsCollector *col = userdata;
 // namespace required for all elements
 if(node->type == XML_ELEMENT_NODE && node->ns) {
 // we create a list of unique prefix-href namespaces by putting
 // all namespaces in a map
-sstr_t nskey = xml_namespace_key(col->a, node->ns);
+CxHashKey nskey = xml_namespace_key(col->a, node->ns);
-if(!nskey.ptr) {
+if(!nskey.data.bytes) {
 col->error = 1;
 return 1;
 }
-if(ucx_map_sstr_put(col->nsmap, nskey, node->ns)) {
+if(cxMapPut(col->nsmap, nskey, node->ns)) {
 col->error = 1;
 return 1;
 }
 // collect all namespace definitions for removing these namespaces
 // from col->nsmap later
 WSNamespace *def = node->nsDef;
 while(def) {
-WebdavNSList *newdef = col->a->malloc(
+WebdavNSList *newdef = cxMalloc(col->a, sizeof(WebdavNSList));
-col->a->pool, sizeof(WebdavNSList));
 if(!newdef) {
 col->error = 1;
 return 1;
 }
 newdef->namespace = def;
 WSXmlNode *node,
 int *error)
 {
 if(error) *error = 0;
-UcxAllocator a = util_pool_allocator(pool);
+CxAllocator *a = pool_allocator(pool);
-UcxMap *nsmap = ucx_map_new_a(&a, 16);
+CxMap *nsmap = cxHashMapCreate(a, 16);
 if(!nsmap) {
 if(error) *error = 1;
 return NULL;
 }
 WSNsCollector col;
-col.a = &a;
+col.a = a;
 col.nsmap = nsmap;
 col.def = NULL;
 // iterate over all xml elements
 // this will fill the hashmap with all namespaces
 } else {
 // remove all namespace definitions from the map
 // what we get is a map that contains all missing namespace definitions
 WebdavNSList *def = col.def;
 while(def) {
-sstr_t nskey = xml_namespace_key(&a, def->namespace);
+CxHashKey nskey = xml_namespace_key(a, def->namespace);
-if(!nskey.ptr) {
+if(!nskey.data.bytes) {
 if(error) *error = 1;
 break;
 }
-ucx_map_sstr_remove(nsmap, nskey);
+(void)cxMapRemove(nsmap, nskey);
 def = def->next;
 }
 // convert nsmap to a list
-UcxMapIterator i = ucx_map_iterator(nsmap);
+CxIterator i = cxMapIteratorValues(nsmap);
 WSNamespace *ns;
-UCX_MAP_FOREACH(key, ns, i) {
+cx_foreach(WSNamespace *, ns, i) {
 WebdavNSList *newelm = pool_malloc(pool, sizeof(WebdavNSList));
 if(!newelm) {
 if(error) *error = 1;
 list = NULL;
 break;
 }
 newelm->namespace = ns;
 newelm->next = NULL;
-newelm->prev = end; // NULL or the end of list
+newelm->prev = NULL;
-if(end) {
+cx_linked_list_add((void**)&list, (void**)&end, offsetof(WebdavNSList, prev), offsetof(WebdavNSList, next), newelm);
-end->next = newelm; // append new element
+}
-} else {
+}
-list = newelm; // start new list
-}
+cxMapDestroy(nsmap);
-end = newelm;
-}
-}
-ucx_map_free(nsmap);
 return list;
 }
 static ssize_t buf_writefunc(void *buf, const char *s, size_t len) {
-int w = ucx_buffer_write(s, 1, len, buf);
+int w = cxBufferWrite(s, 1, len, buf);
 return w == 0 ? IO_ERROR : w;
 }
 WSXmlData* wsxml_node2data(
 pool_handle_t *pool,
 WSXmlNode *node)
 {
-UcxBuffer *buf = ucx_buffer_new(NULL, 1024, UCX_BUFFER_AUTOEXTEND);
+CxBuffer buf;
-if(!buf) {
+if(cxBufferInit(&buf, NULL, 1024, pool_allocator(pool), CX_BUFFER_AUTO_EXTEND|CX_BUFFER_FREE_CONTENTS)) {
 return NULL;
 }
 int error = 0;
 WebdavNSList *nslist = wsxml_get_required_namespaces(pool, node, &error);
 return NULL;
 }
 Writer writer;
 char buffer[512];
-writer_init_with_stream(&writer, buf, buf_writefunc, buffer, 512);
+writer_init_with_stream(&writer, &buf, buf_writefunc, buffer, 512);
 WSXmlData *data = NULL;
 if(!wsxml_write_nodes(pool, &writer, NULL, node) && !writer_flush(&writer)) {
 data = pool_malloc(pool, sizeof(WSXmlData));
 if(data) {
-data->data = pool_malloc(pool, buf->size + 1);
+data->data = pool_malloc(pool, buf.size + 1);
 if(data->data) {
-memcpy(data->data, buf->space, buf->size);
+memcpy(data->data, buf.space, buf.size);
-data->data[buf->size] = '\0';
+data->data[buf.size] = '\0';
-data->length = buf->size;
+data->length = buf.size;
 data->namespaces = nslist;
 }
 }
 }
-ucx_buffer_free(buf);
+cxBufferDestroy(&buf);
 return data;
 }
 char* wsxml_nslist2string(pool_handle_t *pool, WebdavNSList *nslist) {
 elm->namespace = ns;
 if(!ns) {
 break;
 }
 memset(ns, 0, sizeof(WSNamespace));
-ns->prefix = prefix_len > 0 ? (xmlChar*)sstrdup_pool(pool, sstrn(prefix, prefix_len)).ptr : NULL;
+ns->prefix = prefix_len > 0 ? (xmlChar*)cx_strdup_pool(pool, cx_mutstrn(prefix, prefix_len)).ptr : NULL;
-ns->href = (xmlChar*)sstrdup_pool(pool, sstrn(href, i-href_start)).ptr;
+ns->href = (xmlChar*)cx_strdup_pool(pool, cx_mutstrn(href, i-href_start)).ptr;
 if(list_current) {
 list_current->next = elm;
 } else {
 list_start = elm;
 }
 /*
 * Map for all previously defined namespaces
 * key: (char*) namespace prefix
 * value: WSNamespace*
 */
-UcxMap *namespaces;
+CxMap *namespaces;
 /*
 * Should namespace definitions be created
 */
 WSBool define_namespaces;
 * type: 0 = element text, 1 = attribute text
 */
 static void xml_ser_text(Writer *out, int type, const char *text) {
 size_t start = 0;
 size_t i;
-sstr_t entityref = { NULL, 0 };
+cxstring entityref = { NULL, 0 };
 for(i=0;text[i]!='\0';i++) {
 char c = text[i];
 if(c == '&') {
-entityref = S("&amp;");
+entityref = (cxstring)CX_STR("&amp;");
 } else if(type == 0) {
 if(c == '<') {
-entityref = S("&lt;");
+entityref = (cxstring)CX_STR("&lt;");
 } else if(c == '>') {
-entityref = S("&gt;");
+entityref = (cxstring)CX_STR("&gt;");
 }
 } else {
 if(c == '\"') {
-entityref = S("&quot;");
+entityref = (cxstring)CX_STR("&quot;");
 } else if(c == '\'') {
-entityref = S("&apos;");
+entityref = (cxstring)CX_STR("&apos;");
 }
 }
 if(entityref.ptr) {
 size_t len = i-start;
 Writer *out = xw->out;
 writer_putc(out, '<');
 // write prefix and ':'
 if(node->ns && node->ns->prefix) {
-writer_puts(out, sstr((char*)node->ns->prefix));
+writer_puts(out, cx_str((char*)node->ns->prefix));
 writer_putc(out, ':');
 }
 // node name
-writer_puts(out, sstr((char*)node->name));
+writer_puts(out, cx_str((char*)node->name));
 // namespace definitions
 if(xw->define_namespaces) {
 xmlNs *nsdef = node->nsDef;
 while(nsdef) {
 // we define only namespaces without prefix or namespaces
 // with prefix, that are not already defined
 // xw->namespaces contains all namespace, that were defined
 // before xml serialization
 if(!nsdef->prefix) {
-writer_puts(out, S(" xmlns=\""));
+writer_put_lit(out, " xmlns=\"");
-writer_puts(out, sstr((char*)nsdef->href));
+writer_put_str(out, (char*)nsdef->href);
-writer_putc(out, '"');
+writer_putc   (out, '"');
 } else {
 WSNamespace *n = xw->namespaces ?
-ucx_map_cstr_get(xw->namespaces, (char*)nsdef->prefix) :
+cxMapGet(xw->namespaces, cx_hash_key_str((const char*)nsdef->prefix)) :
 NULL;
 if(!n) {
-writer_puts(out, S(" xmlns:"));
+writer_put_lit(out, " xmlns:");
-writer_puts(out, sstr((char*)nsdef->prefix));
+writer_put_str(out, (const char*)nsdef->prefix);
-writer_puts(out, S("=\""));
+writer_put_lit(out, "=\"");
-writer_puts(out, sstr((char*)nsdef->href));
+writer_put_str(out, (const char*)nsdef->href);
-writer_putc(out, '"');
+writer_putc   (out, '"');
 }
 }
 nsdef = nsdef->next;
 }
 while(attr) {
 // format: ' [<prefix>:]<name>="<value>"'
 writer_putc(out, ' ');
 // optional namespace
 if(attr->ns && attr->ns->prefix) {
-writer_puts(out, sstr((char*)attr->ns->prefix));
+writer_puts(out, cx_str((char*)attr->ns->prefix));
 writer_putc(out, ':');
 }
 // <name>="
-writer_puts(out, sstr((char*)attr->name));
+writer_put_str(out, (char*)attr->name);
-writer_puts(out, S("=\""));
+writer_put_lit(out, "=\"");
 // value
 xmlNode *value = attr->children;
 while(value) {
 if(value->content) {
 xml_ser_text(out, 1, (const char*)value->content);
 }
 if(node->children) {
 writer_putc(out, '>');
 } else {
-writer_puts(out, S("/>"));
+writer_put_lit(out, "/>");
 }
 }
 static int xml_ser_node_begin(xmlNode *node, void *userdata) {
 XmlWriter *xw = userdata;
 static int xml_ser_node_end(xmlNode *node, void *userdata) {
 XmlWriter *xw = userdata;
 Writer *out = xw->out;
 if(node->type == XML_ELEMENT_NODE) {
 if(node->children) {
-writer_puts(xw->out, S("</"));
+writer_put_lit(xw->out, "</");
 // write prefix and ':'
 if(node->ns && node->ns->prefix) {
-writer_puts(out, sstr((char*)node->ns->prefix));
+writer_puts(out, cx_str((char*)node->ns->prefix));
 writer_putc(out, ':');
 }
 // name and close tag
-writer_puts(out, sstr((char*)node->name));
+writer_puts(out, cx_str((char*)node->name));
 writer_putc(out, '>');
 } // element was already closed in xml_ser_node_begin
 }
 return 0;
 static int xml_write_nodes(
 pool_handle_t *pool,
 Writer *out,
-UcxMap *nsdefs,
+CxMap *nsdefs,
 WSBool createdefs,
 xmlNode *node)
 {
 XmlWriter xmlwriter;
 xmlwriter.pool = pool;
 }
 int wsxml_write_nodes(
 pool_handle_t *pool,
 Writer *out,
-UcxMap *nsdefs,
+CxMap *nsdefs,
 xmlNode *node)
 {
 return xml_write_nodes(pool, out, nsdefs, TRUE, node);
 }

Mercurial > hg > webserver / file comparison

comparison: src/server/webdav/xml.c

src/server/webdav/xml.c