/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 2018 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libxml/tree.h>
#include "utils.h"
#include "webdav.h"
#include "session.h"
#include "methods.h"
#include <cx/buffer.h>
#include <cx/utils.h>
#include <cx/linked_list.h>
#include <cx/hash_map.h>
#include <cx/compare.h>
#include "davqlparser.h"
#include "davqlexec.h"
DavContext* dav_context_new(void) {
// initialize
DavContext *context = calloc(1, sizeof(DavContext));
if(!context) {
return NULL;
}
context->sessions = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_ptr, CX_STORE_POINTERS);
cxDefineDestructor(context->sessions, dav_session_destructor);
context->http_proxy = calloc(1, sizeof(DavProxy));
if(!context->http_proxy) {
dav_context_destroy(context);
return NULL;
}
context->https_proxy = calloc(1, sizeof(DavProxy));
if(!context->https_proxy) {
dav_context_destroy(context);
return NULL;
}
context->namespaces = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 16);
if(!context->namespaces) {
dav_context_destroy(context);
return NULL;
}
context->namespaceinfo = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 16);
if(!context->namespaceinfo) {
dav_context_destroy(context);
}
context->keys = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 16);
if(!context->keys) {
dav_context_destroy(context);
return NULL;
}
// add DAV: namespace
if(dav_add_namespace(context, "D", "DAV:")) {
dav_context_destroy(context);
return NULL;
}
// add idav namespace
if(dav_add_namespace(context, "idav", DAV_NS)) {
dav_context_destroy(context);
return NULL;
}
// add idavprops namespace
if(dav_add_namespace(context, "idavprops", DAV_PROPS_NS)) {
dav_context_destroy(context);
return NULL;
}
return context;
}
void dav_context_destroy(DavContext *ctx) {
// destroy all sessions assoziated with this context
// ctx->sessions destructor must be dav_session_destructor
cxListDestroy(ctx->sessions);
if(ctx->http_proxy) {
free(ctx->http_proxy);
}
if(ctx->https_proxy) {
free(ctx->https_proxy);
}
if(ctx->namespaces) {
CxIterator i = cxMapIteratorValues(ctx->namespaces);
cx_foreach(DavNamespace*, ns, i) {
if(!ns) continue;
if(ns->prefix) {
free(ns->prefix);
}
if(ns->name) {
free(ns->name);
}
free(ns);
}
cxMapDestroy(ctx->namespaces);
}
if(ctx->namespaceinfo) {
// TODO: implement
}
if(ctx->keys) {
CxIterator i = cxMapIteratorValues(ctx->keys);
cx_foreach(DavKey*, key, i) {
if(!key) continue;
if(key->name) {
free(key->name);
}
if(key->data) {
free(key->data);
}
free(key);
}
cxMapDestroy(ctx->keys);
}
free(ctx);
}
#ifndef _WIN32
void dav_context_set_mtsafe(DavContext *ctx, DavBool enable) {
if (enable) {
pthread_mutex_init(&ctx->mutex, NULL);
} else {
pthread_mutex_destroy(&ctx->mutex);
}
ctx->mtsafe = enable;
}
void dav_context_lock(DavContext *ctx) {
if (ctx->mtsafe) {
pthread_mutex_lock(&ctx->mutex);
}
}
void dav_context_unlock(DavContext *ctx) {
if (ctx->mtsafe) {
pthread_mutex_unlock(&ctx->mutex);
}
}
#else
void dav_context_set_mtsafe(DavContext *ctx, DavBool enable) {
if (enable) {
ctx->mutex = CreateMutex(NULL, FALSE, NULL);
} else {
CloseHandle(ctx->mutex);
}
ctx->mtsafe = enable;
}
void dav_context_lock(DavContext *ctx) {
if (ctx->mtsafe) {
WaitForSingleObject(ctx->mutex, INFINITE);
}
}
void dav_context_unlock(DavContext *ctx) {
if (ctx->mtsafe) {
ReleaseMutex(ctx->mutex);
}
}
#endif
void dav_context_add_key(DavContext *context, DavKey *key) {
dav_context_lock(context);
cxMapPut(context->keys, cx_hash_key_str(key->name), key);
dav_context_unlock(context);
}
DavKey* dav_context_get_key(DavContext *context, const char *name) {
DavKey *key = NULL;
dav_context_lock(context);
if(name) {
key = cxMapGet(context->keys, cx_hash_key_str(name));
}
dav_context_unlock(context);
return key;
}
int dav_add_namespace(DavContext *context, const char *prefix, const char *name) {
DavNamespace *namespace = malloc(sizeof(DavNamespace));
if(!namespace) {
return 1;
}
char *p = strdup(prefix);
if (!p) {
free(namespace);
return 1;
}
char *n = strdup(name);
if (!n) {
free(namespace);
free(p);
return 1;
}
dav_context_lock(context);
int err = 0;
if(p && n) {
namespace->prefix = p;
namespace->name = n;
err = cxMapPut(context->namespaces, cx_hash_key_str(prefix), namespace);
}
if(err) {
free(namespace);
if(p) free(p);
if(n) free(n);
}
dav_context_unlock(context);
return err;
}
DavNamespace* dav_get_namespace(DavContext *context, const char *prefix) {
dav_context_lock(context);
DavNamespace *ns = cxMapGet(context->namespaces, cx_hash_key_str(prefix));
dav_context_unlock(context);
return ns;
}
DavNamespace* dav_get_namespace_s(DavContext *context, cxstring prefix) {
dav_context_lock(context);
DavNamespace *ns = cxMapGet(context->namespaces, cx_hash_key(prefix.ptr, prefix.length));
dav_context_unlock(context);
return ns;
}
int dav_enable_namespace_encryption(DavContext *context, const char *ns, DavBool encrypt) {
dav_context_lock(context);
CxHashKey hkey = cx_hash_key_str(ns);
DavNSInfo *info = cxMapGet(context->namespaceinfo, hkey);
if(!info) {
info = calloc(1, sizeof(DavNSInfo));
info->encrypt = encrypt;
cxMapPut(context->namespaceinfo, hkey, info);
} else {
info->encrypt = encrypt;
}
dav_context_unlock(context);
return 0;
}
int dav_namespace_is_encrypted(DavContext *context, const char *ns) {
int ret = 0;
dav_context_lock(context);
DavNSInfo *info = cxMapGet(context->namespaceinfo, cx_hash_key_str(ns));
if(info) {
ret = info->encrypt;
}
dav_context_unlock(context);
return ret;
}
void dav_get_property_namespace_str(
DavContext *ctx,
char *prefixed_name,
char **ns,
char **name)
{
// TODO: rewrite using dav_get_property_ns
char *pname = strchr(prefixed_name, ':');
char *pns = "DAV:";
if(pname) {
DavNamespace *davns = dav_get_namespace_s(
ctx,
cx_strn(prefixed_name, pname-prefixed_name));
if(davns) {
pns = davns->name;
pname++;
} else {
pns = NULL;
pname = NULL;
}
} else {
pname = prefixed_name;
}
*ns = pns;
*name = pname;
}
DavNamespace* dav_get_property_namespace(
DavContext *ctx,
char *prefixed_name,
char **name)
{
char *pname = strchr(prefixed_name, ':');
if(pname) {
DavNamespace *ns = dav_get_namespace_s(
ctx,
cx_strn(prefixed_name, pname-prefixed_name));
if(ns) {
*name = pname +1;
return ns;
} else {
*name = NULL;
return NULL;
}
} else {
*name = prefixed_name;
return dav_get_namespace_s(ctx, cx_str("D"));
}
}
int dav_context_add_session(DavContext *context, DavSession *sn) {
dav_context_lock(context);
int ret = cxListAdd(context->sessions, sn);
dav_context_unlock(context);
return ret;
}
int dav_context_remove_session(DavContext *context, DavSession *sn) {
int ret = 0;
dav_context_lock(context);
CxList *sessions = context->sessions;
ssize_t i = cxListFind(sessions, sn);
if(i >= 0) {
cxListRemove(sessions, i);
} else {
ret = 1;
}
dav_context_unlock(context);
return ret;
}
// TODO: add sstr_t version of dav_get_property_ns
void dav_set_effective_href(DavSession *sn, DavResource *resource) {
char *eff_url;
curl_easy_getinfo(sn->handle, CURLINFO_EFFECTIVE_URL, &eff_url);
if(eff_url) {
const char *href = util_url_path(eff_url);
if(strcmp(href, resource->href)) {
dav_session_free(sn, resource->href);
resource->href = dav_session_strdup(sn, href);
}
}
}
DavResource* dav_get(DavSession *sn, char *path, const char *properties) {
CURL *handle = sn->handle;
DavResource *resource = dav_resource_new(sn, path);
util_set_url(sn, dav_resource_get_href(resource));
CxList *proplist = NULL;
if(properties) {
proplist = parse_properties_string(sn->context, cx_str(properties));
}
CxBuffer *rqbuf = create_propfind_request(sn, proplist, "propfind", 0);
CxBuffer *rpbuf = cxBufferCreate(NULL, 4096, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
//fwrite(rqbuf->space, 1, rqbuf->size, stdout);
//printf("\n");
CURLcode ret = do_propfind_request(sn, rqbuf, rpbuf);
long status = 0;
curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
if(ret == CURLE_OK && status == 207) {
dav_set_effective_href(sn, resource);
//printf("response\n%s\n", rpbuf->space);
// TODO: use PropfindParser
resource = parse_propfind_response(sn, resource, rpbuf);
resource->exists = 1;
sn->error = DAV_OK;
} else {
dav_session_set_error(sn, ret, status);
dav_resource_free(resource);
resource = NULL;
}
cxBufferFree(rqbuf);
cxBufferFree(rpbuf);
if(proplist) {
CxIterator i = cxListIterator(proplist);
cx_foreach(DavProperty*, p, i) {
free(p->name);
}
cxListDestroy(proplist);
}
return resource;
}
int dav_propfind(DavSession *sn, DavResource *root, CxBuffer *rqbuf) {
// clean resource properties
DavResourceData *data = root->data;
cxMapClear(data->properties); // TODO: free existing content
CURL *handle = sn->handle;
util_set_url(sn, dav_resource_get_href(root));
CxBuffer *rpbuf = cxBufferCreate(NULL, 4096, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
DavResource *resource = root;
CURLcode ret = do_propfind_request(sn, rqbuf, rpbuf);
long status = 0;
long error = 0;
curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
if(ret == CURLE_OK && status == 207) {
//printf("response\n%s\n", rpbuf->space);
dav_set_effective_href(sn, resource);
// TODO: use PropfindParser
resource = parse_propfind_response(sn, resource, rpbuf);
sn->error = DAV_OK;
root->exists = 1;
} else {
dav_session_set_error(sn, ret, status);
error = 1;
}
cxBufferFree(rpbuf);
return error;
}
CxList* parse_properties_string(DavContext *context, cxstring str) {
CxList *proplist = cxLinkedListCreateSimple(sizeof(DavProperty));
CxStrtokCtx tok = cx_strtok(str, cx_str(","), INT_MAX);
cxstring s;
while(cx_strtok_next(&tok, &s)) {
cxstring nsname = cx_strchr(s, ':');
if(nsname.length > 0) {
cxstring nspre = cx_strsubsl(s, 0, nsname.ptr - s.ptr);
nsname.ptr++;
nsname.length--;
DavProperty dp;
cxstring pre = cx_strtrim(nspre);
dp.ns = dav_get_namespace_s(context, pre);
dp.name = cx_strdup(nsname).ptr;
dp.value = NULL;
if(dp.ns && dp.name) {
cxListAdd(proplist, &dp);
} else {
free(dp.name);
}
}
}
return proplist;
}
DavResource* dav_query(DavSession *sn, char *query, ...) {
DavQLStatement *stmt = dav_parse_statement(cx_str(query));
if(!stmt) {
sn->error = DAV_ERROR;
return NULL;
}
if(stmt->errorcode != 0) {
sn->error = DAV_QL_ERROR;
dav_free_statement(stmt);
return NULL;
}
va_list ap;
va_start(ap, query);
DavResult result = dav_statement_execv(sn, stmt, ap);
va_end(ap);
dav_free_statement(stmt);
if(result.status == -1) {
if(result.result) {
dav_resource_free(result.result);
result.result = NULL;
}
}
return result.result;
}
void dav_verbose_log(
DavSession *sn,
const char *method,
const char *url,
const char *request_body,
size_t request_bodylen,
int status,
const char *response_body,
size_t response_bodylen)
{
fprintf(stderr, "# method: %s url: %s status: %d\n", method, url, status);
fprintf(stderr, "# request len: %d\n%.*s\n", (int)request_bodylen, (int)request_bodylen, request_body);
fprintf(stderr, "# response len: %d\n%.*s\n", (int)response_bodylen, (int)response_bodylen, response_body);
}