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

-:2915b6c11aec
+:ff5826fc6a6c
 return op;
 }
 int webdav_op_propfind_begin(
 WebdavOperation *op,
-const char *path,
+const char *href,
 VFS_DIR parent,
 struct stat *s)
 {
 // create WebdavResource object for requested resource
-WebdavResource *resource = op->response->addresource(op->response, path);
+WebdavResource *resource = op->response->addresource(op->response, href);
 if(!resource) {
 return REQ_ABORTED;
 }
 // store data that we need when the resource will be closed
 }
 return ret;
 }
+typedef struct PathSearchElm {
+char   *href;
+char   *path;
+size_t hreflen;
+size_t pathlen;
+} PathSearchElm;
+/*
+* concats base + / + elm
+* if baseinit is true, only elm is copied
+*/
+static int path_buf_concat(
+pool_handle_t *pool,
+char **buf,
+size_t * restrict len,
+WSBool * restrict baseinit,
+const char *base,
+size_t baselen,
+const char *elm,
+size_t elmlen)
+{
+if(base[baselen-1] == '/') {
+baselen--;
+}
+size_t newlen = baselen + elmlen + 1;
+if(newlen > WEBDAV_PATH_MAX) {
+log_ereport(LOG_FAILURE, "webdav: maximal path length exceeded");
+return 1;
+}
+// check if new path + terminator fits in the buffer
+if(newlen + 1 > *len) {
+*len = newlen + 128;
+char *newbuf = pool_realloc(pool, *buf, newlen);
+if(newbuf) {
+log_ereport(LOG_FAILURE, "webdav: path memory allocation failed");
+return 1;
+}
+*baseinit = FALSE;
+*buf = newbuf;
+}
+// if baseinit is true, the parent is already in the buffer
+// and we don't need to memcpy it again
+if(!(*baseinit)) {
+memcpy(*buf, base, baselen);
+(*buf)[baselen] = '/';
+*baseinit = TRUE;
+}
+// copy child and terminate string
+memcpy((*buf) + baselen + 1, elm, elmlen);
+(*buf)[newlen] = '\0';
+return 0;
+}
 int webdav_op_propfind_children(
 WebdavOperation *op,
 VFSContext *vfs,
-char *path)
+const char *href,
+const char *path)
 {
 WebdavPropfindRequest *request = op->requests->data;
 UcxAllocator *a = session_get_allocator(request->sn);
 pool_handle_t *pool = request->sn->pool;
-UcxList *stack = ucx_list_prepend_a(a, NULL, path);
+PathSearchElm *start_elm = pool_malloc(pool, sizeof(PathSearchElm));
+start_elm->href = pool_strdup(pool, href);
+start_elm->path = pool_strdup(pool, path);
+start_elm->hreflen = strlen(href);
+start_elm->pathlen = strlen(path);
+UcxList *stack = ucx_list_prepend_a(a, NULL, start_elm);
 UcxList *stack_end = stack;
 if(!stack) {
 return 1;
 }
-// reusable buffer for full child path
+// reusable buffer for full child path and href
-char *newpath = NULL;
+char *newpath = pool_malloc(pool, 256);
-size_t newpathlen = 0;
+size_t newpathlen = 256;
+char *newhref = pool_malloc(pool, 256);
+size_t newhreflen = 256;
 int err = 0;
 while(stack && !err) {
-char *cur_path = stack->data;
+PathSearchElm *cur_elm = stack->data;
-size_t parent_len = strlen(cur_path);
-if(parent_len > WEBDAV_PATH_MAX) {
-log_ereport(LOG_FAILURE, "webdav: maximal path length exceeded");
-err = 1;
-break;
-}
-if(cur_path[parent_len-1] == '/') {
-parent_len--;
-}
-size_t max_child_len = WEBDAV_PATH_MAX - parent_len;
 // when newpath is initialized with the parent path
 // set path_buf_init to TRUE
+WSBool href_buf_init = FALSE;
 WSBool path_buf_init = FALSE;
-VFS_DIR dir = vfs_opendir(vfs, path);
+VFS_DIR dir = vfs_opendir(vfs, cur_elm->path);
 if(!dir) {
 log_ereport(
 LOG_FAILURE,
 "webdav: propfind: cannot open directory %d",
 vfs->vfs_errno);
 if(f.stat_errno != 0) {
 continue;
 }
 size_t child_len = strlen(f.name);
-if(child_len > max_child_len) {
-log_ereport(LOG_FAILURE, "webdav: maximal path length exceeded");
+// create new path and href for the child
+if(path_buf_concat(
+pool,
+&newhref,
+&newhreflen,
+&href_buf_init,
+cur_elm->href,
+cur_elm->hreflen,
+f.name,
+child_len))
+{
 err = 1;
 break;
 }
-size_t childpathlen = parent_len + child_len + 1; // +1 '/'
+if(path_buf_concat(
-if(childpathlen > newpathlen) {
+pool,
-// we're gonna need a bigger boa^H^H^Hbuffer
+&newpath,
-if(newpath) {
+&newpathlen,
-pool_free(pool, newpath);
+&path_buf_init,
-}
+cur_elm->path,
-newpath = pool_malloc(pool, childpathlen + 1);
+cur_elm->pathlen,
-if(!newpath) {
+f.name,
-err = 1;
+child_len))
-break;
+{
-}
+err = 1;
-newpathlen = childpathlen;
+break;
-path_buf_init = FALSE;
+}
-}
+size_t childhreflen = cur_elm->hreflen + 1 + child_len;
-// create full path string for this child
+size_t childpathlen = cur_elm->pathlen + 1 + child_len;
-if(!path_buf_init) {
-memcpy(newpath, cur_path, parent_len);
-newpath[parent_len] = '/';
-}
-memcpy(newpath+parent_len+1, f.name, child_len);
-newpath[childpathlen] = 0;
 // propfind for this child
 if(webdav_op_propfind_begin(op, newpath, dir, &f.stat)) {
 err = 1;
 break;
 }
 // depth of -1 means infinity
 if(request->depth == -1 && S_ISDIR(f.stat.st_mode)) {
+char *hrefcp = pool_malloc(pool, childhreflen + 1);
+memcpy(hrefcp, newhref, childhreflen + 1);
+hrefcp[childhreflen] = '\0';
 char *pathcp = pool_malloc(pool, childpathlen + 1);
 memcpy(pathcp, newpath, childpathlen + 1);
+pathcp[childpathlen] = '\0';
-// add the newpath copy to the stack
+PathSearchElm *new_elm = pool_malloc(pool,
+sizeof(PathSearchElm));
+new_elm->href = hrefcp;
+new_elm->path = pathcp;
+new_elm->hreflen = childhreflen;
+new_elm->pathlen = childpathlen;
+// add the new_elm to the stack
 // stack_end is always not NULL here, because we remove
 // the first stack element at the end of the loop
-UcxList *newlistelm = ucx_list_append_a(a, stack_end, pathcp);
+UcxList *newlistelm = ucx_list_append_a(a, stack_end, new_elm);
 if(!newlistelm) {
 err = 1;
 break;
 }
 stack_end = newlistelm;
 }
 }
 vfs_closedir(dir);
-if(cur_path != path) {
+pool_free(pool, cur_elm->path);
-pool_free(pool, cur_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) {

Mercurial > hg > webserver / file comparison

comparison: src/server/webdav/operation.c

src/server/webdav/operation.c