diff -r 21274e5950af -r a1f4cb076d2f src/server/plugins/postgresql/webdav.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/server/plugins/postgresql/webdav.c Sat Sep 24 16:26:10 2022 +0200 @@ -0,0 +1,1426 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2022 Olaf Wintermann. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "webdav.h" +#include "vfs.h" +#include "config.h" + +#include "../../util/util.h" +#include "../../util/pblock.h" + +#include "../../daemon/http.h" // etag + +#include +#include +#include + + +static WebdavBackend pg_webdav_backend = { + pg_dav_propfind_init, + pg_dav_propfind_do, + pg_dav_propfind_finish, + pg_dav_proppatch_do, + pg_dav_proppatch_finish, + NULL, // opt_mkcol + NULL, // opt_mkcol_finish + NULL, // opt_delete + NULL, // opt_delete_finish + 0, + NULL, + NULL +}; + + + +/* + * SQL query components + */ + +/* + * PROPFIND queries are build from components: + * + * cte cte_recursive or empty + * select + * ppath ppath column + * cols list of columns + * ext_cols* list of extension columns + * from from [table] / from cte + * prop_join join with property table, allprop or plist + * ext_join* extension table join + * where different where clauses for depth0 and depth1 + * order depth0 doesn't need order + */ + +static const char *sql_propfind_cte_recursive = "\ +with recursive resolvepath as (\n\ + select\n\ + '' as ppath,\n\ + *\n\ + from Resource\n\ + where resource_id = $1 \n\ + union\n\ + select\n\ + p.ppath || '/' || r.nodename,\n\ + r.*\n\ + from Resource r\n\ + inner join resolvepath p on r.parent_id = p.resource_id\n\ + )\n"; + +static const char *sql_propfind_select = "\ +select\n"; + +static const char *sql_propfind_ppath_depth0 = "\ +$2::text as ppath,\n"; + +static const char *sql_propfind_ppath_depth1 = "\ +case when r.resource_id = $1 then $2\n\ + else $2 || '/' || r.nodename\n\ +end as ppath,\n"; + +static const char *sql_propfind_ppath_depth_infinity = "\ +case when r.resource_id = $1 then $2\n\ + else $2 || r.ppath\n\ +end as ppath,\n"; + +static const char *sql_propfind_cols = "\ +r.resource_id,\n\ +r.parent_id,\n\ +r.nodename,\n\ +r.iscollection,\n\ +r.lastmodified,\n\ +r.creationdate,\n\ +r.contentlength,\n\ +r.etag,\n\ +p.prefix,\n\ +p.xmlns,\n\ +p.pname,\n\ +p.lang,\n\ +p.nsdeflist,\n\ +p.pvalue\n"; + +static const char *sql_propfind_from_table = "\ +from Resource r\n"; + +static const char *sql_propfind_from_cte = "\ +from resolvepath r\n"; + +static const char *sql_propfind_propjoin_allprop = "\ +left join Property p on r.resource_id = p.resource_id\n"; + +static const char *sql_propfind_propjoin_plist = "\ +left join (\n\ + select p.* from Property p\ + inner join (select unnest($3::text[]) as xmlns, unnest($4::text[]) as pname) n\n\ + on p.xmlns = n.xmlns and p.pname = n.pname\n\ +) p on r.resource_id = p.resource_id\n"; + +static const char *sql_propfind_where_depth0 = "\ +where r.resource_id = $1\n"; + +static const char *sql_propfind_where_depth1 = "\ +where r.resource_id = $1 or r.parent_id = $1\n"; + +static const char *sql_propfind_order_depth1 = "\ +order by case when r.resource_id = $1 then 0 else 1 end, nodename, resource_id"; + +static const char *sql_propfind_order_depth_infinity = "\ +order by replace(ppath, '/', chr(1)), resource_id"; + +/* + * SQL Queries + */ + + +// proppatch: set property +// params: $1: resource_id +// $2: xmlns prefix +// $3: xmlns href +// $4: property name +// $5: lang attribute value +// $6: namespace list string +// $7: property value +static const char *sql_proppatch_set = "\ +insert into Property(resource_id, prefix, xmlns, pname, lang, nsdeflist, pvalue)\n\ +values($1, $2, $3, $4, $5, $6, $7)\n\ +on conflict (resource_id, xmlns, pname) do\n\ +update set prefix=$2, lang=$5, nsdeflist=$6, pvalue=$7;"; + +// proppatch: remove property +// params: $1: resource_id +// $2: xmlns href +// $3: property name +static const char *sql_proppatch_remove = "\ +delete from Property where resource_id = $1 and xmlns = $2 and pname = $3"; + + +void* pg_webdav_init(ServerConfiguration *cfg, pool_handle_t *pool, WSConfigNode *config) { + return pg_init_repo(cfg, pool, config); +} + +WebdavBackend* pg_webdav_create(Session *sn, Request *rq, pblock *pb, void *initData) { + PgRepository *repo = initData; + + char *resource_pool; + if(repo) { + resource_pool = repo->resourcepool.ptr; + } else { + // resourcepool is required + resource_pool = pblock_findval("resourcepool", pb); + if(!resource_pool) { + log_ereport(LOG_MISCONFIG, "pg_webdav_create: missing resourcepool parameter"); + return NULL; + } + } + + // get the resource first (should only fail in case of misconfig) + ResourceData *resdata = resourcepool_lookup(sn, rq, resource_pool, 0); + if(!resdata) { + log_ereport(LOG_MISCONFIG, "postgresql webdav: resource pool %s not found", resource_pool); + return NULL; + } + + return pg_webdav_create_from_resdata(sn, rq, repo, resdata); +} + +WebdavBackend* pg_webdav_create_from_resdata(Session *sn, Request *rq, PgRepository *repo, ResourceData *resdata) { + WebdavBackend *webdav = pool_malloc(sn->pool, sizeof(WebdavBackend)); + if(!webdav) { + return NULL; + } + *webdav = pg_webdav_backend; + + PgWebdavBackend *instance = pool_malloc(sn->pool, sizeof(PgWebdavBackend)); + if(!instance) { + pool_free(sn->pool, webdav); + return NULL; + } + webdav->instance = instance; + + instance->pg_resource = resdata; + instance->connection = resdata->data; + + instance->repository = repo; + snprintf(instance->root_resource_id_str, 32, "%" PRId64, repo->root_resource_id); + + return webdav; +} + +WebdavBackend* pg_webdav_prop_create(Session *sn, Request *rq, pblock *pb) { + return NULL; +} + +/* + * adds str to the buffer + * some characters will be escaped: \,{} + */ +static void buf_addstr_escaped(UcxBuffer *buf, const char *str) { + size_t len = strlen(str); + for(size_t i=0;iproperty; + if(property && property->namespace && property->namespace->href && property->name) { + buf_addstr_escaped(xmlns, (const char*)property->namespace->href); + buf_addstr_escaped(pname, (const char*)property->name); + if(plist->next) { + ucx_buffer_putc(xmlns, ','); + ucx_buffer_putc(pname, ','); + } + } + plist = plist->next; + } + int r1 = ucx_buffer_write("}\0", 2, 1, xmlns) == 0; + int r2 = ucx_buffer_write("}\0", 2, 1, pname) == 0; + return r1+r2 != 0; +} + + +static int propfind_ext_cmp(const void *f1, const void *f2) { + const PgPropfindExtCol *e1 = f1; + const PgPropfindExtCol *e2 = f2; + + if(e1->ext->tableindex != e2->ext->tableindex) { + return e1->ext->tableindex < e2->ext->tableindex ? -1 : 1; + } + + return 0; +} + + +static int pg_create_propfind_query( + WebdavPropfindRequest *rq, + WSBool iscollection, + PgPropfindExtCol *ext, + size_t numext, + UcxBuffer *sql) +{ + PgWebdavBackend *pgdav = rq->dav->instance; + PgRepository *repo = pgdav->repository; + int depth = !iscollection ? 0 : rq->depth; + + /* + * PROPFIND queries are build from components: + * + * cte cte_recursive or empty + * select + * ppath ppath column + * cols list of columns + * ext_cols* list of extension columns + * from from [table] / from cte + * prop_join join with property table, allprop or plist + * ext_join* extension table join + * where different where clauses for depth0 and depth1 + * order depth0 doesn't need order + */ + + // CTE + if(depth == -1) { + ucx_buffer_puts(sql, sql_propfind_cte_recursive); + } + + // select + ucx_buffer_puts(sql, sql_propfind_select); + + // ppath + switch(depth) { + case 0: ucx_buffer_puts(sql, sql_propfind_ppath_depth0); break; + case 1: ucx_buffer_puts(sql, sql_propfind_ppath_depth1); break; + case -1: ucx_buffer_puts(sql, sql_propfind_ppath_depth_infinity); break; + } + + // cols + ucx_buffer_puts(sql, sql_propfind_cols); + + // ext_cols + if(ext) { + if(rq->allprop) { + for(int i=0;intables;i++) { + ucx_bprintf(sql, ",x%d.*\n", i); + } + } else { + for(int i=0;itableindex, e.ext->column); + } + } + } + + // from + ucx_buffer_puts(sql, depth == -1 ? sql_propfind_from_cte : sql_propfind_from_table); + + // prop join + ucx_buffer_puts(sql, rq->allprop ? sql_propfind_propjoin_allprop : sql_propfind_propjoin_plist); + + // ext_join + if(ext) { + if(rq->allprop) { + for(int i=0;intables;i++) { + ucx_bprintf(sql, "left join %s x%d on r.resource_id = x%d.resource_id\n", repo->tables[i].table, i, i); + } + } else { + int tab = -1; + for(int i=0;itableindex != tab) { + tab = e.ext->tableindex; + ucx_bprintf(sql, "left join %s x%d on r.resource_id = x%d.resource_id\n", repo->tables[tab].table, tab, tab); + } + } + } + + } + + // where + if(depth == 0) { + ucx_buffer_puts(sql, sql_propfind_where_depth0); + } else if(depth == 1) { + ucx_buffer_puts(sql, sql_propfind_where_depth1); + } + + // order + if(depth == 1) { + ucx_buffer_puts(sql, sql_propfind_order_depth1); + } else if(depth == -1) { + ucx_buffer_puts(sql, sql_propfind_order_depth_infinity); + } + + // end + ucx_buffer_puts(sql, ";\0"); + + return 0; +} + +int pg_dav_propfind_init( + WebdavPropfindRequest *rq, + const char *path, + const char *href, + WebdavPList **outplist) +{ + PgWebdavBackend *pgdav = rq->dav->instance; + + // first, check if the resource exists + // if it doesn't exist, we can return immediately + int64_t parent_id; + int64_t resource_id; + const char *resourcename; + WSBool iscollection; + int res_errno = 0; + int err = pg_resolve_path( + pgdav->connection, + path, + pgdav->root_resource_id_str, + &parent_id, + &resource_id, + NULL, // OID + &resourcename, + &iscollection, + NULL, // stat + NULL, // etag + &res_errno); + + if(err) { + if(res_errno == ENOENT) { + protocol_status(rq->sn, rq->rq, PROTOCOL_NOT_FOUND, NULL); + } + return 1; + } + + // store resource_id in rq->vars, maybe some other modules + // like to use it + char resource_id_str[32]; + snprintf(resource_id_str, 32, "%" PRId64, resource_id); + pblock_nvinsert("resource_id",resource_id_str, rq->rq->vars); + + // create a list of requsted extended properties + PgPropfindExtCol *ext; + size_t numext; + if(pgdav->repository->ntables == 0) { + // no property extensions configured + ext = NULL; + numext = 0; + } else { + numext = pgdav->repository->prop_ext->count; + ext = pool_calloc(rq->sn->pool, numext, sizeof(PgPropfindExtCol)); + + if(rq->allprop) { + // the map pgdav->repository->prop_ext contains all property extensions + // we can just convert the map to an array + UcxMapIterator i = ucx_map_iterator(pgdav->repository->prop_ext); + PgPropertyStoreExt *cfg_ext; + int j = 0; + UCX_MAP_FOREACH(key, cfg_ext, i) { + PgPropfindExtCol extcol; + extcol.ext = cfg_ext; + extcol.field_num = -1; // get the field_num after the PQexec + ext[j++] = extcol; + } + } else { + WebdavPListIterator i = webdav_plist_iterator(outplist); + WebdavPList *cur; + int j = 0; + while(webdav_plist_iterator_next(&i, &cur)) { + WSNamespace *ns = cur->property->namespace; + if(ns) { + UcxKey pkey = webdav_property_key((const char*)ns->href, cur->property->name); + PgPropertyStoreExt *cfg_ext = ucx_map_get(pgdav->repository->prop_ext, pkey); + free((void*)pkey.data); + if(cfg_ext) { + PgPropfindExtCol extcol; + extcol.ext = cfg_ext; + extcol.field_num = -1; // get the field_num after the PQexec + ext[j++] = extcol; + + webdav_plist_iterator_remove_current(&i); + } + } + } + numext = j; + } + + qsort(ext, numext, sizeof(PgPropfindExtCol), propfind_ext_cmp); + } + + // create sql query + const char *query = NULL; + UcxBuffer *sql = ucx_buffer_new(NULL, 2048, UCX_BUFFER_AUTOEXTEND); + if(pg_create_propfind_query(rq, iscollection, ext, numext, sql)) { + return 1; + } + query = sql->space; + + // get all resources and properties + size_t href_len = strlen(href); + char *href_param = pool_malloc(rq->sn->pool, href_len + 1); + memcpy(href_param, href, href_len); + if(href_param[href_len-1] == '/') { + href_len--; + } + href_param[href_len] = '\0'; + + // if allprop is false, create array pair for xmlns/property names + UcxBuffer *xmlns_buf = NULL; + UcxBuffer *pname_buf = NULL; + char *xmlns_param = NULL; + char *pname_param = NULL; + int nparam = 2; + if(!rq->allprop) { + size_t bufsize = rq->propcount < 200 ? 8 + rq->propcount * 32 : 4096; + xmlns_buf = ucx_buffer_new(NULL, bufsize, UCX_BUFFER_AUTOEXTEND); + if(!xmlns_buf) { + return 1; + } + pname_buf = ucx_buffer_new(NULL, bufsize, UCX_BUFFER_AUTOEXTEND); + if(!pname_buf) { + ucx_buffer_free(xmlns_buf); + return 1; + } + if(pg_create_property_param_arrays(*outplist, xmlns_buf, pname_buf)) { + ucx_buffer_free(xmlns_buf); + ucx_buffer_free(pname_buf); + return 1; + } + xmlns_param = xmlns_buf->space; + pname_param = pname_buf->space; + nparam = 4; + } + + const char* params[4] = { resource_id_str, href_param, xmlns_param, pname_param }; + PGresult *result = PQexecParams( + pgdav->connection, + query, + nparam, // number of parameters + NULL, + params, // parameter value + NULL, + NULL, + 0); // 0: result in text format + int nrows = PQntuples(result); + pool_free(rq->sn->pool, href_param); + if(xmlns_buf) { + ucx_buffer_free(xmlns_buf); + ucx_buffer_free(pname_buf); + } + if(nrows < 1) { + PQclear(result); + return 1; + } + + PgPropfind *pg = pool_malloc(rq->sn->pool, sizeof(PgPropfind)); + rq->userdata = pg; + + pg->path = path; + pg->resource_id = resource_id; + pg->vfsproperties = webdav_vfs_properties(outplist, TRUE, rq->allprop, 0); + pg->result = result; + pg->nrows = nrows; + + pg->ext = ext; + pg->numext = numext; + if(ext) { + // get field_nums for all property extensions + for(int i=0;ifield_num = PQfnumber(result, c->ext->column); + } + } + + return 0; +} + +int pg_dav_propfind_do( + WebdavPropfindRequest *rq, + WebdavResponse *response, + VFS_DIR parent, + WebdavResource *resource, + struct stat *s) +{ + PgPropfind *pg = rq->userdata; + pool_handle_t *pool = rq->sn->pool; + PGresult *result = pg->result; + WebdavVFSProperties vfsprops = pg->vfsproperties; + + WSBool vfsprops_set = 0; // are live properties added to the response? + WSBool extprops_set = 0; // are extended properties added to the response? + int64_t current_resource_id = pg->resource_id; + for(int r=0;rnrows;r++) { + // columns: + // 0: path + // 1: resource_id + // 2: parent_id + // 3: nodename + // 4: iscollection + // 5: lastmodified + // 6: creationdate + // 7: contentlength + // 8: etag + // 9: property prefix + // 10: property xmlns + // 11: property name + // 12: property lang + // 13: property nsdeflist + // 14: property value + + char *path = PQgetvalue(result, r, 0); + char *res_id = PQgetvalue(result, r, 1); + char *iscollection_str = PQgetvalue(result, r, 4); + WSBool iscollection = iscollection_str && iscollection_str[0] == 't'; + int64_t resource_id; + if(!util_strtoint(res_id, &resource_id)) { + log_ereport(LOG_FAILURE, "pg_dav_propfind_do: cannot convert resource_id '%s' to int", res_id); + return 1; + } + + if(resource_id != current_resource_id) { + // create a href string for the new resource + // if the resource is a collection, it should have a trailing '/' + size_t pathlen = strlen(path); + if(pathlen == 0) { + log_ereport(LOG_FAILURE, "pg_dav_propfind_do: query returned invalid path"); + return 1; + } + if(pathlen > PG_MAX_PATH_LEN) { + log_ereport(LOG_FAILURE, "pg_dav_propfind_do: path too long: resource_id: %s", res_id); + return 1; + } + char *newres_href = pool_malloc(pool, (pathlen*3)+2); + util_uri_escape(newres_href, path); + if(iscollection && path[pathlen-1] != '/') { + size_t newres_href_len = strlen(newres_href); + newres_href[newres_href_len] = '/'; + newres_href[newres_href_len+1] = '\0'; + } + + // new resource + resource = response->addresource(response, newres_href); + vfsprops_set = FALSE; + extprops_set = FALSE; + current_resource_id = resource_id; + } + + // standard webdav live properties + if(!vfsprops_set) { + if(vfsprops.getresourcetype) { + if(iscollection) { + resource->addproperty(resource, webdav_resourcetype_collection(), 200); + } else { + resource->addproperty(resource, webdav_resourcetype_empty(), 200); + } + } + + char *lastmodified = PQgetvalue(result, r, 5); + char *contentlength = PQgetvalue(result, r, 7); + time_t t = pg_convert_timestamp(lastmodified); + + if(vfsprops.getlastmodified) { + struct tm tm; + gmtime_r(&t, &tm); + + char buf[HTTP_DATE_LEN+1]; + strftime(buf, HTTP_DATE_LEN, HTTP_DATE_FMT, &tm); + webdav_resource_add_dav_stringproperty(resource, pool, "getlastmodified", buf, strlen(buf)); + } + if(vfsprops.creationdate) { + char *creationdate = PQgetvalue(result, r, 6); + webdav_resource_add_dav_stringproperty(resource, pool, "creationdate", creationdate, strlen(creationdate)); + } + if(vfsprops.getcontentlength && !iscollection) { + webdav_resource_add_dav_stringproperty(resource, pool, "getcontentlength", contentlength, strlen(contentlength)); + } + if(vfsprops.getetag) { + char *etag = PQgetvalue(result, r, 8); + if(!PQgetisnull(result, r, 8)) { + webdav_resource_add_dav_stringproperty(resource, pool, "getetag", etag, strlen(etag)); + } else { + int64_t ctlen; + if(util_strtoint(contentlength, &ctlen)) { + char etag[MAX_ETAG]; + http_format_etag(rq->sn, rq->rq, etag, MAX_ETAG, ctlen, t); + webdav_resource_add_dav_stringproperty(resource, pool, "getetag", etag, strlen(etag)); + } + } + } + + vfsprops_set = TRUE; + } + + if(!extprops_set) { + // extended properties + if(pg->ext) { + for(int extc=0;extcnumext;extc++) { + PgPropfindExtCol ext = pg->ext[extc]; + int fieldnum = ext.field_num; + + if(!PQgetisnull(result, r, fieldnum)) { + char *ext_value = PQgetvalue(result, r, fieldnum); + int ext_value_len = PQgetlength(result, r, fieldnum); + char ext_xmlns_prefix[32]; + snprintf(ext_xmlns_prefix, 32, "x%d", ext.ext->tableindex); + + WebdavProperty *property = pool_malloc(pool, sizeof(WebdavProperty)); + property->lang = NULL; + property->name = pool_strdup(pool, ext.ext->name); + + xmlNs *namespace = pool_malloc(pool, sizeof(xmlNs)); + memset(namespace, 0, sizeof(struct _xmlNs)); + namespace->href = (xmlChar*)pool_strdup(pool, ext.ext->ns); + namespace->prefix = (xmlChar*)pool_strdup(pool, ext_xmlns_prefix); + property->namespace = namespace; + + char *content = pool_malloc(pool, ext_value_len+1); + memcpy(content, ext_value, ext_value_len); + content[ext_value_len] = '\0'; + + WebdavNSList *nslist = pool_malloc(pool, sizeof(WebdavNSList)); + nslist->namespace = namespace; + nslist->prev = NULL; + nslist->next = NULL; + + property->vtype = WS_VALUE_XML_DATA; + property->value.data.data = content; + property->value.data.length = ext_value_len; + property->value.data.namespaces = nslist; + + resource->addproperty(resource, property, 200); + } + } + } + + extprops_set = TRUE; + } + + // dead properties + if(!PQgetisnull(result, r, 9)) { + char *prefix = PQgetvalue(result, r, 9); + char *xmlns = PQgetvalue(result, r, 10); + char *pname = PQgetvalue(result, r, 11); + char *lang = PQgetvalue(result, r, 12); + char *nsdef = PQgetvalue(result, r, 13); + char *pvalue = PQgetvalue(result, r, 14); + + int pvalue_len = PQgetlength(result, r, 14); + WSBool lang_isnull = PQgetisnull(result, r, 12); + WSBool nsdef_isnull = PQgetisnull(result, r, 13); + WSBool pvalue_isnull = PQgetisnull(result, r, 14); + + WebdavProperty *property = pool_malloc(pool, sizeof(WebdavProperty)); + property->lang = NULL; + property->name = pool_strdup(pool, pname); + + xmlNs *namespace = pool_malloc(pool, sizeof(xmlNs)); + memset(namespace, 0, sizeof(struct _xmlNs)); + namespace->href = (xmlChar*)pool_strdup(pool, xmlns); + namespace->prefix = (xmlChar*)pool_strdup(pool, prefix); + property->namespace = namespace; + + if(!lang_isnull) { + property->lang = pool_strdup(pool, lang); + } + + if(!pvalue_isnull) { + char *content = pool_malloc(pool, pvalue_len+1); + memcpy(content, pvalue, pvalue_len); + content[pvalue_len] = '\0'; + + if(nsdef_isnull) { + property->vtype = WS_VALUE_TEXT; + property->value.text.str = content; + property->value.text.length = pvalue_len; + } else { + WebdavNSList *nslist = wsxml_string2nslist(pool, nsdef); + property->vtype = WS_VALUE_XML_DATA; + property->value.data.data = content; + property->value.data.length = pvalue_len; + property->value.data.namespaces = nslist; + + } + } + + resource->addproperty(resource, property, 200); + } + } + + return 0; +} + +int pg_dav_propfind_finish(WebdavPropfindRequest *rq) { + PgPropfind *pg = rq->userdata; + pool_handle_t *pool = rq->sn->pool; + PGresult *result = pg->result; + + PQclear(result); + + return 0; +} + +enum PgDavProp { + PG_DAV_PROPPATCH_NOT_ALLOWED = 0, + PG_DAV_CREATIONDATE, + PG_DAV_DISPLAYNAME, + PG_DAV_DEADPROP +}; +/* + * checks if the property can be manipulated + */ +static enum PgDavProp proppatch_check_dav_prop(const char *name) { + if(!strcmp(name, "getlastmodified")) { + return PG_DAV_PROPPATCH_NOT_ALLOWED; + } else if(!strcmp(name, "getcontentlength")) { + return PG_DAV_PROPPATCH_NOT_ALLOWED; + } else if(!strcmp(name, "resourcetype")) { + return PG_DAV_PROPPATCH_NOT_ALLOWED; + } else if(!strcmp(name, "getetag")) { + return PG_DAV_PROPPATCH_NOT_ALLOWED; + } else if(!strcmp(name, "creationdate")) { + return PG_DAV_CREATIONDATE; + } else if(!strcmp(name, "displayname")) { + return PG_DAV_DISPLAYNAME; + } + return PG_DAV_DEADPROP; +} + +typedef struct { + WebdavProperty *creationdate; + WebdavProperty *displayname; + int error; +} PgProppatchOpResult; + +typedef int(*pg_proppatch_func)(PgWebdavBackend*, WebdavProppatchRequest*, WebdavResource*, WebdavProperty*, void*); + +/* + * This function iterates the property list 'plist', + * analyses if any DAV: property is in the list + * and calls opfunc for the each property + * + * If the property list contains the properties creationdate or displayname, + * the pointers to these properties will be stored in the result structure + */ +static PgProppatchOpResult pg_proppatch_op( + PgWebdavBackend *pgdav, + WebdavProppatchRequest *request, + WebdavResource *response, + WebdavPList **plist, + enum PgDavProp forbidden_extra, + pg_proppatch_func opfunc, + void *op_userdata) +{ + PgProppatchOpResult result; + result.creationdate = NULL; + result.displayname = NULL; + result.error = 0; + + WebdavPListIterator i = webdav_plist_iterator(plist); + WebdavPList *cur; + while(webdav_plist_iterator_next(&i, &cur)) { + WebdavProperty *property = cur->property; + WSNamespace *ns = property->namespace; + if(!ns) { + continue; // maybe we should abort + } + + // check if the property is a DAV: property that requires special + // handling + // get* properties can't be manipulated + // some properties can't be removed + if(!strcmp((const char*)ns->href, "DAV:")) { + const char *name = property->name; + enum PgDavProp davprop = proppatch_check_dav_prop(name); + if(davprop != PG_DAV_DEADPROP) { + if(davprop == PG_DAV_PROPPATCH_NOT_ALLOWED || davprop == forbidden_extra) { + response->addproperty(response, property, 409); + } else if(davprop == PG_DAV_CREATIONDATE) { + result.creationdate = property; + } else if(davprop == PG_DAV_DISPLAYNAME) { + result.displayname = property; + } + webdav_plist_iterator_remove_current(&i); + continue; + } + } + + // call op func (set, remove specific code) + if(opfunc(pgdav, request, response, property, op_userdata)) { + result.error = 1; + break; + } + + webdav_plist_iterator_remove_current(&i); + } + + return result; +} + +#define PG_PROPPATCH_EXT_SET 0 +#define PG_PROPPATCH_EXT_REMOVE 1 + +static int pg_proppatch_add_ext_prop( + pool_handle_t *pool, + PgWebdavBackend *pgdav, + PgProppatch *proppatch, + WebdavProperty *property, + int proppatch_op) +{ + UcxKey pkey = webdav_property_key((const char*)property->namespace->href, property->name); + PgPropertyStoreExt *ext = ucx_map_get(pgdav->repository->prop_ext, pkey); + free((void*)pkey.data); + if(ext) { + PgProppatchExtProp *ext_prop = pool_malloc(pool, sizeof(PgProppatchExtProp)); + if(!ext_prop) { + return 1; + } + ext_prop->column = ext; + ext_prop->property = property; + + UcxAllocator a = util_pool_allocator(pool); + proppatch->ext[ext->tableindex].isused = TRUE; + + UcxList **list = proppatch_op == PG_PROPPATCH_EXT_REMOVE + ? &proppatch->ext[ext->tableindex].remove + : &proppatch->ext[ext->tableindex].set; + *list = ucx_list_append_a(&a, *list, ext_prop); + + proppatch->extensions_used = TRUE; + } + + return 0; +} + +static int pg_dav_set_property( + PgWebdavBackend *pgdav, + WebdavProppatchRequest *request, + WebdavResource *response, + WebdavProperty *property, + void *userdata) +{ + pool_handle_t *pool = request->sn->pool; + PgProppatch *proppatch = request->userdata; + WSNamespace *ns = property->namespace; + + // check if the property belongs to an extension + if(proppatch->ext && ns) { + return pg_proppatch_add_ext_prop(pool, pgdav, proppatch, property, PG_PROPPATCH_EXT_SET); + } + + char *resource_id_str = userdata; + int ret = 0; + + // convert the property value to WSXmlData + // property->vtype == WS_VALUE_XML_NODE should always be true + WSXmlData *property_value = property->vtype == WS_VALUE_XML_NODE ? wsxml_node2data(pool, property->value.node) : NULL; + char *value_str = NULL; + char *nsdef_str = NULL; + if(property_value) { + value_str = property_value->data; + if(property_value->namespaces) { + nsdef_str = wsxml_nslist2string(pool, property_value->namespaces); + if(!nsdef_str) { + return 1; // OOM + } + } + } + + // exec sql + const char* params[7] = { resource_id_str, (const char*)ns->prefix, (const char*)ns->href, property->name, NULL, nsdef_str, value_str}; + PGresult *result = PQexecParams( + pgdav->connection, + sql_proppatch_set, + 7, // number of parameters + NULL, + params, // parameter value + NULL, + NULL, + 0); // 0: result in text format + + if(PQresultStatus(result) != PGRES_COMMAND_OK) { + response->addproperty(response, property, 500); + //printf(PQerrorMessage(pgdav->connection)); + //fflush(stdout); + ret = 1; + } else { + response->addproperty(response, property, 200); + } + PQclear(result); + if(value_str) pool_free(pool, value_str); + + return ret; +} + + +static int pg_dav_remove_property( + PgWebdavBackend *pgdav, + WebdavProppatchRequest *request, + WebdavResource *response, + WebdavProperty *property, + void *userdata) +{ + pool_handle_t *pool = request->sn->pool; + PgProppatch *proppatch = request->userdata; + WSNamespace *ns = property->namespace; + + // check if the property belongs to an extension + if(proppatch->ext && ns) { + return pg_proppatch_add_ext_prop(pool, pgdav, proppatch, property, PG_PROPPATCH_EXT_REMOVE); + } + + char *resource_id_str = userdata; + int ret = 0; + + // exec sql + const char* params[3] = { resource_id_str, (const char*)ns->href, property->name }; + PGresult *result = PQexecParams( + pgdav->connection, + sql_proppatch_remove, + 3, // number of parameters + NULL, + params, // parameter value + NULL, + NULL, + 0); // 0: result in text format + + if(PQresultStatus(result) != PGRES_COMMAND_OK) { + response->addproperty(response, property, 500); + //printf(PQerrorMessage(pgdav->connection)); + //fflush(stdout); + ret = 1; + } + PQclear(result); + + return ret; +} + + +/* + * Creates an SQL query for inserting a new row to an extension table + * A parameter list for PQexecParams will also be generated, however + * params[0] will be empty (resource_id str) + * + * Query: insert into (resource_id, col1, ...) values ($1, $2 ...); + */ +static UcxBuffer* ext_row_create_insert_query(WebdavProppatchRequest *request, PgProppatchExt *ext, PgExtTable *table, char *** params, size_t *nparams) { + pool_handle_t *pool = request->sn->pool; + + UcxBuffer *sql = ucx_buffer_new(NULL, 1024, UCX_BUFFER_AUTOEXTEND); + if(!sql) { + return NULL; + } + + size_t pg_nparams = ucx_list_size(ext->set) + 1; + char** pg_params = pool_calloc(pool, pg_nparams, sizeof(char*)); + if(!pg_params) { + ucx_buffer_free(sql); + return NULL; + } + + ucx_buffer_puts(sql, "insert into "); + ucx_buffer_puts(sql, table->table); + ucx_buffer_puts(sql, "(resource_id"); + UCX_FOREACH(elm, ext->set) { + PgProppatchExtProp *prop = elm->data; + ucx_bprintf(sql, ",%s", prop->column->name); + } + + ucx_buffer_puts(sql, ") values ($1\n"); + int i = 1; + UCX_FOREACH(elm, ext->set) { + PgProppatchExtProp *prop = elm->data; + WebdavProperty *property = prop->property; + // convert the property value to WSXmlData + // property->vtype == WS_VALUE_XML_NODE should always be true + WSXmlData *property_value = property->vtype == WS_VALUE_XML_NODE ? wsxml_node2data(pool, property->value.node) : NULL; + char *value_str = NULL; + //char *nsdef_str = NULL; + if(property_value) { + value_str = property_value->data; + if(property_value->namespaces) { + // currently only text data is supported + pool_free(pool, params); + ucx_buffer_free(sql); + return NULL; + } + } + + pg_params[i] = value_str; + ucx_bprintf(sql, ",$%d", ++i); + } + ucx_buffer_puts(sql, ");"); + + + //printf("\n\n%.*s\n\n", (int)sql->size, sql->space); + //fflush(stdout); + + *params = pg_params; + *nparams = pg_nparams; + + return sql; +} + +/* + * Creates an SQL query for updating an extension table row + * A parameter list for PQexecParams will also be generated, however + * params[0] will be empty (resource_id str) + * + * Query: update
set + * col1 = $2, + * col2 = $3, + * ... + * where resource_id = $1 ; + */ +static UcxBuffer* ext_row_create_update_query(WebdavProppatchRequest *request, PgProppatchExt *ext, PgExtTable *table, char *** params, size_t *nparams) { + pool_handle_t *pool = request->sn->pool; + + UcxBuffer *sql = ucx_buffer_new(NULL, 1024, UCX_BUFFER_AUTOEXTEND); + if(!sql) { + return NULL; + } + + ucx_buffer_puts(sql, "update "); + ucx_buffer_puts(sql, table->table); + ucx_buffer_puts(sql, " set\n"); + + size_t pg_nparams = ucx_list_size(ext->set) + 1; + char** pg_params = pool_calloc(pool, pg_nparams, sizeof(char*)); + if(!pg_params) { + ucx_buffer_free(sql); + return NULL; + } + + int i = 1; + UCX_FOREACH(elm, ext->set) { + PgProppatchExtProp *prop = elm->data; + WebdavProperty *property = prop->property; + // convert the property value to WSXmlData + // property->vtype == WS_VALUE_XML_NODE should always be true + WSXmlData *property_value = property->vtype == WS_VALUE_XML_NODE ? wsxml_node2data(pool, property->value.node) : NULL; + char *value_str = NULL; + //char *nsdef_str = NULL; + if(property_value) { + value_str = property_value->data; + if(property_value->namespaces) { + // currently only text data is supported + pool_free(pool, params); + ucx_buffer_free(sql); + return NULL; + } + } + + pg_params[i] = value_str; + ucx_bprintf(sql, " %s = $%d,\n", prop->column->name, ++i); + } + + UCX_FOREACH(elm, ext->remove) { + PgProppatchExtProp *prop = elm->data; + ucx_bprintf(sql, " %s = NULL,\n", prop->column->name); + } + + // check if any write worked + if(sql->pos == 0) { + ucx_buffer_free(sql); + pool_free(pool, pg_params); + return NULL; + } + + // last line should end with ',' '\n' + // replace ',' with space + if(sql->space[sql->pos-2] == ',') { + sql->space[sql->pos-2] = ' '; + } + + ucx_bprintf(sql, "where resource_id = $1 ;\0"); + + //printf("\n\n%.*s\n\n", (int)sql->size, sql->space); + //fflush(stdout); + + *params = pg_params; + *nparams = pg_nparams; + + return sql; +} + +/* + * Executes an SQL insert for the extension table + */ +int ext_row_insert(WebdavProppatchRequest *request, PgProppatchExt *ext, PgExtTable *table) { + PgWebdavBackend *pgdav = request->dav->instance; + PgProppatch *proppatch = request->userdata; + pool_handle_t *pool = request->sn->pool; + + char **params; + size_t nparam; + UcxBuffer *sql = ext_row_create_insert_query(request, ext, table, ¶ms, &nparam); + if(!sql) { + return 1; + } + + char resource_id_str[32]; + snprintf(resource_id_str, 32, "%" PRId64, proppatch->resource_id); + params[0] = resource_id_str; + + PGresult *result = PQexecParams( + pgdav->connection, + sql->space, + nparam, // number of parameters + NULL, + ( const char *const *)params, // parameter value + NULL, + NULL, + 0); // 0: result in text format + + ucx_buffer_free(sql); + + int ret = 1; + if(PQresultStatus(result) == PGRES_COMMAND_OK) { + // command ok, check if any row was updated + char *nrows_affected = PQcmdTuples(result); + if(nrows_affected[0] == '1') { + ret = 0; + } else { + log_ereport(LOG_FAILURE, "pg: extension row insert failed"); + } + } else { + log_ereport(LOG_FAILURE, "pg: extension row insert failed: %s", PQresultErrorMessage(result)); + } + + PQclear(result); + + return ret; +} + +/* + * Executes an SQL update for the extension table + */ +int ext_row_update(WebdavProppatchRequest *request, PgProppatchExt *ext, PgExtTable *table) { + PgWebdavBackend *pgdav = request->dav->instance; + PgProppatch *proppatch = request->userdata; + pool_handle_t *pool = request->sn->pool; + + char **params; + size_t nparam; + UcxBuffer *sql = ext_row_create_update_query(request, ext, table, ¶ms, &nparam); + if(!sql) { + return 1; + } + + char resource_id_str[32]; + snprintf(resource_id_str, 32, "%" PRId64, proppatch->resource_id); + params[0] = resource_id_str; + + PGresult *result = PQexecParams( + pgdav->connection, + sql->space, + nparam, // number of parameters + NULL, + ( const char *const *)params, // parameter value + NULL, + NULL, + 0); // 0: result in text format + + ucx_buffer_free(sql); + + int ret = 1; + if(PQresultStatus(result) == PGRES_COMMAND_OK) { + // command ok, check if any row was updated + char *nrows_affected = PQcmdTuples(result); + if(nrows_affected[0] == '1') { + ret = 0; + } else if(nrows_affected[0] == '0') { + // no rows affected, that means we have to insert a new row + // in the extension table for this resource + + // TODO: cleanup params + + ret = ext_row_insert(request, ext, table); + } + } else { + log_ereport(LOG_FAILURE, "pg: extension row update failed: %s", PQresultErrorMessage(result)); + } + + + PQclear(result); + + return ret; +} + +static int pg_dav_update_extension_tables(WebdavProppatchRequest *request) { + PgWebdavBackend *pgdav = request->dav->instance; + PgProppatch *proppatch = request->userdata; + + for(int i=0;inumext;i++) { + if(proppatch->ext[i].isused) { + if(ext_row_update(request, &proppatch->ext[i], &pgdav->repository->tables[i])) { + // extension proppatch failed + return 1; + } + } + } + + return 0; +} + +int pg_dav_proppatch_do( + WebdavProppatchRequest *request, + WebdavResource *response, + VFSFile *file, + WebdavPList **out_set, + WebdavPList **out_remove) +{ + PgWebdavBackend *pgdav = request->dav->instance; + pool_handle_t *pool = request->sn->pool; + char *path = pblock_findkeyval(pb_key_path, request->rq->vars); + + PgProppatch proppatch; + proppatch.extensions_used = FALSE; + if(pgdav->repository->ntables == 0) { + proppatch.ext = NULL; + proppatch.numext = 0; + } else { + // some properties are stored in additional tables + // for each table we create a PgProppatchExt record + // which stores data about, which tables are used + // and which properties (columns) should be updated + // + // proppatch.ext[i] should contain the data for repository->tables[i] + proppatch.numext = pgdav->repository->ntables; + proppatch.ext = pool_calloc(request->sn->pool, proppatch.numext, sizeof(PgProppatchExt)); + if(!proppatch.ext) { + return 1; // OOM + } + } + request->userdata = &proppatch; + + // check if the resource exists, we also need the resource_id + int64_t parent_id; + int64_t resource_id; + const char *resourcename; + WSBool iscollection; + int res_errno = 0; + int err = pg_resolve_path( + pgdav->connection, + path, + pgdav->root_resource_id_str, + &parent_id, + &resource_id, + NULL, // OID + &resourcename, + &iscollection, + NULL, // stat + NULL, // etag + &res_errno); + + if(err) { + return 1; + } + + proppatch.resource_id = resource_id; + + // because proppatch must be atomic and we have multiple sql + // queries and other backends that do stuff that could fail + // we need the possibility to reverse all changes + // we use a transaction savepoint for this + PGresult *result = PQexec(pgdav->connection, "savepoint proppatch;"); + ExecStatusType execStatus = PQresultStatus(result); + PQclear(result); + if(execStatus != PGRES_COMMAND_OK) { + return 1; + } + + char resource_id_str[32]; + snprintf(resource_id_str, 32, "%" PRId64, resource_id); + // store the resource_id in rq->vars, because it could be useful later + pblock_nvinsert("resource_id", resource_id_str, request->rq->vars); + + int ret = 0; + PgProppatchOpResult set_res = pg_proppatch_op( + pgdav, + request, + response, + out_set, + PG_DAV_PROPPATCH_NOT_ALLOWED, + pg_dav_set_property, + resource_id_str); + if(set_res.error) { + return 1; + } + PgProppatchOpResult rm_res = pg_proppatch_op( + pgdav, + request, + response, + out_remove, + PG_DAV_CREATIONDATE, // creationdate can't be removed + pg_dav_remove_property, + resource_id_str); + if(rm_res.error) { + return 1; + } + + // if extensions are in use and pg_proppatch_op found any + // properties, that should be stored in extension tables + // we do the update/insert now + if(proppatch.extensions_used) { + ret = pg_dav_update_extension_tables(request); + } + + + return ret; +} + +int pg_dav_proppatch_finish( + WebdavProppatchRequest *request, + WebdavResource *response, + VFSFile *file, + WSBool commit) +{ + PgWebdavBackend *pgdav = request->dav->instance; + int ret = 0; + if(!commit) { + log_ereport(LOG_VERBOSE, "proppatch: rollback"); + PGresult *result = PQexec(pgdav->connection, "rollback to savepoint proppatch;"); + if(PQresultStatus(result) != PGRES_COMMAND_OK) { + log_ereport(LOG_FAILURE, "pg_dav_proppatch_finish: rollback failed: %s", PQerrorMessage(pgdav->connection)); + ret = 1; + } + PQclear(result); + } + return ret; +}