Wed, 27 Nov 2024 14:06:56 +0100
add transfer speed indicator
/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright 2023 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 "config.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <cx/hash_map.h> #include <errno.h> #include <libxml/tree.h> #include "utils.h" #define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b) #define xstrEQ(a,b) !xmlStrcasecmp(BAD_CAST a, BAD_CAST b) #define print_error(lineno, ...) \ do {\ fprintf(stderr, "Error (config.xml line %u): ", lineno); \ fprintf(stderr, __VA_ARGS__); \ fprintf(stderr, "Abort.\n"); \ } while(0); #define print_warning(lineno, ...) \ do {\ fprintf(stderr, "Warning (config.xml line %u): ", lineno); \ fprintf(stderr, __VA_ARGS__); \ } while(0); #ifdef _WIN32 #define ENV_HOME getenv("USERPROFILE") #else #define ENV_HOME getenv("HOME") #endif /* _WIN32 */ static int load_repository( DavConfig *config, DavCfgRepository **list_begin, DavCfgRepository **list_end, xmlNode *reponode); static int load_key( DavConfig *config, DavCfgKey **list_begin, DavCfgKey **list_end, xmlNode *keynode); static int load_proxy( DavConfig *config, DavCfgProxy *proxy, xmlNode *proxynode, int type); static int load_namespace( DavConfig *config, DavCfgNamespace **list_begin, DavCfgNamespace **list_end, xmlNode *node); static int load_secretstore(DavConfig *config, xmlNode *node); int dav_cfg_string_set_node_value(DavConfig *config, CfgString *str, xmlNode *node) { str->node = node; char *value = util_xml_get_text(node); if(value) { str->value = cx_strdup_a(config->mp->allocator, cx_str(value)); return 0; } else { str->value = (cxmutstr){NULL, 0}; return 1; } } void dav_cfg_bool_set_node_value(DavConfig *config, CfgBool *cbool, xmlNode *node) { cbool->node = node; char *value = util_xml_get_text(node); cbool->value = util_getboolean(value); } static void set_xml_content(xmlNode *node, const char *content) { xmlNode *child = node->children; while(child) { xmlNode *next = child->next; xmlUnlinkNode(child); xmlFreeNode(child); child = next; } if(content) { xmlChar *encoded = xmlEncodeSpecialChars(node->doc, (const xmlChar*)content); if(encoded) { xmlNodeSetContent(node, encoded); xmlFree(encoded); } } } void dav_cfg_string_set_value(DavConfig *config, CfgString *str, xmlNode *parent, cxstring new_value, const char *nodename) { if(str->value.ptr) { cxFree(config->mp->allocator, str->value.ptr); } if(new_value.ptr) { str->value = cx_strdup_a(config->mp->allocator, new_value); } else { str->value = cx_mutstrn(NULL, 0); } if(!str->node) { str->node = xmlNewNode(NULL, (const xmlChar*) nodename); xmlAddChild(parent, str->node); } set_xml_content(str->node, new_value.ptr); } void dav_cfg_bool_set_value(DavConfig *config, CfgBool *cbool, xmlNode *parent, DavBool new_value, const char *nodename) { const char *content = new_value ? "true" : "false"; cbool->value = new_value; if(!cbool->node) { cbool->node = xmlNewNode(NULL, (const xmlChar*) nodename); xmlAddChild(parent, cbool->node); } set_xml_content(cbool->node, content); } void dav_cfg_int_set_value(DavConfig *config, CfgInt *cint, xmlNode *parent, int64_t new_value, const char *nodename) { char content[32]; snprintf(content, 32, "%" PRId64, new_value); cint->value = new_value; if(!cint->node) { cint->node = xmlNewNode(NULL, (const xmlChar*) nodename); xmlAddChild(parent, cint->node); } set_xml_content(cint->node, content); } void dav_cfg_uint_set_value(DavConfig *config, CfgUInt *cint, xmlNode *parent, uint64_t new_value, const char *nodename) { char content[32]; snprintf(content, 32, "%" PRIu64, new_value); cint->value = new_value; if(!cint->node) { cint->node = xmlNewNode(NULL, (const xmlChar*) nodename); xmlAddChild(parent, cint->node); } set_xml_content(cint->node, content); } void dav_cfg_string_remove(CfgString *str) { if(str->node) { xmlUnlinkNode(str->node); xmlFreeNode(str->node); str->node = NULL; } } void dav_cfg_bool_remove(CfgBool *cbool) { if(cbool->node) { xmlUnlinkNode(cbool->node); xmlFreeNode(cbool->node); cbool->node = NULL; } } void dav_cfg_int_remove(CfgInt *cint) { if(cint->node) { xmlUnlinkNode(cint->node); xmlFreeNode(cint->node); cint->node = NULL; } } void dav_cfg_uint_remove(CfgUInt *cint) { if(cint->node) { xmlUnlinkNode(cint->node); xmlFreeNode(cint->node); cint->node = NULL; } } DavConfig* dav_config_new(xmlDoc *doc) { CxMempool *cfg_mp = cxMempoolCreate(128, NULL); DavConfig *config = cxMalloc(cfg_mp->allocator, sizeof(DavConfig)); memset(config, 0, sizeof(DavConfig)); config->mp = cfg_mp; if(!doc) { doc = xmlNewDoc(BAD_CAST "1.0"); xmlNode *root = xmlNewNode(NULL, BAD_CAST "configuration"); xmlDocSetRootElement(doc, root); } config->doc = doc; return config; } DavConfig* dav_config_load(cxmutstr xmlfilecontent, int *error) { xmlDoc *doc = xmlReadMemory(xmlfilecontent.ptr, xmlfilecontent.length, NULL, NULL, 0); if(!doc) { if(error) { *error = DAV_CONFIG_ERROR_XML; } return NULL; } DavConfig *config = dav_config_new(doc); CxMempool *cfg_mp = config->mp; cxMempoolRegister(cfg_mp, doc, (cx_destructor_func)xmlFreeDoc); DavCfgRepository *repos_begin = NULL; DavCfgRepository *repos_end = NULL; DavCfgKey *keys_begin = NULL; DavCfgKey *keys_end = NULL; DavCfgNamespace *namespaces_begin = NULL; DavCfgNamespace *namespaces_end = NULL; xmlNode *xml_root = xmlDocGetRootElement(doc); xmlNode *node = xml_root->children; int ret = 0; while(node && !ret) { if(node->type == XML_ELEMENT_NODE) { if(xstreq(node->name, "repository")) { ret = load_repository(config, &repos_begin, &repos_end, node); } else if(xstreq(node->name, "key")) { ret = load_key(config, &keys_begin, &keys_end, node); } else if (xstreq(node->name, "http-proxy")) { config->http_proxy = cxCalloc(config->mp->allocator, 1, sizeof(DavCfgProxy)); ret = load_proxy(config, config->http_proxy, node, DAV_HTTP_PROXY); } else if (xstreq(node->name, "https-proxy")) { config->https_proxy = cxCalloc(config->mp->allocator, 1, sizeof(DavCfgProxy)); ret = load_proxy(config, config->https_proxy, node, DAV_HTTPS_PROXY); } else if (xstreq(node->name, "namespace")) { ret = load_namespace(config, &namespaces_begin, &namespaces_end, node); } else if (xstreq(node->name, "secretstore")) { ret = load_secretstore(config, node); } else { fprintf(stderr, "Unknown config element: %s\n", node->name); ret = 1; } } node = node->next; } config->repositories = repos_begin; config->keys = keys_begin; config->namespaces = namespaces_begin; if(ret != 0 && error) { *error = ret; cxMempoolDestroy(cfg_mp); } return config; } void dav_config_free(DavConfig *config) { cxMempoolDestroy(config->mp); } CxBuffer* dav_config2buf(DavConfig *config) { xmlChar* xmlText = NULL; int textLen = 0; xmlDocDumpFormatMemory(config->doc, &xmlText, &textLen, 1); if(!xmlText) { return NULL; } CxBuffer *buf = cxBufferCreate(NULL, textLen, cxDefaultAllocator, CX_BUFFER_AUTO_EXTEND|CX_BUFFER_FREE_CONTENTS); cxBufferWrite(xmlText, 1, textLen, buf); xmlFree(xmlText); return buf; } static int repo_add_config( DavConfig *config, DavCfgRepository *repo, xmlNode* node) { unsigned short lineno = node->line; char *key = (char*)node->name; char *value = util_xml_get_text(node); /* every key needs a value */ if(!value) { /* TODO: maybe this should only be reported, if the key is valid * But this makes the code very ugly. */ print_error(lineno, "missing value for config element: %s\n", key); return 1; } if(xstreq(key, "name")) { dav_cfg_string_set_node_value(config, &repo->name, node); } else if(xstreq(key, "url")) { dav_cfg_string_set_node_value(config, &repo->url, node); } else if(xstreq(key, "user")) { dav_cfg_string_set_node_value(config, &repo->user, node); } else if(xstreq(key, "password")) { dav_cfg_string_set_node_value(config, &repo->password, node); } else if(xstreq(key, "stored-user")) { dav_cfg_string_set_node_value(config, &repo->stored_user, node); } else if(xstreq(key, "default-key")) { dav_cfg_string_set_node_value(config, &repo->default_key, node); } else if(xstreq(key, "full-encryption")) { dav_cfg_bool_set_node_value(config, &repo->full_encryption, node); } else if(xstreq(key, "content-encryption")) { dav_cfg_bool_set_node_value(config, &repo->content_encryption, node); } else if(xstreq(key, "decrypt-content")) { dav_cfg_bool_set_node_value(config, &repo->decrypt_content, node); } else if(xstreq(key, "decrypt-name")) { dav_cfg_bool_set_node_value(config, &repo->decrypt_name, node); } else if(xstreq(key, "cert")) { dav_cfg_string_set_node_value(config, &repo->cert, node); } else if(xstreq(key, "verification")) { dav_cfg_bool_set_node_value(config, &repo->verification, node); } else if(xstreq(key, "ssl-version")) { repo->ssl_version.node = node; int ssl_version = dav_str2ssl_version((const char*)value); if(ssl_version == -1) { print_warning(lineno, "unknown ssl version: %s\n", value); repo->ssl_version.value = CURL_SSLVERSION_DEFAULT; } else { repo->ssl_version.value = ssl_version; } } else if(xstreq(key, "authmethods")) { repo->authmethods.node = node; repo->authmethods.value = CURLAUTH_NONE; const char *delims = " \t\r\n"; char *meths = strdup(value); char *meth = strtok(meths, delims); while (meth) { if(xstrEQ(meth, "basic")) { repo->authmethods.value |= CURLAUTH_BASIC; } else if(xstrEQ(meth, "digest")) { repo->authmethods.value |= CURLAUTH_DIGEST; } else if(xstrEQ(meth, "negotiate")) { repo->authmethods.value |= CURLAUTH_GSSNEGOTIATE; } else if(xstrEQ(meth, "ntlm")) { repo->authmethods.value |= CURLAUTH_NTLM; } else if(xstrEQ(meth, "any")) { repo->authmethods.value = CURLAUTH_ANY; } else if(xstrEQ(meth, "none")) { /* skip */ } else { print_warning(lineno, "unknown authentication method: %s\n", meth); } meth = strtok(NULL, delims); } free(meths); } else { print_error(lineno, "unkown repository config element: %s\n", key); return 1; } return 0; } int dav_str2ssl_version(const char *value) { if(xstrEQ(value, "TLSv1")) { return CURL_SSLVERSION_TLSv1; } else if(xstrEQ(value, "SSLv2")) { return CURL_SSLVERSION_SSLv2; } else if(xstrEQ(value, "SSLv3")) { return CURL_SSLVERSION_SSLv3; } #if LIBCURL_VERSION_MAJOR * 1000 + LIBCURL_VERSION_MINOR >= 7034 else if(xstrEQ(value, "TLSv1.0")) { return CURL_SSLVERSION_TLSv1_0; } else if(xstrEQ(value, "TLSv1.1")) { return CURL_SSLVERSION_TLSv1_1; } else if(xstrEQ(value, "TLSv1.2")) { return CURL_SSLVERSION_TLSv1_2; } #endif #if LIBCURL_VERSION_MAJOR * 1000 + LIBCURL_VERSION_MINOR >= 7052 else if(xstrEQ(value, "TLSv1.3")) { return CURL_SSLVERSION_TLSv1_3; } #endif return -1; } static int load_repository( DavConfig *config, DavCfgRepository **list_begin, DavCfgRepository **list_end, xmlNode *reponode) { DavCfgRepository *repo = dav_repository_new(config); repo->node = reponode; // add repo config from child nodes xmlNode *node = reponode->children; int ret = 0; while(node && !ret) { if(node->type == XML_ELEMENT_NODE) { ret = repo_add_config(config, repo, node); } node = node->next; } // success: add repo to the configuration, error: free repo if(ret) { return 1; } else { cx_linked_list_add( (void**)list_begin, (void**)list_end, offsetof(DavCfgRepository, prev), offsetof(DavCfgRepository, next), repo); } return 0; } static xmlNode* addXmlNode(xmlNode *node, const char *name, cxmutstr content) { xmlNode *text1 = xmlNewDocText(node->doc, BAD_CAST "\t\t"); xmlAddChild(node, text1); cxmutstr ctn = cx_strdup(cx_strcast(content)); xmlNode *newNode = xmlNewChild(node, NULL, BAD_CAST name, BAD_CAST ctn.ptr); free(ctn.ptr); xmlNode *text2 = xmlNewDocText(node->doc, BAD_CAST "\n"); xmlAddChild(node, text2); return newNode; } void dav_config_add_repository(DavConfig *config, DavCfgRepository *repo) { if(repo->node) { fprintf(stderr, "Error: dav_config_add_repository: node already exists\n"); return; } xmlNode *repoNode = xmlNewNode(NULL, BAD_CAST "repository"); xmlNode *rtext1 = xmlNewDocText(config->doc, BAD_CAST "\n"); xmlAddChild(repoNode, rtext1); repo->node = repoNode; if(repo->name.value.ptr) { repo->name.node = addXmlNode(repoNode, "name", repo->name.value); } if(repo->url.value.ptr) { repo->url.node = addXmlNode(repoNode, "url", repo->url.value); } if(repo->user.value.ptr) { repo->user.node = addXmlNode(repoNode, "user", repo->user.value); } if(repo->password.value.ptr) { repo->password.node = addXmlNode(repoNode, "password", repo->password.value); } if(repo->stored_user.value.ptr) { repo->stored_user.node = addXmlNode(repoNode, "stored-user", repo->stored_user.value); } if(repo->default_key.value.ptr) { repo->default_key.node = addXmlNode(repoNode, "default-key", repo->default_key.value); } if(repo->cert.value.ptr) { repo->cert.node = addXmlNode(repoNode, "cert", repo->cert.value); } // TODO: implement booleans // indent closing tag xmlNode *rtext2 = xmlNewDocText(config->doc, BAD_CAST "\t"); xmlAddChild(repoNode, rtext2); // add repository to internal list DavCfgRepository **list_begin = &config->repositories; cx_linked_list_add( (void**)list_begin, NULL, offsetof(DavCfgRepository, prev), offsetof(DavCfgRepository, next), repo); // add repository element to the xml document xmlNode *xml_root = xmlDocGetRootElement(config->doc); xmlNode *text1 = xmlNewDocText(config->doc, BAD_CAST "\n\t"); xmlAddChild(xml_root, text1); xmlAddChild(xml_root, repoNode); xmlNode *text2 = xmlNewDocText(config->doc, BAD_CAST "\n"); xmlAddChild(xml_root, text2); } DavCfgRepository* dav_repository_new(DavConfig *config) { DavCfgRepository *repo = cxMalloc(config->mp->allocator, sizeof(DavCfgRepository)); memset(repo, 0, sizeof(DavCfgRepository)); repo->decrypt_name.value = false; repo->decrypt_content.value = true; repo->decrypt_properties.value = false; repo->verification.value = true; repo->ssl_version.value = CURL_SSLVERSION_DEFAULT; repo->authmethods.value = CURLAUTH_BASIC; return repo; } void dav_repository_free(DavConfig *config, DavCfgRepository *repo) { // TODO } void dav_repository_remove_and_free(DavConfig *config, DavCfgRepository *repo) { if(repo->prev) { repo->prev->next = repo->next; } if(repo->next) { repo->next->prev = repo->prev; } if(repo->node) { // TODO: remove newline after repo node xmlUnlinkNode(repo->node); xmlFreeNode(repo->node); } } int dav_repository_get_flags(DavCfgRepository *repo) { int flags = 0; DavBool encrypt_content = FALSE; DavBool encrypt_name = FALSE; DavBool encrypt_properties = FALSE; DavBool decrypt_content = FALSE; DavBool decrypt_name = FALSE; DavBool decrypt_properties = FALSE; if(repo->full_encryption.value) { encrypt_content = TRUE; encrypt_name = TRUE; encrypt_properties = TRUE; decrypt_content = TRUE; decrypt_name = TRUE; decrypt_properties = TRUE; } else if(repo->content_encryption.value) { encrypt_content = TRUE; decrypt_content = TRUE; } if(decrypt_content) { flags |= DAV_SESSION_DECRYPT_CONTENT; } if(decrypt_name) { flags |= DAV_SESSION_DECRYPT_NAME; } if(decrypt_properties) { flags |= DAV_SESSION_DECRYPT_PROPERTIES; } if(encrypt_content) { flags |= DAV_SESSION_ENCRYPT_CONTENT; } if(encrypt_name) { flags |= DAV_SESSION_ENCRYPT_NAME; } if(encrypt_properties) { flags |= DAV_SESSION_ENCRYPT_PROPERTIES; } return flags; } void dav_repository_set_url(DavConfig *config, DavCfgRepository *repo, cxstring newurl) { if(repo->url.value.ptr) { cxFree(config->mp->allocator, repo->url.value.ptr); } repo->url.value = cx_strdup_a(config->mp->allocator, newurl); } void dav_repository_set_auth(DavConfig *config, DavCfgRepository *repo, cxstring user, cxstring password) { const CxAllocator *a = config->mp->allocator; if(user.length > 0) { repo->user.value = cx_strdup_a(a, user); } if(password.length > 0) { char *pwenc = util_base64encode(password.ptr, password.length); repo->password.value = cx_strdup_a(a, cx_str(pwenc)); free(pwenc); } } cxmutstr dav_repository_get_decodedpassword(DavCfgRepository *repo) { cxmutstr pw = { NULL, 0 }; if(repo->password.value.ptr) { pw = cx_mutstr(util_base64decode(repo->password.value.ptr)); } return pw; } void dav_config_add_key(DavConfig *config, DavCfgKey *key) { cx_linked_list_add( (void**)&config->keys, NULL, offsetof(DavCfgKey, prev), offsetof(DavCfgKey, next), key); if(key->node) { fprintf(stderr, "Error: dav_config_add_key: node already exists\n"); return; } xmlNode *keyNode = xmlNewNode(NULL, BAD_CAST "key"); xmlNode *rtext1 = xmlNewDocText(config->doc, BAD_CAST "\n"); xmlAddChild(keyNode, rtext1); key->node = keyNode; if(key->name.value.ptr) { key->name.node = addXmlNode(keyNode, "name", key->name.value); } const char *type = dav_config_keytype_str(key->type); if(type) { key->type_node = addXmlNode(keyNode, "type", cx_mutstr((char*)type)); } if(key->file.value.ptr) { key->file.node = addXmlNode(keyNode, "file", key->file.value); } // indent closing tag xmlNode *rtext2 = xmlNewDocText(config->doc, BAD_CAST "\t"); xmlAddChild(keyNode, rtext2); // add key element to the xml document xmlNode *xml_root = xmlDocGetRootElement(config->doc); xmlNode *text1 = xmlNewDocText(config->doc, BAD_CAST "\n\t"); xmlAddChild(xml_root, text1); xmlAddChild(xml_root, keyNode); xmlNode *text2 = xmlNewDocText(config->doc, BAD_CAST "\n"); xmlAddChild(xml_root, text2); } DavCfgKey* dav_key_new(DavConfig *config) { DavCfgKey *key = cxMalloc(config->mp->allocator, sizeof(DavCfgKey)); memset(key, 0, sizeof(DavCfgKey)); key->type = DAV_KEY_TYPE_AES256; return key; } void dav_key_remove_and_free(DavConfig *config, DavCfgKey *key) { cx_linked_list_remove( (void**)&config->keys, NULL, offsetof(DavCfgKey, prev), offsetof(DavCfgKey, next), key); if(key->node) { // TODO: remove newline after key node xmlUnlinkNode(key->node); xmlFreeNode(key->node); } } static int load_key( DavConfig *config, DavCfgKey **list_begin, DavCfgKey **list_end, xmlNode *keynode) { xmlNode *node = keynode->children; DavCfgKey *key = cxMalloc(config->mp->allocator, sizeof(DavCfgKey)); memset(key, 0, sizeof(DavCfgKey)); key->type = DAV_KEY_TYPE_AES256; key->node = keynode; int error = 0; while(node) { if(node->type == XML_ELEMENT_NODE) { if(xstreq(node->name, "name")) { dav_cfg_string_set_node_value(config, &key->name, node); } else if(xstreq(node->name, "file")) { dav_cfg_string_set_node_value(config, &key->file, node); } else if(xstreq(node->name, "type")) { const char *value = util_xml_get_text(node); key->type_node = node; if(!strcmp(value, "aes128")) { key->type = DAV_KEY_TYPE_AES128; } else if(!strcmp(value, "aes256")) { key->type = DAV_KEY_TYPE_AES256; } else { print_error(node->line, "unknown key type %s\n", value); error = 1; } } else { key->unknown_elements++; } } node = node->next; } if(!key->name.value.ptr) { error = 1; } if(!error) { error = 0; size_t expected_length = 0; if(key->type == DAV_KEY_TYPE_AES128) { expected_length = 16; } if(key->type == DAV_KEY_TYPE_AES256) { expected_length = 32; } /* if(key->length < expected_length) { print_error(keynode->line, "key %s is too small (%zu < %zu)\n", key->name, key->length, expected_length); error = 1; } // add key to context if(!error) { cxMapPut(keys, cx_hash_key_str(key->name), key); dav_context_add_key(context, key); } */ } // cleanup if(error) { return 1; } else { // add key to the configuration cx_linked_list_add( (void**)list_begin, (void**)list_end, offsetof(DavCfgKey, prev), offsetof(DavCfgKey, next), key); return 0; } } static int load_proxy( DavConfig *config, DavCfgProxy *proxy, xmlNode *proxynode, int type) { const char *stype; if(type == DAV_HTTPS_PROXY) { stype = "https"; } else if(type == DAV_HTTP_PROXY) { stype = "http"; } else { fprintf(stderr, "unknown proxy type\n"); return 1; } if(!proxy) { // no xml error - so report this directly via fprintf fprintf(stderr, "no memory reserved for %s proxy.\n", stype); return 1; } xmlNode *node = proxynode->children; int ret = 0; while(node && !ret) { if(node->type == XML_ELEMENT_NODE) { int reportmissingvalue = 0; if(xstreq(node->name, "url")) { reportmissingvalue = dav_cfg_string_set_node_value(config, &proxy->url, node); } else if(xstreq(node->name, "user")) { reportmissingvalue = dav_cfg_string_set_node_value(config, &proxy->user, node); } else if(xstreq(node->name, "password")) { reportmissingvalue = dav_cfg_string_set_node_value(config, &proxy->password, node); } else if(xstreq(node->name, "no")) { reportmissingvalue = dav_cfg_string_set_node_value(config, &proxy->noproxy, node); } else { proxy->unknown_elements++; } if (reportmissingvalue) { print_error(node->line, "missing value for proxy configuration element: %s\n", node->name); ret = 1; break; } } node = node->next; } if(!ret && !proxy->url.value.ptr) { print_error(proxynode->line, "missing url for %s proxy.\n", stype); return 1; } return ret; } static char* get_attr_content(xmlNode *node) { // TODO: remove code duplication (util_xml_get_text) while(node) { if(node->type == XML_TEXT_NODE) { return (char*)node->content; } node = node->next; } return NULL; } static int load_namespace( DavConfig *config, DavCfgNamespace **list_begin, DavCfgNamespace **list_end, xmlNode *node) { const char *prefix = NULL; const char *uri = NULL; xmlAttr *attr = node->properties; while(attr) { if(attr->type == XML_ATTRIBUTE_NODE) { char *value = get_attr_content(attr->children); if(!value) { print_error( node->line, "missing value for attribute %s\n", (char*)attr->name); return 1; } if(xstreq(attr->name, "prefix")) { prefix = value; } else if(xstreq(attr->name, "uri")) { uri = value; } else { print_error( node->line, "unexpected attribute %s\n", (char*)attr->name); return 1; } } attr = attr->next; } if(!prefix) { print_error(node->line, "missing prefix attribute\n"); return 1; } if(!uri) { print_error(node->line, "missing uri attribute\n"); return 1; } DavCfgNamespace *ns = cxMalloc(config->mp->allocator, sizeof(DavCfgNamespace)); memset(ns, 0, sizeof(DavCfgNamespace)); ns->node = node; ns->prefix = cx_strdup_a(config->mp->allocator, cx_str(prefix)); ns->uri = cx_strdup_a(config->mp->allocator, cx_str(uri)); cx_linked_list_add( (void**)list_begin, (void**)list_end, offsetof(DavCfgNamespace, prev), offsetof(DavCfgNamespace, next), ns); return 0; } static int load_secretstore(DavConfig *config, xmlNode *node) { // currently only one secretstore is supported if(config->secretstore) { return 1; } config->secretstore = cxCalloc(config->mp->allocator, 1, sizeof(DavCfgSecretStore)); node = node->children; int error = 0; while(node) { if(node->type == XML_ELEMENT_NODE) { if(xstreq(node->name, "unlock-command")) { dav_cfg_string_set_node_value(config, &config->secretstore->unlock_cmd, node); } else if(xstreq(node->name, "lock-command")) { dav_cfg_string_set_node_value(config, &config->secretstore->lock_cmd, node); } } node = node->next; } return error; } DavCfgRepository* dav_config_get_repository(DavConfig *config, cxstring name) { if(!config) { return NULL; } DavCfgRepository *repo = config->repositories; while(repo) { if(!cx_strcmp(cx_strcast(repo->name.value), name)) { return repo; } repo = repo->next; } return NULL; } DavCfgRepository* dav_config_url2repo(DavConfig *config, const char *url, char **path) { cxmutstr p; DavCfgRepository *repo = dav_config_url2repo_s(config, cx_str(url), &p); *path = p.ptr; return repo; } DavCfgRepository* dav_config_url2repo_s(DavConfig *config, cxstring url, cxmutstr *path) { path->ptr = NULL; path->length = 0; int s; if(cx_strprefix(url, CX_STR("http://"))) { s = 7; } else if(cx_strprefix(url, CX_STR("https://"))) { s = 8; } else { s = 1; } // split URL into repository and path cxstring r = cx_strsubs(url, s); cxstring p = cx_strchr(r, '/'); r = cx_strsubsl(url, 0, url.length-p.length); if(p.length == 0) { p = cx_strn("/", 1); } DavCfgRepository *repo = dav_config_get_repository(config, r); if(repo) { *path = cx_strdup(p); } else { // TODO: who is responsible for freeing this repository? // how can the callee know, if he has to call free()? repo = dav_repository_new(config); repo->name.value = cx_strdup_a(config->mp->allocator, CX_STR("")); if(url.ptr[url.length-1] == '/') { repo->url.value = cx_strdup_a(config->mp->allocator, url); *path = cx_strdup(CX_STR("/")); } else if (cx_strchr(url, '/').length > 0) { // TODO: fix the following workaround after // fixing the inconsistent behavior of util_url_*() cxstring repo_url = util_url_base_s(url); repo->url.value = cx_strdup_a(config->mp->allocator, repo_url); *path = cx_strdup(util_url_path_s(url)); } else { repo->url.value = cx_strdup(url); *path = cx_strdup(CX_STR("/")); } } return repo; } int dav_config_keytype(DavCfgKeyType type) { switch(type) { default: break; case DAV_KEY_TYPE_AES256: return DAV_KEY_AES256; case DAV_KEY_TYPE_AES128: return DAV_KEY_AES128; } return 0; } const char* dav_config_keytype_str(DavCfgKeyType type) { switch(type) { default: break; case DAV_KEY_TYPE_AES256: return "aes256"; case DAV_KEY_TYPE_AES128: return "aes128"; } return NULL; } int dav_config_register_keys(DavConfig *config, DavContext *ctx, dav_loadkeyfile_func loadkey) { for(DavCfgKey *key=config->keys;key;key=key->next) { char *file = cx_strdup_m(key->file.value).ptr; cxmutstr keycontent = loadkey(file); free(file); // TODO: check key length if(!keycontent.ptr) { return 1; } DavKey *davkey = calloc(1, sizeof(DavKey)); davkey->name = cx_strdup_m(key->name.value).ptr; davkey->type = dav_config_keytype(key->type); davkey->data = keycontent.ptr; davkey->length = keycontent.length; dav_context_add_key(ctx, davkey); } return 0; } int dav_config_register_namespaces(DavConfig *config, DavContext *ctx) { DavCfgNamespace *ns = config->namespaces; while(ns) { dav_add_namespace(ctx, ns->prefix.ptr, ns->uri.ptr); ns = ns->next; } return 0; }