libidav/utils.c@d2bd73d28ff1
libidav/utils.c
Thu, 12 Dec 2024 20:01:43 +0100
- author
- Olaf Wintermann <olaf.wintermann@gmail.com>
- date
- Thu, 12 Dec 2024 20:01:43 +0100
- changeset 100
- d2bd73d28ff1
- parent 59
- 6bd37fe6d905
- permissions
- -rw-r--r--
update toolkit
/* * 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); }
