dav: comparison libidav/davqlexec.c

-:7072a2b4ae35
+:649eb328674a
 #include <string.h>
 #include <ucx/utils.h>
 #include "davqlexec.h"
 #include "utils.h"
+#include "methods.h"
-DavQLResult* dav_statement_exec(DavSession *sn, DavQLStatement *st, ...) {
+#include "session.h"
+DavResult* dav_statement_exec(DavSession *sn, DavQLStatement *st, ...) {
 va_list ap;
 va_start(ap, st);
-DavQLResult *result = dav_statement_execv(sn, st, ap);
+DavResult *result = dav_statement_execv(sn, st, ap);
 va_end(ap);
 return result;
 }
-DavQLResult* dav_statement_execv(DavSession *sn, DavQLStatement *st, va_list ap) {
+DavResult* dav_statement_execv(DavSession *sn, DavQLStatement *st, va_list ap) {
-DavQLResult *result = dav_session_malloc(sn, sizeof(DavQLResult));
+DavResult *result = dav_session_malloc(sn, sizeof(DavResult));
 result->result = NULL;
 result->status = 1;
 // make sure the statement was successfully parsed
 if(st->type == DAVQL_ERROR) {
 // get path string
 davqlerror_t error;
 sstr_t path = dav_format_string(sn->mp->allocator, st->path, ap, &error);
 if(st->type == DAVQL_SELECT) {
-dav_exec_get(sn, st, path.ptr, ap);
+*result = dav_exec_select(sn, st, path.ptr, ap);
 } else {
 // TODO
 }
 return result;
 *error = DAVQL_OK;
 return sstrdup_a(a, sstrn(buf->space, buf->size));
 }
-void dav_exec_get(DavSession *sn, DavQLStatement *st, char* path, va_list ap) {
+/*
-// execute a davql get statement
+* execute a davql select statement
+*/
+DavResult dav_exec_select(DavSession *sn, DavQLStatement *st, char* path, va_list ap) {
 UcxMempool *mp = ucx_mempool_new(128);
 // TODO: get property list
+UcxBuffer *rqbuf = create_allprop_propfind_request();
-UcxBuffer *bcode = dav_compile_expr(mp->allocator, st->where, ap);
+UcxBuffer *where = dav_compile_expr(sn->context, mp->allocator, st->where, ap);
-//print_bytecode(bcode);
+DavResource *selroot = dav_resource_new(sn, path);
-DavResource *res = dav_resource_new(sn, "/test.txt");
+DavResult result;
-dav_set_property_ns(res, "DAV:", "string", "value");
+result.result = selroot;
-dav_set_property_ns(res, "DAV:", "integer", "1337");
+result.status = 0;
-res->lastmodified = 100;
-DavQLStackObj result;
+UcxList *stack = NULL; // stack with DavResource* elements
-dav_exec_expr(bcode, res, &result);
+// initialize the stack with the requested resource
+DavQLRes *r = ucx_mempool_malloc(mp, sizeof(DavQLRes));
+r->resource = selroot;
+r->depth = 0;
+stack = ucx_list_prepend(stack, r);
+// reuseable response buffer
+UcxBuffer *rpbuf = ucx_buffer_new(NULL, 4096, UCX_BUFFER_AUTOEXTEND);
+// do a propfind request for each resource on the stack
+while(stack) {
+DavQLRes *sr = stack->data; // get first element from the stack
+stack = ucx_list_remove(stack, stack); // remove first element
+DavResource *root = sr->resource;
+util_set_url(sn, dav_resource_get_href(sr->resource));
+CURLcode ret = do_propfind_request(sn->handle, rqbuf, rpbuf);
+int http_status = 0;
+curl_easy_getinfo (sn->handle, CURLINFO_RESPONSE_CODE, &http_status);
+if(ret == CURLE_OK && http_status == 207) {
+// propfind request successful, now parse the response
+char *url = "http://url/";
+PropfindParser *parser = create_propfind_parser(rpbuf, url);
+ResponseTag response;
+int r;
+while((r = get_propfind_response(parser, &response)) != 0) {
+if(r == -1) {
+// error
+result.status = -1;
+// TODO: free resources
+break;
+}
+// the propfind multistatus response contains responses
+// for the requsted resource and all childs
+// determine if the response is a child or not
+if(hrefeq(sn, root->href, response.href)) {
+// response is the currently requested resource
+// and not a child
+// add properties
+add_properties(root, &response);
+if(root == selroot) {
+// The current root is the root of the select query.
+// In this case we have to check the where clause.
+// If root is not selroot, the where clause was
+// already checked for the resource before it was
+// added to the stack.
+DavQLStackObj where_result;
+if(!dav_exec_expr(where, root, &where_result)) {
+if(where_result.data.integer != 0) {
+continue;
+}
+} else {
+result.status = -1;
+}
+dav_resource_free_all(selroot);
+ucx_list_free(stack);
+break;
+}
+} else {
+DavResource *child = response2resource(
+sn,
+&response,
+root->path);
+// check where clause
+DavQLStackObj where_result;
+if(!dav_exec_expr(where, child, &where_result)) {
+if(where_result.data.integer != 0) {
+resource_add_child(root, child);
+if(child->iscollection &&
+(st->depth < 0 || st->depth > sr->depth+1))
+{
+DavQLRes *rs = ucx_mempool_malloc(
+mp,
+sizeof(DavQLRes));
+rs->resource = child;
+rs->depth = sr->depth + 1;
+stack = ucx_list_prepend(stack, rs);
+}
+} else {
+dav_resource_free(child);
+}
+}
+}
+}
+} else  {
+dav_session_set_error(sn, ret, http_status);
+result.status = -1;
+dav_resource_free_all(selroot);
+break;
+}
+// reset response buffer
+ucx_buffer_seek(rpbuf, SEEK_SET, 0);
+}
+ucx_mempool_destroy(mp);
+result.result = selroot;
+return result;
 }
 static int count_func_args(DavQLExpression *expr) {
 int count = 0;
 DavQLExpression *arg = expr->right;
 }
 }
 return count;
 }
-static int identifier2propname(UcxAllocator *a, sstr_t id, DavPropName *propname) {
+static int add_cmd(DavContext *ctx, UcxAllocator *a, UcxBuffer *bcode, DavQLExpression *expr, va_list ap) {
-ssize_t count;
-sstr_t *s = sstrsplit_a(a, id, S(":"), &count);
-if(count == 2) {
-sstr_t ns = s[0];
-sstr_t name = s[1];
-propname->ns = ns.ptr;
-propname->name = name.ptr;
-return 0;
-} else {
-return 1;
-}
-}
-static int add_cmd(UcxAllocator *a, UcxBuffer *bcode, DavQLExpression *expr, va_list ap) {
 if(!expr) {
 return 0;
 }
 int numcmd = 1;
 case DAVQL_IDENTIFIER: {
 sstr_t propertyname = sstrchr(src, ':');
 cmd.type = DAVQL_CMD_RES_IDENTIFIER;
 if(propertyname.length > 0) {
 cmd.type = DAVQL_CMD_PROP_IDENTIFIER;
-if(identifier2propname(a, src, &cmd.data.property)) {
+char *ns;
+char *name;
+dav_get_property_namespace(
+ctx,
+sstrdup_a(a, src).ptr,
+&ns,
+&name);
+if(ns && name) {
+cmd.data.property.ns = ns;
+cmd.data.property.name = name;
+} else {
 // error
 return -1;
 }
 } else if(!sstrcmp(src, S("name"))) {
 cmd.data.resprop = DAVQL_RES_NAME;
 }
 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
 break;
 }
 case DAVQL_UNARY: {
-numcmd += add_cmd(a, bcode, expr->left, ap);
+numcmd += add_cmd(ctx, a, bcode, expr->left, ap);
 switch(expr->op) {
 case DAVQL_ADD: {
-cmd.type = DAVQL_CMD_OP_UNARY_ADD;
+// noop
+numcmd = 0;
 break;
 }
 case DAVQL_SUB: {
 cmd.type = DAVQL_CMD_OP_UNARY_SUB;
+ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
 break;
 }
 case DAVQL_NEG: {
 cmd.type = DAVQL_CMD_OP_UNARY_NEG;
-break;
+ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
-}
+break;
 }
-ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
+}
 break;
 }
 case DAVQL_BINARY: {
-numcmd += add_cmd(a, bcode, expr->left, ap);
+numcmd += add_cmd(ctx, a, bcode, expr->left, ap);
-numcmd += add_cmd(a, bcode, expr->right, ap);
+numcmd += add_cmd(ctx, a, bcode, expr->right, ap);
 switch(expr->op) {
 case DAVQL_ADD: {
 cmd.type = DAVQL_CMD_OP_BINARY_ADD;
 break;
 }
 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
 break;
 }
 case DAVQL_LOGICAL: {
 if(expr->left && expr->right && expr->op != DAVQL_LOR) {
-numcmd += add_cmd(a, bcode, expr->left, ap);
+numcmd += add_cmd(ctx, a, bcode, expr->left, ap);
-numcmd += add_cmd(a, bcode, expr->right, ap);
+numcmd += add_cmd(ctx, a, bcode, expr->right, ap);
 }
 switch(expr->op) {
 case DAVQL_NOT: {
-numcmd += add_cmd(a, bcode, expr->left, ap);
+numcmd += add_cmd(ctx, a, bcode, expr->left, ap);
 cmd.type = DAVQL_CMD_OP_LOGICAL_NOT;
 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
 break;
 }
 case DAVQL_LAND: {
 cmd.type = DAVQL_CMD_OP_LOGICAL_AND;
 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
 break;
 }
 case DAVQL_LOR: {
-int nleft = add_cmd(a, bcode, expr->left, ap);
+int nleft = add_cmd(ctx, a, bcode, expr->left, ap);
 cmd.type = DAVQL_CMD_OP_LOGICAL_OR_L;
 DavQLCmd *or_l = (DavQLCmd*)(bcode->space + bcode->pos);
 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
-int nright = add_cmd(a, bcode, expr->right, ap);
+int nright = add_cmd(ctx, a, bcode, expr->right, ap);
 or_l->data.integer = nright + 1;
 cmd.type = DAVQL_CMD_OP_LOGICAL_OR;
 cmd.data.integer = 0;
 ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode);
 break;
 }
 case DAVQL_FUNCCALL: {
 switch(expr->op) {
 case DAVQL_CALL: {
-int nright = add_cmd(a, bcode, expr->right, ap);
+int nright = add_cmd(ctx, a, bcode, expr->right, ap);
 // TODO: count args
 DavQLExpression *funcid = expr->left;
 if(!funcid && funcid->type != DAVQL_IDENTIFIER) {
 // fail
 return -1;
 numcmd += nright;
 break;
 }
 case DAVQL_ARGLIST: {
 numcmd = 0;
-numcmd += add_cmd(a, bcode, expr->left, ap);
+numcmd += add_cmd(ctx, a, bcode, expr->left, ap);
-numcmd += add_cmd(a, bcode, expr->right, ap);
+numcmd += add_cmd(ctx, a, bcode, expr->right, ap);
 break;
 }
 }
 break;
 }
 }
 return numcmd;
 }
-UcxBuffer* dav_compile_expr(UcxAllocator *a, DavQLExpression *lexpr, va_list ap) {
+UcxBuffer* dav_compile_expr(DavContext *ctx, UcxAllocator *a, DavQLExpression *lexpr, va_list ap) {
 UcxBuffer *bcode = ucx_buffer_new(NULL, 512, UCX_BUFFER_AUTOEXTEND);
 if(!bcode) {
 return NULL;
 }
-if(add_cmd(a, bcode, lexpr, ap) <= 0) {
+if(add_cmd(ctx, a, bcode, lexpr, ap) <= 0) {
 ucx_buffer_free(bcode);
 return NULL;
 }
 return bcode;
 break;
 }
 }
 }
-for(int i=0;i<stpos;i++) {
+int ret = 0;
-DavQLStackObj obj = stack[i];
+if(stpos == 1) {
-if(obj.type == 0) {
+*result = stack[0];
-printf("stack: int=%lld\n", obj.data.integer);
+} else {
-} else {
+ret = -1;
-printf("stack: string=\"%.*s\"\n", obj.length, obj.data.string);
+}
-}
+free(stack);
-}
-return 0;
+return ret;
 }
 void print_bytecode(UcxBuffer *bcode) {
 bcode->pos = 0;

Mercurial > hg > dav / file comparison

comparison: libidav/davqlexec.c

libidav/davqlexec.c