dav/config.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 <sys/types.h>
#include <ucx/map.h>
#include <errno.h>
#include <libxml/tree.h>

#include "config.h"
#include <libidav/utils.h>

#define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b)
#define xstrEQ(a,b) !xmlStrcasecmp(BAD_CAST a, BAD_CAST b)

#ifdef _WIN32
#define ENV_HOME getenv("USERPROFILE")
#else
#define ENV_HOME getenv("HOME")
#endif /* _WIN32 */

static UcxMap *repos;
static UcxMap *keys;
static Proxy  *http_proxy;
static Proxy  *https_proxy;

int check_config_dir() {
    char *file = util_concat_path(ENV_HOME, ".dav");
    int ret = 0;
    if(util_mkdir(file, S_IRWXU)) {
        if(errno != EEXIST) {
            ret = 1;
        }
    }
    free(file);
    return ret;
}

static DavContext *context;

void create_default_config(char *file) {
    xmlDoc *doc = xmlNewDoc(BAD_CAST "1.0");
    xmlNode *root = xmlNewNode(NULL, BAD_CAST "configuration");
    xmlDocSetRootElement(doc, root);
    xmlSaveFormatFileEnc(file, doc, "UTF-8", 1);
    xmlFreeDoc(doc);
}

void load_config(DavContext *ctx) {
    context = ctx;
    // TODO: free the config somewhere
    repos = ucx_map_new(16);
    keys = ucx_map_new(16);
    http_proxy = calloc(1, sizeof(Proxy));
    https_proxy = calloc(1, sizeof(Proxy));
    if(check_config_dir()) {
        return;
    }
    
    char *file = util_concat_path(ENV_HOME, ".dav/config.xml");
    
    struct stat s;
    if(stat(file, &s)) {
        switch(errno) {
            case ENOENT: {
                create_default_config(file);
                break;
            }
            default: {
                perror("Cannot load config.xml");
            }
        }
        return;
    }
    
    xmlDoc *doc = xmlReadFile(file, NULL, 0);
    free(file);
    if(!doc) {
        fprintf(stderr, "Cannot load config.xml\n");
        return;
    }
    
    xmlNode *xml_root = xmlDocGetRootElement(doc);
    xmlNode *node = xml_root->children;
    while(node) {
        if(node->type == XML_ELEMENT_NODE) {
            if(xstreq(node->name, "repository")) {
                load_repository(node);
            } else if(xstreq(node->name, "key")) {
                load_key(node);
            } else if (xstreq(node->name, "http-proxy")) {
                load_proxy(node, HTTP_PROXY);
            } else if (xstreq(node->name, "https-proxy")) {
                load_proxy(node, HTTPS_PROXY);
            }
        }
        node = node->next;
    }
    
    xmlFreeDoc(doc);
}

void free_config() {
    UcxMapIterator i = ucx_map_iterator(repos);
    UcxKey k;
    Repository *repo;
    UCX_MAP_FOREACH(k, repo, i) {
        if(repo->default_key) {
            free(repo->default_key);
        }
        if(repo->name) {
            free(repo->name);
        }
        if(repo->password) {
            free(repo->password);
        }
        if(repo->url) {
            free(repo->url);
        }
        if(repo->user) {
            free(repo->user);
        }
        free(repo);
    }
    ucx_map_free(repos);
    
    ucx_map_free(keys);
}

Repository* repository_new() {
    Repository *repo = calloc(1, sizeof(Repository));
    repo->encrypt_name = false;
    repo->encrypt_content = false;
    repo->decrypt_name = false;
    repo->decrypt_content = true;
    repo->verification = true;
    repo->ssl_version = CURL_SSLVERSION_DEFAULT;
    repo->authmethods = CURLAUTH_BASIC;
    return repo;
}

