/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 2019 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 <errno.h>
#include <ctype.h>
#include <cx/string.h>
#include <cx/buffer.h>
#include <cx/utils.h>
#include <cx/printf.h>
#include <libxml/tree.h>
#include <curl/curl.h>
#ifdef _WIN32
#include <conio.h>
#define getpasswordchar() getch()
#define IS_PATH_SEPARATOR(c) (c == '/' || c == '\\')
#define PATH_SEPARATOR '\\'
#else
#include <unistd.h>
#include <spawn.h>
#include <sys/wait.h>
#include <termios.h>
#define getpasswordchar() getchar()
#define IS_PATH_SEPARATOR(c) (c == '/')
#define PATH_SEPARATOR '/'
#endif
#include "webdav.h"
#include "utils.h"
#include "crypto.h"
#include "session.h"
/*
#include <openssl/hmac.h>
#include <openssl/evp.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>
#include <openssl/rand.h>
*/
static size_t extractval(cxstring str, char *result, char delim) {
size_t n = 0;
for(size_t i = 0; i < str.length ; i++) {
if(isdigit(str.ptr[i])) {
result[n++] = str.ptr[i];
} else if(str.ptr[i] != delim) {
return 0;
}
}
result[n] = '\0';
return n;
}
static time_t parse_iso8601(char *iso8601str) {
// safety
if(!iso8601str) {
return 0;
}
// local vars
struct tm tparts;
memset(&tparts, 0, sizeof(struct tm));
long val;
char conv[16];
// work on the trimmed string
cxstring date = cx_strtrim(cx_str(iso8601str));
cxstring time = cx_strchr(date, 'T');
if(time.length == 0) {
return 0;
}
date.length = time.ptr - date.ptr;
time.ptr++; time.length--;
cxstring tzinfo;
if((tzinfo = cx_strchr(time, 'Z')).length > 0 ||
(tzinfo = cx_strchr(time, '+')).length > 0 ||
(tzinfo = cx_strchr(time, '-')).length > 0) {
time.length = tzinfo.ptr - time.ptr;
}
// parse date
if((date.length != 8 && date.length != 10)
|| extractval(date, conv , '-') != 8) {
return 0;
}
val = atol(conv);
if(val < 19000000L) {
return 0;
}
tparts.tm_mday = val % 100;
tparts.tm_mon = (val % 10000) / 100 - 1;
tparts.tm_year = val / 10000 - 1900;
// parse time and skip possible fractional seconds
cxstring frac;
if((frac = cx_strchr(time, '.')).length > 0 ||
(frac = cx_strchr(time, ',')).length > 0) {
time.length = frac.ptr - time.ptr;
}
if((time.length != 6 && time.length != 8)
|| extractval(time, conv , ':') != 6) {
return 0;
}
val = atol(conv);
tparts.tm_sec = val % 100;
tparts.tm_min = (val % 10000) / 100;
tparts.tm_hour = val / 10000;
// parse time zone (if any)
if(tzinfo.length == 0) {
// local time
tparts.tm_isdst = -1;
return mktime(&tparts);
} else if(!cx_strcmp(tzinfo, cx_str("Z"))) {
#if defined(__FreeBSD__)
return timegm(&tparts);
#elif defined(_WIN32)
return _mkgmtime(&tparts);
#else
return mktime(&tparts) - timezone;
#endif
} else if(tzinfo.ptr[0] == '+' || tzinfo.ptr[0] == '-') {
int sign = (tzinfo.ptr[0] == '+') ? -1 : 1;
if(tzinfo.length > 6) {
return 0;
} else {
tzinfo.ptr++; tzinfo.length--;
extractval(tzinfo, conv, ':');
val = atol(conv);
val = 60 * (val / 100) + (val % 100);
#if defined(__FreeBSD__)
return timegm(&tparts) + (time_t) (60 * val * sign);
#elif defined(_WIN32)
return _mkgmtime(&tparts) + (time_t)(60 * val * sign);
#else
return mktime(&tparts) - timezone + (time_t) (60 * val * sign);
#endif
}
} else {
return 0;
}
}
time_t util_parse_creationdate(char *str) {
// parse a ISO-8601 date (rfc-3339)
// example: 2012-11-29T21:35:35Z
if(!str) {
return 0;
}
return parse_iso8601(str);
}
time_t util_parse_lastmodified(char *str) {
// parse a rfc-1123 date
// example: Thu, 29 Nov 2012 21:35:35 GMT
if(!str) {
return 0;
} else {
time_t result = curl_getdate(str, NULL);
if(result == -1) {
// fall back to the ISO-8601 format (e.g. Microsoft Sharepoint
// illegally uses this format for lastmodified, but also some
// users might want to give an ISO-8601 date)
return util_parse_creationdate(str);
} else {
return result;
}
}
}
int util_getboolean(const char *v) {
if(v[0] == 'T' || v[0] == 't') {
return 1;
}
return 0;
}
int util_strtouint(const char *str, uint64_t *value) {
if (str == NULL || *str == '\0') return 0;
char *end;
errno = 0;
uint64_t val = strtoull(str, &end, 0);
if(errno == 0 && *end == '\0') {
*value = val;
return 1;
} else {
return 0;
}
}
int util_strtoint(const char *str, int64_t *value) {
if (str == NULL || *str == '\0') return 0;
char *end;
errno = 0;
int64_t val = strtoll(str, &end, 0);
if(errno == 0 && *end == '\0') {
*value = val;
return 1;
} else {
return 0;
}
}
int util_szstrtouint(const char *str, uint64_t *value) {
if (str == NULL || *str == '\0') return 0;
char *end;
errno = 0;
size_t len = strlen(str);
uint64_t val = strtoull(str, &end, 0);
if(errno != 0) {
return 0;
} if(end == str+len) {
*value = val;
return 1;
} else if(end == str+len-1) {
uint64_t mul = 1;
switch(end[0]) {
case 'k':
case 'K': mul = 1024; break;
case 'm':
case 'M': mul = 1024*1024; break;
case 'g':
case 'G': mul = 1024*1024*1024; break;
default: return 0;
}
uint64_t result = 0;
if(util_uint_mul(val, mul, &result)) {
return 0;
}
*value = result;
return 1;
}
return 0;
}
int util_uint_mul(uint64_t a, uint64_t b, uint64_t *result) {
if(a == 0 || b == 0) {
*result = 0;
return 0;
}
uint64_t r = a * b;
if(r / b == a) {
*result = r;
return 0;
} else {
*result = 0;
return 1;
}
}
cxstring util_url_base_s(cxstring url) {
size_t i = 0;
if(url.length > 0) {
int slmax;
if(cx_strprefix(url, cx_str("http://"))) {
slmax = 3;
} else if(cx_strprefix(url, cx_str("https://"))) {
slmax = 3;
} else {
slmax = 1;
}
int slashcount = 0;
for(i=0;i<url.length;i++) {
if(url.ptr[i] == '/') {
slashcount++;
if(slashcount == slmax) {
i++;
break;
}
}
}
}
return cx_strsubsl(url, 0, i);
}
char* util_url_base(const char *url) {
return cx_strdup(util_url_base_s(cx_str(url))).ptr;
}
#ifdef _WIN32
#define strncasecmp _strnicmp
#endif
const char* util_url_path(const char *url) {
return util_url_path_s(cx_str(url)).ptr;
}
cxstring util_url_path_s(cxstring url) {
cxstring path = { "", 0 };
int slashcount = 0;
int slmax;
if(url.length > 7 && !strncasecmp(url.ptr, "http://", 7)) {
slmax = 3;
} else if(url.length > 8 && !strncasecmp(url.ptr, "https://", 8)) {
slmax = 3;
} else {
slmax = 1;
}
char c;
for(int i=0;i<url.length;i++) {
c = url.ptr[i];
if(c == '/') {
slashcount++;
if(slashcount == slmax) {
path = cx_strsubs(url, i);
break;
}
}
}
return path;
}
char* util_url_decode(DavSession *sn, const char *url) {
char *unesc = curl_easy_unescape(sn->handle, url, strlen(url), NULL);
char *ret = strdup(unesc);
curl_free(unesc);
return ret;
}
static size_t util_header_callback(char *buffer, size_t size,
size_t nitems, void *data) {
cxstring sbuffer = cx_strn(buffer, size*nitems);
CxMap *map = (CxMap*) data;
// if we get a status line, clear the map and exit
if(cx_strprefix(sbuffer, cx_str("HTTP/"))) {
// TODO: use new map destructor ucx_map_free_content(map, free);
cxMapClear(map);
return size*nitems;
}
// if we get the terminating CRLF, just exit
if(!cx_strcmp(sbuffer, cx_str("\r\n"))) {
return 2;
}
cxstring key = sbuffer;
cxstring value = cx_strchr(sbuffer, ':');
if(value.length == 0) {
return 0; // invalid header line
}
key.length = value.ptr - key.ptr;
value.ptr++; value.length--;
cxmutstr key_cp = cx_strdup(cx_strtrim(key));
cx_strlower(key_cp);
cxmutstr value_cp = cx_strdup(cx_strtrim(value));
cxMapPut(map, cx_hash_key(key_cp.ptr, key_cp.length), value_cp.ptr);
free(key_cp.ptr);
return sbuffer.length;
}
int util_path_isrelated(const char *path1, const char *path2) {
cxstring p1 = cx_str(path1);
cxstring p2 = cx_str(path2);
if(IS_PATH_SEPARATOR(p1.ptr[p1.length-1])) {
p1.length--;
}
if(IS_PATH_SEPARATOR(p2.ptr[p2.length-1])) {
p2.length--;
}
if(p2.length < p1.length) {
return 0;
}
if(!cx_strcmp(p1, p2)) {
return 1;
}
if(cx_strprefix(p2, p1)) {
if(IS_PATH_SEPARATOR(p2.ptr[p1.length])) {
return 1;
}
}
return 0;
}
#ifdef _WIN32
int util_path_isabsolut(const char *path) {
if(strlen(path) < 3) {
return 0;
}
// check if first char is A-Z or a-z
char c = path[0];
if(!((c >= 65 && c <= 90) || (c >= 97 && c <= 122))) {
return 0;
}
if(path[1] == ':' && path[2] == '\\') {
return 1;
}
return 0;
}
#else
int util_path_isabsolut(const char *path) {
return path[0] == '/';
}
#endif
char* util_path_normalize(const char *path) {
size_t len = strlen(path);
CxBuffer buf;
cxBufferInit(&buf, NULL, len+1, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
if(path[0] == '/') {
cxBufferPut(&buf, '/');
}
int add_separator = 0;
int seg_start = 0;
for(int i=0;i<=len;i++) {
char c = path[i];
if(IS_PATH_SEPARATOR(c) || c == '\0') {
const char *seg_ptr = path+seg_start;
int seg_len = i - seg_start;
if(IS_PATH_SEPARATOR(seg_ptr[0])) {
seg_ptr++;
seg_len--;
}
if(seg_len > 0) {
cxstring seg = cx_strn(seg_ptr, seg_len);
if(!cx_strcmp(seg, CX_STR(".."))) {
for(int j=buf.pos;j>=0;j--) {
char t = j < buf.pos ? buf.space[j] : 0;
if(IS_PATH_SEPARATOR(t) || j == 0) {
buf.pos = j;
buf.size = j;
buf.space[j] = 0;
add_separator = IS_PATH_SEPARATOR(t) ? 1 : 0;
break;
}
}
} else if(!cx_strcmp(seg, CX_STR("."))) {
// ignore
} else {
if(add_separator) {
cxBufferPut(&buf, PATH_SEPARATOR);
}
cxBufferWrite(seg_ptr, 1, seg_len, &buf);
add_separator = 1;
}
}
seg_start = i;
}
}
cxBufferPut(&buf, 0);
return buf.space;
}
static char* create_relative_path(const char *abspath, const char *base) {
size_t path_len = strlen(abspath);
size_t base_len = strlen(base);
if(IS_PATH_SEPARATOR(abspath[path_len-1])) {
path_len--;
}
if(IS_PATH_SEPARATOR(base[base_len-1])) {
base_len--;
}
// get base parent
for(int i=base_len-1;i>=0;i--) {
if(IS_PATH_SEPARATOR(base[i])) {
base_len = i+1;
break;
}
}
size_t max = path_len > base_len ? base_len : path_len;
// get prefix of abspath and base
// this dir is the root of the link
size_t last_dir = 0;
for(size_t i=0;i<max;i++) {
char c = abspath[i];
if(c != base[i]) {
break;
} else if(IS_PATH_SEPARATOR(c)) {
last_dir = i;
}
}
char *ret = NULL;
CxBuffer out;
if(last_dir+1 < base_len) {
// base is deeper than the link root, we have to go backwards
size_t dircount = 0;
for(size_t i=last_dir+1;i<base_len;i++) {
if(IS_PATH_SEPARATOR(base[i])) {
dircount++;
}
}
cxBufferInit(&out, NULL, dircount*3+path_len-last_dir, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
for(size_t i=0;i<dircount;i++) {
cxBufferPutString(&out, "../");
}
} else {
cxBufferInit(&out, NULL, path_len - last_dir, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
}
cxBufferPutString(&out, abspath + last_dir + 1);
cxBufferPut(&out, 0);
return out.space;
}
#ifdef _WIN32
char* util_create_relative_path(const char *abspath, const char *base) {
char *abspath_converted = strdup(abspath);
char *base_converted = strdup(base);
size_t abs_len = strlen(abspath_converted);
size_t base_len = strlen(base_converted);
for(int i=0;i<abs_len;i++) {
if(abspath_converted[i] == '\\') {
abspath_converted[i] = '/';
}
}
for(int i=0;i<base_len;i++) {
if(base_converted[i] == '\\') {
base_converted[i] = '/';
}
}
char *ret = create_relative_path(abspath_converted, base_converted);
free(abspath_converted);
free(base_converted);
return ret;
}
#else
char* util_create_relative_path(const char *abspath, const char *base) {
return create_relative_path(abspath, base);
}
#endif
void util_capture_header(CURL *handle, CxMap* map) {
if(map) {
curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, util_header_callback);
curl_easy_setopt(handle, CURLOPT_HEADERDATA, map);
} else {
curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, NULL);
curl_easy_setopt(handle, CURLOPT_HEADERDATA, NULL);
}
}
const char* util_resource_name(const char *url) {
cxstring urlstr = cx_str(url);
if(urlstr.ptr[urlstr.length-1] == '/') {
urlstr.length--;
}
cxstring resname = cx_strrchr(urlstr, '/');
if(resname.length > 1) {
return resname.ptr+1;
} else {
return url;
}
}
const char* util_resource_name_c(const char *url, char pathseparator) {
cxstring urlstr = cx_str(url);
if(urlstr.ptr[urlstr.length-1] == pathseparator) {
urlstr.length--;
}
cxstring resname = cx_strrchr(urlstr, pathseparator);
if(resname.length > 1) {
return resname.ptr+1;
} else {
return url;
}
}
const char* util_path_file_name(const char *url) {
#ifdef _WIN32
return util_resource_name_c(url, '\\');
#else
return util_resource_name_c(url, '/');
#endif
}
int util_mkdir(char *path, mode_t mode) {
#ifdef _WIN32
return mkdir(path);
#else
return mkdir(path, mode);
#endif
}
char* util_concat_path(const char *url_base, const char *p) {
cxstring base = cx_str(url_base);
cxstring path;
if(p) {
path = cx_str((char*)p);
} else {
path = CX_STR("");
}
return util_concat_path_s(base, path).ptr;
}
cxmutstr util_concat_path_s(cxstring base, cxstring path) {
if(!path.ptr) {
path = CX_STR("");
}
int add_separator = 0;
if(base.length != 0 && base.ptr[base.length-1] == '/') {
if(path.ptr[0] == '/') {
base.length--;
}
} else {
if(path.length == 0 || path.ptr[0] != '/') {
add_separator = 1;
}
}
cxmutstr url;
if(add_separator) {
url = cx_strcat(3, base, CX_STR("/"), path);
} else {
url = cx_strcat(2, base, path);
}
return url;
}
cxmutstr util_concat_path_ext(cxstring base, cxstring path, char separator) {
if(!path.ptr) {
path = CX_STR("");
}
int add_separator = 0;
if(base.length != 0 && base.ptr[base.length-1] == separator) {
if(path.ptr[0] == separator) {
base.length--;
}
} else {
if(path.length == 0 || path.ptr[0] != separator) {
add_separator = 1;
}
}
cxmutstr url;
if(add_separator) {
url = cx_strcat(3, base, cx_strn(&separator, 1), path);
} else {
url = cx_strcat(2, base, path);
}
return url;
}
cxmutstr util_concat_sys_path(cxstring base, cxstring path) {
#ifdef _WIN32
return util_concat_path_ext(base, path, '\\');
#else
return util_concat_path_ext(base, path, '/');
#endif
}
char* util_get_url(DavSession *sn, const char *href) {
cxstring base = cx_str(sn->base_url);
cxstring href_str = cx_str(href);
const char *base_path = util_url_path(sn->base_url);
base.length -= strlen(base_path);
cxmutstr url = cx_strcat(2, base, href_str);
return url.ptr;
}
void util_set_url(DavSession *sn, const char *href) {
char *url = util_get_url(sn, href);
curl_easy_setopt(sn->handle, CURLOPT_URL, url);
free(url);
}
char* util_path_to_url(DavSession *sn, const char *path) {
size_t pathlen = path ? strlen(path) : 0;
if(pathlen == 0) {
return strdup(sn->base_url);
}
CxBuffer url;
cxBufferInit(&url, NULL, 256, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
// add base url
cxBufferWrite(sn->base_url, 1, strlen(sn->base_url), &url);
// remove trailing slash
cxBufferSeek(&url, -1, SEEK_CUR);
cxstring p = cx_strn(path, pathlen);
CxStrtokCtx tkctx = cx_strtok(p, CX_STR("/"), INT_MAX);
cxstring node;
while(cx_strtok_next(&tkctx, &node)) {
if(node.length > 0) {
char *esc = curl_easy_escape(sn->handle, node.ptr, node.length);
cxBufferPut(&url, '/');
cxBufferWrite(esc, 1, strlen(esc), &url);
curl_free(esc);
}
}
if(path[p.length-1] == '/') {
cxBufferPut(&url, '/');
}
cxBufferPut(&url, 0);
return url.space;
}
char* util_parent_path(const char *path) {
const 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_sys_parent_path(const char *path) {
const char *name = util_path_file_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_size_str(DavBool iscollection, uint64_t contentlength) {
return util_size_str2(iscollection, contentlength, contentlength, 1);
}
char* util_size_str2(DavBool iscollection, uint64_t contentlength, uint64_t dimension, int precision) {
char *str = malloc(16);
uint64_t size = contentlength;
if(iscollection) {
str[0] = '\0'; // currently no information for collections
} else if(dimension < 0x400) {
snprintf(str, 16, "%" PRIu64 " bytes", size);
} else if(dimension < 0x100000) {
float s = (float)size/0x400;
int diff = (s*100 - (int)s*100);
if(diff > 90) {
diff = 0;
s += 0.10f;
}
if(dimension < 0x2800 && diff != 0) {
// size < 10 KiB
snprintf(str, 16, "%.*f KiB", precision, s);
} else {
snprintf(str, 16, "%.0f KiB", s);
}
} else if(dimension < 0x40000000) {
float s = (float)size/0x100000;
int diff = (s*100 - (int)s*100);
if(diff > 90) {
diff = 0;
s += 0.10f;
}
if(dimension < 0xa00000 && diff != 0) {
// size < 10 MiB
snprintf(str, 16, "%.*f MiB", precision, s);
} else {
size /= 0x100000;
snprintf(str, 16, "%.0f MiB", s);
}
} else if(dimension < 0x1000000000ULL) {
float s = (float)size/0x40000000;
int diff = (s*100 - (int)s*100);
if(diff > 90) {
diff = 0;
s += 0.10f;
}
if(dimension < 0x280000000 && diff != 0) {
// size < 10 GiB
snprintf(str, 16, "%.*f GiB", precision, s);
} else {
size /= 0x40000000;
snprintf(str, 16, "%.0f GiB", s);
}
} else {
size /= 1024;
float s = (float)size/0x40000000;
int diff = (s*100 - (int)s*100);
if(diff > 90) {
diff = 0;
s += 0.10f;
}
if(dimension < 0x280000000 && diff != 0) {
// size < 10 TiB
snprintf(str, 16, "%.*f TiB", precision, s);
} else {
size /= 0x40000000;
snprintf(str, 16, "%.0f TiB", s);
}
}
return str;
}
char* util_date_str(time_t tm) {
struct tm t;
struct tm n;
time_t now = time(NULL);
#ifdef _WIN32
memcpy(&t, localtime(&tm), sizeof(struct tm));
memcpy(&n, localtime(&now), sizeof(struct tm));
#else
localtime_r(&tm, &t);
localtime_r(&now, &n);
#endif /* _WIN32 */
char *str = malloc(16);
if(t.tm_year == n.tm_year) {
strftime(str, 16, "%b %d %H:%M", &t);
} else {
strftime(str, 16, "%b %d %Y", &t);
}
return str;
}
char* util_xml_get_text(const 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(const char *in) {
int len = 0;
return util_base64decode_len(in, &len);
}
#define WHITESPACE 64
#define EQUALS 65
#define INVALID 66
static char b64dectable[] = {
66,66,66,66,66,66,66,66,66,66,64,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,62,66,66,66,63,52,53,
54,55,56,57,58,59,60,61,66,66,66,65,66,66,66, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,66,66,66,66,66,66,26,27,28,
29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,66,66,
66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
66,66,66,66,66,66
};
char* util_base64decode_len(const char* in, int *outlen) {
/* code is mostly from wikibooks */
if(!in) {
*outlen = 0;
return NULL;
}
size_t inlen = strlen(in);
size_t bufsize = (inlen*3) / 4;
char *outbuf = malloc(bufsize+1);
*outlen = -1;
unsigned char *out = (unsigned char*)outbuf;
const char *end = in + inlen;
char iter = 0;
uint32_t buf = 0;
size_t len = 0;
while (in < end) {
unsigned char c = b64dectable[*in++];
switch (c) {
case WHITESPACE: continue; /* skip whitespace */
case INVALID: {
/* invalid input */
outbuf[0] = 0;
return outbuf;
}
case EQUALS: {
/* pad character, end of data */
in = end;
continue;
}
default: {
buf = buf << 6 | c;
iter++; // increment the number of iteration
/* If the buffer is full, split it into bytes */
if (iter == 4) {
if ((len += 3) > bufsize) {
/* buffer overflow */
outbuf[0] = 0;
return outbuf;
}
*(out++) = (buf >> 16) & 255;
*(out++) = (buf >> 8) & 255;
*(out++) = buf & 255;
buf = 0; iter = 0;
}
}
}
}
if (iter == 3) {
if ((len += 2) > bufsize) {
/* buffer overflow */
outbuf[0] = 0;
return outbuf;
}
*(out++) = (buf >> 10) & 255;
*(out++) = (buf >> 2) & 255;
}
else if (iter == 2) {
if (++len > bufsize) {
/* buffer overflow */
outbuf[0] = 0;
return outbuf;
}
*(out++) = (buf >> 4) & 255;
}
*outlen = len; /* modify to reflect the actual output size */
outbuf[len] = 0;
return outbuf;
}
static char* b64enctable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
char* util_base64encode(const char *in, size_t len) {
// calculate length of base64 output and create buffer
size_t outlen = 4 * ((len + 2) / 3);
int pad = len % 3;
char *out = malloc(outlen + 1);
out[outlen] = 0;
size_t pos = 0;
// encode blocks of 3 bytes
size_t i;
size_t blockend = len - pad;
for(i=0;i<blockend;i++) {
unsigned char b1 = in[i++];
unsigned char b2 = in[i++];
unsigned char b3 = in[i];
uint32_t inb = b1 << 16 | (b2 << 8) | b3;
out[pos++] = b64enctable[(inb >> 18) & 63];
out[pos++] = b64enctable[(inb >> 12) & 63];
out[pos++] = b64enctable[(inb >> 6) & 63];
out[pos++] = b64enctable[(inb) & 63];
}
// encode last bytes
if(pad > 0) {
char p[3] = {0, 0, 0};
for(int j=0;i<len;i++) {
p[j++] = in[i];
}
unsigned char b1 = p[0];
unsigned char b2 = p[1];
unsigned char b3 = p[2];
uint32_t inb = (b1 << 16) | (b2 << 8) | b3;
out[pos++] = b64enctable[(inb >> 18) & 63];
out[pos++] = b64enctable[(inb >> 12) & 63];
out[pos++] = b64enctable[(inb >> 6) & 63];
out[pos++] = b64enctable[(inb) & 63];
for(int k=outlen-1;k>=outlen-(3-pad);k--) {
out[k] = '=';
}
}
return out;
}
char* util_encrypt_str(DavSession *sn, const char *str, const char *key) {
DavKey *k = dav_context_get_key(sn->context, key);
if(!k) {
sn->error = DAV_ERROR;
cxmutstr err = cx_asprintf("Key %s not found", key);
dav_session_set_errstr(sn, err.ptr);
free(err.ptr);
return NULL;
}
return util_encrypt_str_k(sn, str, k);
}
char* util_encrypt_str_k(DavSession *sn, const char *str, DavKey *key) {
char *enc_str = aes_encrypt(str, strlen(str), key);
char *ret_str = dav_session_strdup(sn, enc_str);
free(enc_str);
return ret_str;
}
char* util_decrypt_str(DavSession *sn, const char *str, const char *key) {
DavKey *k = dav_context_get_key(sn->context, key);
if(!k) {
sn->error = DAV_ERROR;
cxmutstr err = cx_asprintf("Key %s not found", key);
dav_session_set_errstr(sn, err.ptr);
free(err.ptr);
return NULL;
}
return util_decrypt_str_k(sn, str, k);
}
char* util_decrypt_str_k(DavSession *sn, const char *str, DavKey *key) {
size_t len = 0;
char *dec_str = aes_decrypt(str, &len, key);
char *ret_str = dav_session_strdup(sn, dec_str);
free(dec_str);
return ret_str;
}
char* util_random_str() {
unsigned char *str = malloc(25);
str[24] = '\0';
cxstring t = CX_STR(
"01234567890"
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ");
const unsigned char *table = (const unsigned char*)t.ptr;
#ifdef DAV_USE_OPENSSL
RAND_bytes(str, 24);
#else
dav_rand_bytes(str, 24);
#endif
for(int i=0;i<24;i++) {
int c = str[i] % t.length;
str[i] = table[c];
}
return (char*)str;
}
/*
* gets a substring from 0 to the appearance of the token
* tokens are separated by space
* sets sub to the substring and returns the remaining string
*/
// TODO: remove if it isn't used
/*
sstr_t util_getsubstr_until_token(sstr_t str, sstr_t token, sstr_t *sub) {
int i;
int token_start = -1;
int token_end = -1;
for(i=0;i<=str.length;i++) {
int c;
if(i == str.length) {
c = ' ';
} else {
c = str.ptr[i];
}
if(c < 33) {
if(token_start != -1) {
token_end = i;
size_t len = token_end - token_start;
sstr_t tk = sstrsubsl(str, token_start, len);
//printf("token: {%.*s}\n", token.length, token.ptr);
if(!sstrcmp(tk, token)) {
*sub = sstrtrim(sstrsubsl(str, 0, token_start));
break;
}
token_start = -1;
token_end = -1;
}
} else {
if(token_start == -1) {
token_start = i;
}
}
}
if(i < str.length) {
return sstrtrim(sstrsubs(str, i));
} else {
str.ptr = NULL;
str.length = 0;
return str;
}
}
*/
cxmutstr util_readline(FILE *stream) {
CxBuffer buf;
cxBufferInit(&buf, NULL, 128, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
int c;
while((c = fgetc(stream)) != EOF) {
if(c == '\n') {
break;
}
cxBufferPut(&buf, c);
}
cxmutstr str = cx_strdup(cx_strtrim(cx_strn(buf.space, buf.size)));
cxBufferDestroy(&buf);
return str;
}
char* util_password_input(char *prompt) {
fprintf(stderr, "%s", prompt);
fflush(stderr);
#ifndef _WIN32
// hide terminal input
struct termios oflags, nflags;
if(isatty(fileno(stdin))) {
tcgetattr(fileno(stdin), &oflags);
nflags = oflags;
nflags.c_lflag &= ~ECHO;
nflags.c_lflag |= ECHONL;
if (tcsetattr(fileno(stdin), TCSANOW, &nflags) != 0) {
perror("tcsetattr");
}
}
#endif
// read password input
CxBuffer buf;
cxBufferInit(&buf, NULL, 128, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
int c = 0;
while((c = getpasswordchar()) != EOF) {
if(c == '\n' || c == '\r') {
break;
}
cxBufferPut(&buf, c);
}
cxBufferPut(&buf, 0);
fflush(stdin);
#ifndef _WIN32
// restore terminal settings
if (isatty(fileno(stdin)) && tcsetattr(fileno(stdin), TCSANOW, &oflags) != 0) {
perror("tcsetattr");
}
#endif
return buf.space;
}
int util_exec_command(char *command, CxBuffer *outbuf) {
#ifdef _WIN32
fprintf(stderr, "util_exec_command unsupported\n");
return 1;
#else
int pout[2];
if(pipe(pout)) {
perror("pipe");
return 1;
}
int ret = 0;
// close stdin and stderr, use pipe for stdout
posix_spawn_file_actions_t actions;
posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_addclose(&actions, 0);
posix_spawn_file_actions_adddup2(&actions, pout[1], 1);
posix_spawn_file_actions_addclose(&actions, 2);
char *args[4];
args[0] = "sh";
args[1] = "-c";
args[2] = command;
args[3] = NULL;
pid_t pid; // child pid
ret = posix_spawn(&pid, "/bin/sh", &actions, NULL, args, NULL);
close(pout[1]);
if(!ret) {
ssize_t r;
char buf[1024];
while((r = read(pout[0], buf, 1024)) > 0) {
cxBufferWrite(buf, 1, r, outbuf);
}
}
// wait for child process
ret = 1;
waitpid(pid, &ret, 0);
posix_spawn_file_actions_destroy(&actions);
close(pout[0]);
return ret;
#endif
}
char* util_hexstr(const unsigned char *data, size_t len) {
size_t buflen = 2*len + 4;
CxBuffer buf;
cxBufferInit(&buf, NULL, buflen + 1, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
for(int i=0;i<len;i++) {
cx_bprintf(&buf, "%02x", data[i]);
}
cxBufferPut(&buf, 0);
return buf.space;
}
void util_remove_trailing_pathseparator(char *path) {
size_t len = strlen(path);
if(len < 2) {
return;
}
if(path[len-1] == '/') {
path[len-1] = '\0';
}
}
char* util_file_hash(const char *path) {
FILE *in = fopen(path, "r");
if(!in) {
return NULL;
}
DAV_SHA_CTX *sha = dav_hash_init();
char *buf = malloc(16384);
size_t r;
while((r = fread(buf, 1, 16384, in)) > 0) {
dav_hash_update(sha, buf, r);
}
unsigned char hash[DAV_SHA256_DIGEST_LENGTH];
dav_hash_final(sha, hash);
free(buf);
fclose(in);
return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
}