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

-:99a34860c105
+:d938228c382e
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
-#include <ucx/list.h>
+#include <cx/list.h>
 #include "../daemon/session.h"
 #include "../util/pblock.h"
 #include "operation.h"
 WebdavOperation* webdav_create_propfind_operation(
 Session *sn,
 Request *rq,
 WebdavBackend *dav,
 WebdavPList *reqprops,
-UcxList *requests,
+WebdavPropfindRequestList *requests,
 WebdavResponse *response)
 {
 WebdavOperation *op = pool_malloc(sn->pool, sizeof(WebdavOperation));
 ZERO(op, sizeof(WebdavOperation));
 op->dav = dav;
 // store data that we need when the resource will be closed
 op->stat = s;
 op->parent = parent;
 // get first propfind object
-WebdavPropfindRequest *propfind = op->requests->data;
+WebdavPropfindRequest *propfind = op->requests->propfind;
 // execute propfind_do of the first backend for the first resource
 int ret = REQ_PROCEED;
 if(op->dav->propfind_do(propfind, op->response, NULL, resource, s)) {
 ret = REQ_ABORTED;
 typedef struct PathSearchElm {
 char   *href;
 char   *path;
 size_t hreflen;
 size_t pathlen;
+struct PathSearchElm *next;
 } PathSearchElm;
 /*
 * concats base + / + elm
 * if baseinit is true, only elm is copied
 WebdavOperation *op,
 VFSContext *vfs,
 const char *href,
 const char *path)
 {
-WebdavPropfindRequest *request = op->requests->data;
+WebdavPropfindRequest *request = op->requests->propfind;
 return webdav_op_iterate_children(
 vfs, request->depth, href, path, propfind_child_cb, op);
 }
 int webdav_op_propfiond_close_resource(
 WebdavResource *resource)
 {
 // start with second backend and request, because
 // the first one was already called by webdav_op_propfind_begin
 WebdavBackend *dav = op->dav->next;
-UcxList *request = op->requests->next;
+WebdavPropfindRequestList *request = op->requests->next;
 // call propfind_do of all remaining backends
 int ret = REQ_PROCEED;
 while(dav && request) {
 if(dav->propfind_do(
-request->data,
+request->propfind,
 op->response,
 op->parent,
 resource,
 op->stat))
 {
 /*
 * Executes propfind_finish for each Backend
 */
 int webdav_op_propfind_finish(WebdavOperation *op) {
 WebdavBackend *dav = op->dav;
-UcxList *requests = op->requests;
+WebdavPropfindRequestList *requests = op->requests;
 int ret = REQ_PROCEED;
 while(dav && requests) {
-if(dav->propfind_finish(requests->data)) {
+if(dav->propfind_finish(requests->propfind)) {
 ret = REQ_ABORTED;
 }
 dav = dav->next;
 requests = requests->next;
 WebdavOperation *op,
 const char *href,
 const char *path)
 {
 WebdavProppatchRequest *orig_request = op->proppatch;
-UcxAllocator *a = session_get_allocator(op->sn);
+CxAllocator *a = pool_allocator(op->sn->pool);
 // create WebdavResource object for the requested resource
 WebdavResource *resource = op->response->addresource(op->response, href);
 if(!resource) {
 return REQ_ABORTED;
 const char *href,
 const char *path,
 vfs_op_child_func func,
 void *userdata)
 {
-UcxAllocator *a = session_get_allocator(vfs->sn);
 pool_handle_t *pool = vfs->sn->pool;
 PathSearchElm *start_elm = pool_malloc(pool, sizeof(PathSearchElm));
 start_elm->href = pool_strdup(pool, href ? href : "");
 start_elm->path = pool_strdup(pool, path ? path : "");
 start_elm->hreflen = href ? strlen(href) : 0;
 start_elm->pathlen = path ? strlen(path) : 0;
+start_elm->next = NULL;
-UcxList *stack = ucx_list_prepend_a(a, NULL, start_elm);
-UcxList *stack_end = stack;
+PathSearchElm *stack = start_elm;
-if(!stack) {
+PathSearchElm *stack_end = start_elm;
-return 1;
-}
 // reusable buffer for full child path and href
 char *newpath = pool_malloc(pool, 256);
 size_t newpathlen = 256;
 char *newhref = pool_malloc(pool, 256);
 size_t newhreflen = 256;
 int err = 0;
 while(stack && !err) {
-PathSearchElm *cur_elm = stack->data;
+PathSearchElm *cur_elm = stack;
 // when newpath is initialized with the parent path
 // set path_buf_init to TRUE
 WSBool href_buf_init = FALSE;
 WSBool path_buf_init = FALSE;
 memcpy(pathcp, newpath, childpathlen + 1);
 pathcp[childpathlen] = '\0';
 PathSearchElm *new_elm = pool_malloc(pool,
 sizeof(PathSearchElm));
+if(!new_elm) {
+err = 1;
+break;
+}
 new_elm->href = hrefcp;
 new_elm->path = pathcp;
 new_elm->hreflen = childhreflen;
 new_elm->pathlen = childpathlen;
+new_elm->next = NULL;
 // add the new_elm to the stack
-// stack_end is always not NULL here, because we remove
+// stack_end is always not NULL here, because the loop is
+// running as long as we have a stack and we remove
 // the first stack element at the end of the loop
-UcxList *newlistelm = ucx_list_append_a(a, stack_end, new_elm);
+stack_end->next = new_elm;
-if(!newlistelm) {
+stack_end = new_elm;
-err = 1;
-break;
-}
-stack_end = newlistelm;
 }
 }
 vfs_closedir(dir);
+stack = stack->next;
 pool_free(pool, cur_elm->path);
 pool_free(pool, cur_elm->href);
 pool_free(pool, cur_elm);
-stack = ucx_list_remove_a(a, stack, stack);
 }
 // in case of an error, we have to free all remaining stack elements
-UCX_FOREACH(elm, stack) {
+for(PathSearchElm *elm=stack;elm;) {
-char *data = elm->data;
+PathSearchElm *next_elm = elm->next;
-if(data != path) {
+pool_free(pool, elm->path);
-pool_free(pool, data);
+pool_free(pool, elm->href);
-}
+pool_free(pool, elm);
+elm = next_elm;
 }
 return err;
 }

Mercurial > hg > webserver / file comparison

comparison: src/server/webdav/operation.c

src/server/webdav/operation.c