void load_repository(xmlNode *reponode) {
    xmlNode *node = reponode->children;
    Repository *repo = repository_new();
    while(node) {
        if(node->type == XML_ELEMENT_NODE) {
            char *name = (char*)node->name;
            char *value = util_xml_get_text(node);
            if(value) {
                if(repo_add_config(repo, name, value)) {
                    fprintf(
                            stderr,
                            "Unkown repository config element: %s\n",
                            name);
                }
            }
        }
        node = node->next;
    }
    
    if(!repo->name) {
        fprintf(
                stderr,
                "Cannot load config.xml: missing name for repository.\n");
        fprintf(stderr, "Abort.\n");
        exit(-1);
    }
    if(!repo->url) {
        fprintf(
                stderr,
                "Cannot load config.xml: "
                "missing url for repository '%s'.\n", repo->name);
        fprintf(stderr, "Abort.\n");
        exit(-1);
    }
    
    ucx_map_cstr_put(repos, repo->name, repo);
}

int repo_add_config(Repository *repo, char *key, char *value) {  
    if(xstreq(key, "name")) {
        repo->name = strdup(value);
    } else if(xstreq(key, "url")) {
        repo->url = strdup(value);
    } else if(xstreq(key, "user")) {
        repo->user = strdup(value);
    } else if(xstreq(key, "password")) {
        repo->password = util_base64decode(value);
    } else if(xstreq(key, "default-key")) {
        repo->default_key = strdup(value);
    } else if(xstreq(key, "full-encryption")) {
        if(util_getboolean(value)) {
            repo->encrypt_name = true;
            repo->encrypt_content = true;
            repo->decrypt_name = true;
            repo->decrypt_content = true;
        }
    } else if(xstreq(key, "content-encryption")) {
        if(util_getboolean(value)) {
            repo->encrypt_content = true;
            repo->decrypt_content = true;
        } else {
            repo->encrypt_content = false;
        }
    } else if(xstreq(key, "decrypt-content")) {
        repo->decrypt_content = util_getboolean(value);
    } else if(xstreq(key, "decrypt-name")) {
        repo->decrypt_name = util_getboolean(value);
    } else if(xstreq(key, "cert")) {
        char *configdir = util_concat_path(ENV_HOME, ".dav");
        char *certfile = util_concat_path(configdir, value);
        repo->cert = certfile;
        free(configdir);
    } else if(xstreq(key, "verification")) {
        repo->verification = util_getboolean(value);
    } else if(xstreq(key, "ssl-version")) {
        if(xstrEQ(value, "TLSv1")) {
            repo->ssl_version = CURL_SSLVERSION_TLSv1;
        } else if(xstrEQ(value, "SSLv2")) {
            repo->ssl_version = CURL_SSLVERSION_SSLv2;
        } else if(xstrEQ(value, "SSLv3")) {
            repo->ssl_version = CURL_SSLVERSION_SSLv3;
        }
#if LIBCURL_VERSION_MAJOR >= 7
#if LIBCURL_VERSION_MINOR >= 34
        else if(xstrEQ(value, "TLSv1.0")) {
            repo->ssl_version = CURL_SSLVERSION_TLSv1_0;
        } else if(xstrEQ(value, "TLSv1.1")) {
            repo->ssl_version = CURL_SSLVERSION_TLSv1_1;
        } else if(xstrEQ(value, "TLSv1.2")) {
            repo->ssl_version = CURL_SSLVERSION_TLSv1_2;
        }
#endif
#endif
        else {
            fprintf(stderr, "Unknown ssl version: %s\n", value);
        }
    } else if(xstreq(key, "authmethods")) {
        repo->authmethods = CURLAUTH_NONE;
        const char *delims = " ,\r\n";
        char *meths = strdup(value);
        char *meth = strtok(meths, delims);
        while (meth) {
            if(xstrEQ(value, "basic")) {
                repo->authmethods |= CURLAUTH_BASIC;
            } else if(xstrEQ(value, "digest")) {
                repo->authmethods |= CURLAUTH_DIGEST;
            } else if(xstrEQ(value, "negotiate")) {
                repo->authmethods |= CURLAUTH_GSSNEGOTIATE;
            } else if(xstrEQ(value, "ntlm")) {
                repo->authmethods |= CURLAUTH_NTLM;
            } else if(xstrEQ(value, "any")) {
                repo->authmethods = CURLAUTH_ANY;
            } else if(xstrEQ(value, "none")) {
                /* skip */
            } else {
                fprintf(stderr, "Unknown authentication method: %s\n", value);
            }
            meth = strtok(NULL, delims);
        }
        free(meths);
    } else {
        return -1;
    }
    return 0;
}

