dav/utils.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2013 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 <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ucx/string.h>
#include <libxml/tree.h>
#include <curl/curl.h>

#include <openssl/sha.h>
#include <openssl/hmac.h>
#include <openssl/evp.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>

#include "utils.h"


time_t util_parse_creationdate(char *str) {
    // example: 2012-11-29T21:35:35Z
    if(!str) {
        return 0;
    }
    // TODO
    return 0;
}

time_t util_parse_lastmodified(char *str) {
    // example: Thu, 29 Nov 2012 21:35:35 GMT
    if(!str) {
        return 0;
    } else {
        return curl_getdate(str, NULL);
    }
}

int util_getboolean(char *v) {
    if(v[0] == 'T' || v[0] == 't') {
        return 1;
    }
    return 0;
}

char* util_url_path(char *url) { 
    char *path = NULL;
    size_t len = strlen(url);
    int slashcount = 0;
    int slmax;
    if(len > 7 && !strncasecmp(url, "http://", 7)) {
        slmax = 3;
    } else if(len > 8 && !strncasecmp(url, "https://", 8)) {
        slmax = 3;
    } else {
        slmax = 1;
    }
    char c;
    for(int i=0;i<len;i++) {
        c = url[i];
        if(c == '/') {
            slashcount++;
            if(slashcount == slmax) {
                path = url + i;
                break;
            }
        }
    } 
    return path;
}

char* util_resource_name(char *url) {
    int si = 0;
    int osi = 0;
    int i = 0;
    char c;
    while((c = url[i]) != 0) {
        if(c == '/') {
            osi = si;
            si = i;
        }
        i++;
    }
    
    char *name = url + si + 1;;
    if(name[0] == 0) {
        name = url + osi + 1;
        if(name[0] == 0) {
            return url;
        }
    }
    
    return name;
}

char* util_concat_path(char *url_base, char *p) {
    sstr_t base = sstr(url_base);
    sstr_t path;
    if(p) {
        path = sstr(p);
    } else {
        path = sstrn("", 0);
    }
    
    int add_separator = 0;
    if(base.ptr[base.length-1] == '/') {
        if(path.ptr[0] == '/') {
            base.length--;
        }
    } else {
        if(path.length == 0 || path.ptr[0] != '/') {
            add_separator = 1;
        }
    }
    
    sstr_t url;
    url.length = base.length + path.length + add_separator;
    url.ptr = malloc(url.length + 1);
    url.ptr[url.length] = '\0';
    
    if(add_separator) {
        url = sstrncat(url, 3, base, sstr("/"), path);
    } else {
        url = sstrncat(url, 2, base, path);
    }
    
    return url.ptr;
}

char* util_parent_path(char *path) {
    char *name = util_resource_name(path);
    size_t namelen = strlen(name);
    size_t pathlen = strlen(path);
    size_t parentlen = pathlen - namelen;
    char *parent = malloc(parentlen + 1);
    memcpy(parent, path, parentlen);
    parent[parentlen] = '\0';
    return parent;
}


char* util_xml_get_text(xmlNode *elm) {
    xmlNode *node = elm->children;
    while(node) {
        if(node->type == XML_TEXT_NODE) {
            return (char*)node->content;
        }
        node = node->next;
    }
    return NULL;
}


char* util_base64decode(char* in) {
    size_t len = strlen(in);
    char *out = calloc(1, len);
    
    BIO* b = BIO_new_mem_buf(in, len);
    BIO *d = BIO_new(BIO_f_base64());
    BIO_set_flags(d, BIO_FLAGS_BASE64_NO_NL);
    b = BIO_push(d, b);

    BIO_read(b, out, len);
    BIO_free_all(b);
    
    return out;
}