void load_proxy(xmlNode *proxynode, int type) {
    Proxy *proxy;
    const char *stype;
    if (type == HTTPS_PROXY) {
        proxy = https_proxy;
        stype = "https";
    } else if (type == HTTP_PROXY) {
        proxy = http_proxy;
        stype = "http";
    }
    
    xmlNode *node = proxynode->children;
    while(node) {
        if(node->type == XML_ELEMENT_NODE) {
            char *value = util_xml_get_text(node);
            if(!value) {
                // next
            } else if(xstreq(node->name, "url")) {
                proxy->url = strdup(value);
            } else if(xstreq(node->name, "user")) {
                proxy->user = strdup(value);
            } else if(xstreq(node->name, "password")) {
                proxy->password = util_base64decode(value);
            } else if(xstreq(node->name, "no")) {
                proxy->no = strdup(value);
            }
        }
        node = node->next;
    }
    
    if(!proxy->url) {
        fprintf(stderr,
            "Cannot load config.xml: missing url for %s proxy.\n", stype);
        fprintf(stderr, "Abort.\n");
        exit(-1);
    }
}

void load_key(xmlNode *keynode) {
    xmlNode *node = keynode->children;
    Key *key = calloc(1, sizeof(Key));
    key->type = KEY_AES256;
    
    int error = 0;
    while(node) {
        if(node->type == XML_ELEMENT_NODE) {
            char *value = util_xml_get_text(node);
            if(!value) {
                // next
            } else if(xstreq(node->name, "name")) {
                key->name = strdup(value);
            } else if(xstreq(node->name, "file")) {
                // load key file
                sstr_t key_data = load_key_file(value);
                if(key_data.length > 0) {
                    key->data = key_data.ptr;
                    key->length = key_data.length;
                } else {
                    fprintf(stderr, "Error: Cannot key from file: %s\n", value);
                    error = 1;
                }
            } else if(xstreq(node->name, "type")) {
                if(!strcmp(value, "aes128")) {
                    key->type = KEY_AES128;
                } else if(!strcmp(value, "aes256")) {
                    key->type = KEY_AES256;
                } else if(!strcmp(value, "password")) {
                    key->type = KEY_PASSWORD;
                }
            }
                
        }
        node = node->next;
    }
    
    if(!error && key->name) {
        error = 0;
        if(key->type == KEY_AES128) {
            if(key->length < 16) {
                fprintf(
                        stderr,
                        "Error: Key %s is too small (%zu < 16)\n",
                        key->name,
                        key->length);
                error = 1;
            }
            key->length = 16;
        }
        if(key->type == KEY_AES256) {
            if(key->length < 32) {
                fprintf(
                        stderr,
                        "Error: Key %s is too small (%zu < 32)\n",
                        key->name,
                        key->length);
                error = 1;
            }
            key->length = 32;
        }
        if(key->type == KEY_PASSWORD) {
            key->length = 0;
            if(key->data) {
                // make sure the pw-key is not loaded from a file
                free(key->data);
                key->data = NULL;
            }
        }
        
        // add key to context
        if(!error) {
            ucx_map_cstr_put(keys, key->name, key);
            dav_context_add_key(context, key);
        }
    }
    
    // cleanup
    if(error) {
        if(key->data) {
            free(key->data);
        }
        free(key);
    }
}

sstr_t load_key_file(char *filename) {
    sstr_t k;
    k.ptr = NULL;
    k.length = 0;
    
    FILE *file = NULL;
    if(filename[0] == '/') {
        file = fopen(filename, "r");
    } else {
        char *path = util_concat_path(ENV_HOME, ".dav/");
        char *p2 = util_concat_path(path, filename);
        file = fopen(p2, "r");
        free(path);
        free(p2);
    }
    
    if(!file) {
        return k;
    }
    
    char *data = malloc(256);
    size_t r = fread(data, 1, 256, file);
    k.ptr = data;
    k.length = r;
    
    fclose(file);
    return k;
} 

Repository* get_repository(sstr_t name) {
    if(!name.ptr) {
        return NULL;
    }
    return ucx_map_sstr_get(repos, name);
}

int get_repository_flags(Repository *repo) {
    int flags = 0;
    if(repo->decrypt_content) {
        flags |= DAV_SESSION_DECRYPT_CONTENT;
    }
    if(repo->decrypt_name) {
        flags |= DAV_SESSION_DECRYPT_NAME;
    }
    if(repo->encrypt_content) {
        flags |= DAV_SESSION_ENCRYPT_CONTENT;
    }
    if(repo->encrypt_name) {
        flags |= DAV_SESSION_ENCRYPT_NAME;
    }
    return flags;
}


Key* get_key(char *name) {
    if(!name) {
        return NULL;
    }
    return ucx_map_cstr_get(keys, name);
}

Proxy* get_http_proxy() {
    return http_proxy;
}

Proxy* get_https_proxy() {
    return https_proxy;
}


int add_repository(Repository *repo) {
    char *file = util_concat_path(ENV_HOME, ".dav/config.xml");
    xmlDoc *doc = xmlReadFile(file, NULL, 0);
    if(!doc) {
        free(file);
        fprintf(stderr, "Cannot load config.xml\n");
        return 1;
    }
    
    xmlNode *root = xmlDocGetRootElement(doc);
    
    xmlNode *repoNode = xmlNewNode(NULL, BAD_CAST "repository");
    xmlNodeAddContent(repoNode, BAD_CAST "\n\t\t");
    xmlNewTextChild(repoNode, NULL, BAD_CAST "name", BAD_CAST repo->name);
    xmlNodeAddContent(repoNode, BAD_CAST "\n\t\t");
    xmlNewTextChild(repoNode, NULL, BAD_CAST "url", BAD_CAST repo->url);
    xmlNodeAddContent(repoNode, BAD_CAST "\n");
    if(repo->user) {
        xmlNodeAddContent(repoNode, BAD_CAST "\t\t");
        xmlNewChild(repoNode, NULL, BAD_CAST "user", BAD_CAST repo->user);
        xmlNodeAddContent(repoNode, BAD_CAST "\n");
        if(repo->password) {
            char *pwenc = util_base64encode(
                    repo->password,
                    strlen(repo->password));
            xmlNodeAddContent(repoNode, BAD_CAST "\t\t");
            xmlNewTextChild(repoNode, NULL, BAD_CAST "password", BAD_CAST pwenc);
            free(pwenc);
            xmlNodeAddContent(repoNode, BAD_CAST "\n");
        }
    }
    xmlNodeAddContent(repoNode, BAD_CAST "\t");
    
    xmlNodeAddContent(root, "\n\t");
    xmlAddChild(root, repoNode);
    xmlNodeAddContent(root, BAD_CAST "\n");
    
    int ret = 0;
    if(xmlSaveFormatFileEnc(file, doc, "UTF-8", 1) == -1) {
        ret = 1;
    }
    xmlFreeDoc(doc);
    free(file);
    
    return ret;
}

int list_repositories() {
    UcxMapIterator i = ucx_map_iterator(repos);
    Repository *repo;
    UCX_MAP_FOREACH(key, repo, i) {
        printf("%s\n", repo->name);
    }
    return 0;
}