libidav/utils.c

   1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   3  *
   4  * Copyright 2019 Olaf Wintermann. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  *   1. Redistributions of source code must retain the above copyright
  10  *      notice, this list of conditions and the following disclaimer.
  11  *
  12  *   2. Redistributions in binary form must reproduce the above copyright
  13  *      notice, this list of conditions and the following disclaimer in the
  14  *      documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <time.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <ctype.h>
  35 #include <ucx/string.h>
  36 #include <ucx/buffer.h>
  37 #include <ucx/utils.h>
  38 #include <libxml/tree.h>
  39 #include <curl/curl.h>
  40
  41 #ifdef _WIN32
  42 #include <conio.h>
  43 #define getpasswordchar() getch()
  44 #define IS_PATH_SEPARATOR(c) (c == '/' || c == '\\')
  45 #define PATH_SEPARATOR '\\'
  46 #else
  47 #include <termios.h>
  48 #define getpasswordchar() getchar()
  49 #define IS_PATH_SEPARATOR(c) (c == '/')
  50 #define PATH_SEPARATOR '/'
  51 #endif
  52
  53 #include "webdav.h"
  54 #include "utils.h"
  55 #include "crypto.h"
  56 #include "session.h"
  57
  58 /*
  59 #include <openssl/hmac.h>
  60 #include <openssl/evp.h>
  61 #include <openssl/bio.h>
  62 #include <openssl/buffer.h>
  63 #include <openssl/rand.h>
  64 */
  65
  66 static size_t extractval(sstr_t str, char *result, char delim) {
  67     size_t n = 0;
  68     for(size_t i = 0; i < str.length ; i++) {
  69         if(isdigit(str.ptr[i])) {
  70             result[n++] = str.ptr[i];
  71         } else if(str.ptr[i] != delim) {
  72             return 0;
  73         }
  74     }
  75     result[n] = '\0';
  76     return n;
  77 }
  78
  79 static time_t parse_iso8601(char *iso8601str) {
  80
  81     // safety
  82     if(!iso8601str) {
  83         return 0;
  84     }
  85
  86     // local vars
  87     struct tm tparts;
  88     memset(&tparts, 0, sizeof(struct tm));
  89     long val;
  90     char conv[16];
  91
  92     // work on the trimmed string
  93     sstr_t date = sstrtrim(sstr(iso8601str));
  94
  95     sstr_t time = sstrchr(date, 'T');
  96     if(time.length == 0) {
  97         return 0;
  98     }
  99     date.length = time.ptr - date.ptr;
 100     time.ptr++; time.length--;
 101
 102     sstr_t tzinfo;
 103     if((tzinfo = sstrchr(time, 'Z')).length > 0 ||
 104         (tzinfo = sstrchr(time, '+')).length > 0 ||
 105         (tzinfo = sstrchr(time, '-')).length > 0) {
 106
 107         time.length = tzinfo.ptr - time.ptr;
 108     }
 109
 110     // parse date
 111     if((date.length != 8 && date.length != 10)
 112             || extractval(date, conv , '-') != 8) {
 113         return 0;
 114     }
 115     val = atol(conv);
 116     if(val < 19000000L) {
 117         return 0;
 118     }
 119     tparts.tm_mday = val % 100;
 120     tparts.tm_mon = (val % 10000) / 100 - 1;
 121     tparts.tm_year = val / 10000 - 1900;
 122
 123     // parse time and skip possible fractional seconds
 124     sstr_t frac;
 125     if((frac = sstrchr(time, '.')).length > 0 ||
 126         (frac = sstrchr(time, ',')).length > 0) {
 127         time.length = frac.ptr - time.ptr;
 128     }
 129     if((time.length != 6 && time.length != 8)
 130             || extractval(time, conv , ':') != 6) {
 131         return 0;
 132     }
 133     val = atol(conv);
 134     tparts.tm_sec = val % 100;
 135     tparts.tm_min = (val % 10000) / 100;
 136     tparts.tm_hour = val / 10000;
 137
 138
 139     // parse time zone (if any)
 140     if(tzinfo.length == 0) {
 141         // local time
 142         tparts.tm_isdst = -1;
 143         return mktime(&tparts);
 144     } else if(!sstrcmp(tzinfo, S("Z"))) {
 145 #ifdef __FreeBSD__
 146         return timegm(&tparts);
 147 #else
 148         return mktime(&tparts) - timezone;
 149 #endif
 150     } else if(tzinfo.ptr[0] == '+' || tzinfo.ptr[0] == '-') {
 151         int sign = (tzinfo.ptr[0] == '+') ? -1 : 1;
 152
 153         if(tzinfo.length > 6) {
 154             return 0;
 155         } else {
 156             tzinfo.ptr++; tzinfo.length--;
 157             extractval(tzinfo, conv, ':');
 158             val = atol(conv);
 159             val = 60 * (val / 100) + (val % 100);
 160 #ifdef __FreeBSD__
 161             return timegm(&tparts) + (time_t) (60 * val * sign);
 162 #else
 163             return mktime(&tparts) - timezone + (time_t) (60 * val * sign);
 164 #endif
 165         }
 166     } else {
 167         return 0;
 168     }
 169 }
 170
 171
 172 time_t util_parse_creationdate(char *str) {
 173     // parse a ISO-8601 date (rfc-3339)
 174     // example: 2012-11-29T21:35:35Z
 175     if(!str) {
 176         return 0;
 177     }
 178
 179     return parse_iso8601(str);
 180 }
 181
 182 time_t util_parse_lastmodified(char *str) {
 183     // parse a rfc-1123 date
 184     // example: Thu, 29 Nov 2012 21:35:35 GMT
 185     if(!str) {
 186         return 0;
 187     } else {
 188         time_t result = curl_getdate(str, NULL);
 189         if(result == -1) {
 190             // fall back to the ISO-8601 format (e.g. Microsoft Sharepoint
 191             // illegally uses this format for lastmodified, but also some
 192             // users might want to give an ISO-8601 date)
 193             return util_parse_creationdate(str);
 194         } else {
 195             return result;
 196         }
 197     }
 198 }
 199
 200 int util_getboolean(const char *v) {
 201     if(v[0] == 'T' || v[0] == 't') {
 202         return 1;
 203     }
 204     return 0;
 205 }
 206
 207 int util_strtouint(const char *str, uint64_t *value) {
 208     char *end;
 209     errno = 0;
 210     uint64_t val = strtoull(str, &end, 0);
 211     if(errno == 0) {
 212         *value = val;
 213         return 1;
 214     } else {
 215         return 0;
 216     }
 217 }
 218
 219 int util_strtoint(const char *str, int64_t *value) {
 220     char *end;
 221     errno = 0;
 222     int64_t val = strtoll(str, &end, 0);
 223     if(errno == 0) {
 224         *value = val;
 225         return 1;
 226     } else {
 227         return 0;
 228     }
 229 }
 230
 231 int util_szstrtouint(const char *str, uint64_t *value) {
 232     char *end;
 233     errno = 0;
 234     size_t len = strlen(str);
 235     uint64_t val = strtoull(str, &end, 0);
 236     if(end == str+len) {
 237         *value = val;
 238         return 1;
 239     } else if(end == str+len-1) {
 240         uint64_t mul = 1;
 241         switch(end[0]) {
 242             case 'k':
 243             case 'K': mul = 1024; break;
 244             case 'm':
 245             case 'M': mul = 1024*1024; break;
 246             case 'g':
 247             case 'G': mul = 1024*1024*1024; break;
 248             default: return 0;
 249         }
 250
 251         uint64_t result = 0;
 252         if(util_uint_mul(val, mul, &result)) {
 253             return 0;
 254         }
 255         *value = result;
 256         return 1;
 257     }
 258     return 0;
 259 }
 260
 261 int util_uint_mul(uint64_t a, uint64_t b, uint64_t *result) {
 262     if(a == 0 || b == 0) {
 263         *result = 0;
 264         return 0;
 265     }
 266     uint64_t r = a * b;
 267     if(r / b == a) {
 268         *result = r;
 269         return 0;
 270     } else {
 271         *result = 0;
 272         return 1;
 273     }
 274 }
 275
 276 char* util_url_base_s(sstr_t url) {
 277     size_t i = 0;
 278     if(url.length > 0) {
 279         int slmax;
 280         if(sstrprefix(url, SC("http://"))) {
 281             slmax = 3;
 282         } else if(sstrprefix(url, SC("https://"))) {
 283             slmax = 3;
 284         } else {
 285             slmax = 1;
 286         }
 287         int slashcount = 0;
 288         for(i=0;i<url.length;i++) {
 289             if(url.ptr[i] == '/') {
 290                 slashcount++;
 291                 if(slashcount == slmax) {
 292                     i++;
 293                     break;
 294                 }
 295             }
 296         }
 297     }
 298     sstr_t server = sstrsubsl(url, 0, i);
 299     return sstrdup(server).ptr;
 300 }
 301
 302 char* util_url_base(char *url) {
 303     return util_url_base_s(sstr(url));
 304 }
 305
 306 char* util_url_path(char *url) {
 307     char *path = NULL;
 308     size_t len = strlen(url);
 309     int slashcount = 0;
 310     int slmax;
 311     if(len > 7 && !strncasecmp(url, "http://", 7)) {
 312         slmax = 3;
 313     } else if(len > 8 && !strncasecmp(url, "https://", 8)) {
 314         slmax = 3;
 315     } else {
 316         slmax = 1;
 317     }
 318     char c;
 319     for(int i=0;i<len;i++) {
 320         c = url[i];
 321         if(c == '/') {
 322             slashcount++;
 323             if(slashcount == slmax) {
 324                 path = url + i;
 325                 break;
 326             }
 327         }
 328     }
 329     if(!path) {
 330         path = url + len; // empty string
 331     }
 332     return path;
 333 }
 334
 335 char* util_url_decode(DavSession *sn, char *url) {
 336     char *unesc = curl_easy_unescape(sn->handle, url, strlen(url), NULL);
 337     char *ret = strdup(unesc);
 338     curl_free(unesc);
 339     return ret;
 340 }
 341
 342 static size_t util_header_callback(char *buffer, size_t size,
 343         size_t nitems, void *data) {
 344
 345     sstr_t sbuffer = sstrn(buffer, size*nitems);
 346
 347     UcxMap *map = (UcxMap*) data;
 348
 349     // if we get a status line, clear the map and exit
 350     if(sstrprefix(sbuffer, S("HTTP/"))) {
 351         ucx_map_free_content(map, free);
 352         ucx_map_clear(map);
 353         return size*nitems;
 354     }
 355
 356     // if we get the terminating CRLF, just exit
 357     if(!sstrcmp(sbuffer, S("\r\n"))) {
 358         return 2;
 359     }
 360
 361     sstr_t key = sbuffer;
 362     sstr_t value = sstrchr(sbuffer, ':');
 363
 364     if(value.length == 0) {
 365         return 0; // invalid header line
 366     }
 367
 368     key.length = value.ptr - key.ptr;
 369     value.ptr++; value.length--;
 370
 371     key = sstrlower(sstrtrim(key));
 372     value = sstrdup(sstrtrim(value));
 373
 374     ucx_map_sstr_put(map, key, value.ptr);
 375
 376     free(key.ptr);
 377
 378     return sbuffer.length;
 379 }
 380
 381 int util_path_isrelated(const char *path1, const char *path2) {
 382     scstr_t p1 = scstr(path1);
 383     scstr_t p2 = scstr(path2);
 384
 385     if(IS_PATH_SEPARATOR(p1.ptr[p1.length-1])) {
 386         p1.length--;
 387     }
 388     if(IS_PATH_SEPARATOR(p2.ptr[p2.length-1])) {
 389         p2.length--;
 390     }
 391
 392     if(p2.length < p1.length) {
 393         return 0;
 394     }
 395
 396     if(!sstrcmp(p1, p2)) {
 397         return 1;
 398     }
 399
 400     if(sstrprefix(p2, p1)) {
 401         if(IS_PATH_SEPARATOR(p2.ptr[p1.length])) {
 402             return 1;
 403         }
 404     }
 405
 406     return 0;
 407 }
 408
 409 #ifdef _WIN32
 410 int util_path_isabsolut(const char *path) {
 411     if(strlen(path) < 3) {
 412         return 0;
 413     }
 414
 415     // check if first char is A-Z or a-z
 416     char c = path[0];
 417     if(!((c >= 65 && c <= 90) || (c >= 97 && c <= 122))) {
 418         return 0;
 419     }
 420
 421     if(path[1] == ':' && path[2] == '\\') {
 422         return 1;
 423     }
 424     return 0;
 425 }
 426 #else
 427 int util_path_isabsolut(const char *path) {
 428     return path[0] == '/';
 429 }
 430 #endif
 431
 432 char* util_path_normalize(const char *path) {
 433     size_t len = strlen(path);
 434     UcxBuffer *buf = ucx_buffer_new(NULL, len+1, UCX_BUFFER_AUTOEXTEND);
 435
 436     if(path[0] == '/') {
 437         ucx_buffer_putc(buf, '/');
 438     }
 439
 440     int add_separator = 0;
 441     int seg_start = 0;
 442     for(int i=0;i<=len;i++) {
 443         char c = path[i];
 444         if(IS_PATH_SEPARATOR(c) || c == '\0') {
 445             const char *seg_ptr = path+seg_start;
 446             int seg_len = i - seg_start;
 447             if(IS_PATH_SEPARATOR(seg_ptr[0])) {
 448                 seg_ptr++;
 449                 seg_len--;
 450             }
 451
 452             if(seg_len > 0) {
 453                 scstr_t seg = scstrn(seg_ptr, seg_len);
 454                 if(!sstrcmp(seg, SC(".."))) {
 455                     for(int j=buf->pos;j>=0;j--) {
 456                         char t = buf->space[j];
 457                         if(IS_PATH_SEPARATOR(t) || j == 0) {
 458                             buf->pos = j;
 459                             buf->size = j;
 460                             buf->space[j] = 0;
 461                             add_separator = IS_PATH_SEPARATOR(t) ? 1 : 0;
 462                             break;
 463                         }
 464                     }
 465                 } else if(!sstrcmp(seg, SC("."))) {
 466                     // ignore
 467                 } else {
 468                     if(add_separator) {
 469                         ucx_buffer_putc(buf, PATH_SEPARATOR);
 470                     }
 471                     ucx_buffer_write(seg_ptr, 1, seg_len, buf);
 472                     add_separator = 1;
 473                 }
 474             }
 475
 476             seg_start = i;
 477         }
 478     }
 479
 480     ucx_buffer_putc(buf, 0);
 481
 482
 483     char *space = buf->space;
 484     buf->flags = 0; // disable autofree
 485     ucx_buffer_free(buf);
 486     return space;
 487 }
 488
 489 static char* create_relative_path(const char *abspath, const char *base) {
 490     size_t path_len = strlen(abspath);
 491     size_t base_len = strlen(base);
 492
 493     if(IS_PATH_SEPARATOR(abspath[path_len-1])) {
 494         path_len--;
 495     }
 496     if(IS_PATH_SEPARATOR(base[base_len-1])) {
 497         base_len--;
 498     }
 499     // get base parent
 500     for(int i=base_len-1;i>=0;i--) {
 501         if(IS_PATH_SEPARATOR(base[i])) {
 502             base_len = i+1;
 503             break;
 504         }
 505     }
 506
 507     size_t max = path_len > base_len ? base_len : path_len;
 508
 509     // get prefix of abspath and base
 510     // this dir is the root of the link
 511     size_t i;
 512     size_t last_dir = 0;
 513     for(i=0;i<max;i++) {
 514         char c = abspath[i];
 515         if(c != base[i]) {
 516             break;
 517         } else if(IS_PATH_SEPARATOR(c)) {
 518             last_dir = i;
 519         }
 520     }
 521
 522     char *ret = NULL;
 523     UcxBuffer *out = NULL;
 524     if(last_dir+1 < base_len) {
 525         // base is deeper than the link root, we have to go backwards
 526         int dircount = 0;
 527         for(int i=last_dir+1;i<base_len;i++) {
 528             if(IS_PATH_SEPARATOR(base[i])) {
 529                 dircount++;
 530             }
 531         }
 532
 533         out = ucx_buffer_new(NULL, dircount*3+path_len-last_dir, UCX_BUFFER_AUTOEXTEND);
 534
 535         for(int i=0;i<dircount;i++) {
 536             ucx_buffer_puts(out, "../");
 537         }
 538     } else {
 539         out = ucx_buffer_new(NULL, 1024, path_len - last_dir);
 540     }
 541
 542     ucx_buffer_puts(out, abspath + last_dir + 1);
 543     ucx_buffer_putc(out, 0);
 544     out->flags = 0;
 545     ret = out->space;
 546     ucx_buffer_free(out);
 547
 548     return ret;
 549 }
 550
 551 #ifdef _WIN32
 552 char* util_create_relative_path(const char *abspath, const char *base) {
 553     char *abspath_converted = strdup(abspath);
 554     char *base_converted = strdup(base);
 555     size_t abs_len = strlen(abspath_converted);
 556     size_t base_len = strlen(base_converted);
 557
 558     for(int i=0;i<abs_len;i++) {
 559         if(abspath_converted[i] == '\\') {
 560             abspath_converted[i] = '/';
 561         }
 562     }
 563     for(int i=0;i<base_len;i++) {
 564         if(base_converted[i] == '\\') {
 565             base_converted[i] = '/';
 566         }
 567     }
 568
 569     char *ret = create_relative_path(abspath_converted, base_converted);
 570     free(abspath_converted);
 571     free(base_converted);
 572     return ret;
 573 }
 574 #else
 575 char* util_create_relative_path(const char *abspath, const char *base) {
 576     return create_relative_path(abspath, base);
 577 }
 578 #endif
 579
 580
 581 void util_capture_header(CURL *handle, UcxMap* map) {
 582     if(map) {
 583         curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, util_header_callback);
 584         curl_easy_setopt(handle, CURLOPT_HEADERDATA, map);
 585     } else {
 586         curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, NULL);
 587         curl_easy_setopt(handle, CURLOPT_HEADERDATA, NULL);
 588     }
 589 }
 590
 591 char* util_resource_name(char *url) {
 592     sstr_t urlstr = sstr(url);
 593     if(urlstr.ptr[urlstr.length-1] == '/') {
 594         urlstr.length--;
 595     }
 596     sstr_t resname = sstrrchr(urlstr, '/');
 597     if(resname.length > 1) {
 598         return resname.ptr+1;
 599     } else {
 600         return url;
 601     }
 602 }
 603
 604 int util_mkdir(char *path, mode_t mode) {
 605 #ifdef _WIN32
 606     return mkdir(path);
 607 #else
 608     return mkdir(path, mode);
 609 #endif
 610 }
 611
 612 char* util_concat_path(const char *url_base, const char *p) {
 613     sstr_t base = sstr((char*)url_base);
 614     sstr_t path;
 615     if(p) {
 616         path = sstr((char*)p);
 617     } else {
 618         path = sstrn("", 0);
 619     }
 620
 621     int add_separator = 0;
 622     if(base.length != 0 && base.ptr[base.length-1] == '/') {
 623         if(path.ptr[0] == '/') {
 624             base.length--;
 625         }
 626     } else {
 627         if(path.length == 0 || path.ptr[0] != '/') {
 628             add_separator = 1;
 629         }
 630     }
 631
 632     sstr_t url;
 633     if(add_separator) {
 634         url = sstrcat(3, base, sstr("/"), path);
 635     } else {
 636         url = sstrcat(2, base, path);
 637     }
 638
 639     return url.ptr;
 640 }
 641
 642 char* util_get_url(DavSession *sn, const char *href) {
 643     scstr_t base = scstr(sn->base_url);
 644     scstr_t href_str = scstr(href);
 645
 646     char *base_path = util_url_path(sn->base_url);
 647     base.length -= strlen(base_path);
 648
 649     sstr_t url = sstrcat(2, base, href_str);
 650     return url.ptr;
 651 }
 652
 653 void util_set_url(DavSession *sn, const char *href) {
 654     char *url = util_get_url(sn, href);
 655     curl_easy_setopt(sn->handle, CURLOPT_URL, url);
 656     free(url);
 657 }
 658
 659 char* util_path_to_url(DavSession *sn, char *path) {
 660     char *space = malloc(256);
 661     UcxBuffer *url = ucx_buffer_new(space, 256, UCX_BUFFER_AUTOEXTEND);
 662
 663     // add base url
 664     ucx_buffer_write(sn->base_url, 1, strlen(sn->base_url), url);
 665     // remove trailing slash
 666     ucx_buffer_seek(url, -1, SEEK_CUR);
 667
 668     sstr_t p = sstr(path);
 669     ssize_t ntk = 0;
 670     sstr_t *tks = sstrsplit(p, S("/"), &ntk);
 671
 672     for(int i=0;i<ntk;i++) {
 673         sstr_t node = tks[i];
 674         if(node.length > 0) {
 675             char *esc = curl_easy_escape(sn->handle, node.ptr, node.length);
 676             ucx_buffer_putc(url, '/');
 677             ucx_buffer_write(esc, 1, strlen(esc), url);
 678             curl_free(esc);
 679         }
 680         free(node.ptr);
 681     }
 682     free(tks);
 683     if(path[p.length-1] == '/') {
 684         ucx_buffer_putc(url, '/');
 685     }
 686     ucx_buffer_putc(url, 0);
 687
 688     space = url->space;
 689     ucx_buffer_free(url);
 690
 691     return space;
 692 }
 693
 694 char* util_parent_path(const char *path) {
 695     char *name = util_resource_name((char*)path);
 696     size_t namelen = strlen(name);
 697     size_t pathlen = strlen(path);
 698     size_t parentlen = pathlen - namelen;
 699     char *parent = malloc(parentlen + 1);
 700     memcpy(parent, path, parentlen);
 701     parent[parentlen] = '\0';
 702     return parent;
 703 }
 704
 705 char* util_size_str(DavBool iscollection, uint64_t contentlength) {
 706     char *str = malloc(16);
 707     uint64_t size = contentlength;
 708
 709     if(iscollection) {
 710         str[0] = '\0'; // currently no information for collections
 711     } else if(size < 0x400) {
 712         snprintf(str, 16, "%" PRIu64 " bytes", size);
 713     } else if(size < 0x100000) {
 714         float s = (float)size/0x400;
 715         int diff = (s*100 - (int)s*100);
 716         if(diff > 90) {
 717             diff = 0;
 718             s += 0.10f;
 719         }
 720         if(size < 0x2800 && diff != 0) {
 721             // size < 10 KiB
 722             snprintf(str, 16, "%.1f KiB", s);
 723         } else {
 724             snprintf(str, 16, "%.0f KiB", s);
 725         }
 726     } else if(size < 0x40000000) {
 727         float s = (float)size/0x100000;
 728         int diff = (s*100 - (int)s*100);
 729         if(diff > 90) {
 730             diff = 0;
 731             s += 0.10f;
 732         }
 733         if(size < 0xa00000 && diff != 0) {
 734             // size < 10 MiB
 735             snprintf(str, 16, "%.1f MiB", s);
 736         } else {
 737             size /= 0x100000;
 738             snprintf(str, 16, "%.0f MiB", s);
 739         }
 740     } else if(size < 0x1000000000ULL) {
 741         float s = (float)size/0x40000000;
 742         int diff = (s*100 - (int)s*100);
 743         if(diff > 90) {
 744             diff = 0;
 745             s += 0.10f;
 746         }
 747         if(size < 0x280000000 && diff != 0) {
 748             // size < 10 GiB
 749             snprintf(str, 16, "%.1f GiB", s);
 750         } else {
 751             size /= 0x40000000;
 752             snprintf(str, 16, "%.0f GiB", s);
 753         }
 754     } else {
 755         size /= 1024;
 756         float s = (float)size/0x40000000;
 757         int diff = (s*100 - (int)s*100);
 758         if(diff > 90) {
 759             diff = 0;
 760             s += 0.10f;
 761         }
 762         if(size < 0x280000000 && diff != 0) {
 763             // size < 10 TiB
 764             snprintf(str, 16, "%.1f TiB", s);
 765         } else {
 766             size /= 0x40000000;
 767             snprintf(str, 16, "%.0f TiB", s);
 768         }
 769     }
 770     return str;
 771 }
 772
 773 char* util_date_str(time_t tm) {
 774     struct tm t;
 775     struct tm n;
 776     time_t now = time(NULL);
 777 #ifdef _WIN32
 778     memcpy(&t, localtime(&tm), sizeof(struct tm));
 779     memcpy(&n, localtime(&now), sizeof(struct tm));
 780 #else
 781     localtime_r(&tm, &t);
 782     localtime_r(&now, &n);
 783 #endif /* _WIN32 */
 784     char *str = malloc(16);
 785     if(t.tm_year == n.tm_year) {
 786         strftime(str, 16, "%b %d %H:%M", &t);
 787     } else {
 788         strftime(str, 16, "%b %d  %Y", &t);
 789     }
 790     return str;
 791 }
 792
 793
 794 char* util_xml_get_text(const xmlNode *elm) {
 795     xmlNode *node = elm->children;
 796     while(node) {
 797         if(node->type == XML_TEXT_NODE) {
 798             return (char*)node->content;
 799         }
 800         node = node->next;
 801     }
 802     return NULL;
 803 }
 804
 805
 806 char* util_base64decode(const char *in) {
 807     int len = 0;
 808     return util_base64decode_len(in, &len);
 809 }
 810
 811 #define WHITESPACE 64
 812 #define EQUALS     65
 813 #define INVALID    66
 814 static char b64dectable[] = {
 815     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,
 816     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,
 817     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,
 818     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,
 819     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,
 820     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,
 821     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,
 822     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,
 823     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,
 824     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,
 825     66,66,66,66,66,66
 826 };
 827 char* util_base64decode_len(const char* in, int *outlen) {
 828     /* code is mostly from wikibooks */
 829
 830     if(!in) {
 831         *outlen = 0;
 832         return NULL;
 833     }
 834
 835     size_t inlen = strlen(in);
 836     size_t bufsize = (inlen*3) / 4;
 837     char *outbuf = malloc(bufsize+1);
 838     *outlen = -1;
 839
 840     unsigned char *out = (unsigned char*)outbuf;
 841
 842     const char *end = in + inlen;
 843     char iter = 0;
 844     uint32_t buf = 0;
 845     size_t len = 0;
 846
 847     while (in < end) {
 848         unsigned char c = b64dectable[*in++];
 849
 850         switch (c) {
 851             case WHITESPACE: continue; /* skip whitespace */
 852             case INVALID: {
 853                   /* invalid input */
 854                 outbuf[0] = 0;
 855                 return outbuf;
 856             }
 857             case EQUALS: {
 858                 /* pad character, end of data */
 859                 in = end;
 860                 continue;
 861             }
 862             default: {
 863                 buf = buf << 6 | c;
 864                 iter++; // increment the number of iteration
 865                 /* If the buffer is full, split it into bytes */
 866                 if (iter == 4) {
 867                     if ((len += 3) > bufsize) {
 868                         /* buffer overflow */
 869                         outbuf[0] = 0;
 870                         return outbuf;
 871                     }
 872                     *(out++) = (buf >> 16) & 255;
 873                     *(out++) = (buf >> 8) & 255;
 874                     *(out++) = buf & 255;
 875                     buf = 0; iter = 0;
 876
 877                 }
 878             }
 879         }
 880     }
 881
 882     if (iter == 3) {
 883         if ((len += 2) > bufsize) {
 884             /* buffer overflow */
 885             outbuf[0] = 0;
 886             return outbuf;
 887         }
 888         *(out++) = (buf >> 10) & 255;
 889         *(out++) = (buf >> 2) & 255;
 890     }
 891     else if (iter == 2) {
 892         if (++len > bufsize) {
 893             /* buffer overflow */
 894             outbuf[0] = 0;
 895             return outbuf;
 896         }
 897         *(out++) = (buf >> 4) & 255;
 898     }
 899
 900     *outlen = len; /* modify to reflect the actual output size */
 901     outbuf[len] = 0;
 902     return outbuf;
 903 }
 904
 905
 906 static char* b64enctable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 907 char* util_base64encode(const char *in, size_t len) {
 908     // calculate length of base64 output and create buffer
 909     size_t outlen = 4 * ((len + 2) / 3);
 910     int pad = len % 3;
 911
 912     char *out = malloc(outlen + 1);
 913     out[outlen] = 0;
 914     size_t pos = 0;
 915
 916     // encode blocks of 3 bytes
 917     size_t i;
 918     size_t blockend = len - pad;
 919     for(i=0;i<blockend;i++) {
 920         unsigned char b1 = in[i++];
 921         unsigned char b2 = in[i++];
 922         unsigned char b3 = in[i];
 923         uint32_t inb = b1 << 16 | (b2 << 8) | b3;
 924         out[pos++] = b64enctable[(inb >> 18) & 63];
 925         out[pos++] = b64enctable[(inb >> 12) & 63];
 926         out[pos++] = b64enctable[(inb >> 6) & 63];
 927         out[pos++] = b64enctable[(inb) & 63];
 928     }
 929
 930     // encode last bytes
 931     if(pad > 0) {
 932         char p[3] = {0, 0, 0};
 933         for(int j=0;i<len;i++) {
 934             p[j++] = in[i];
 935         }
 936         unsigned char b1 = p[0];
 937         unsigned char b2 = p[1];
 938         unsigned char b3 = p[2];
 939         uint32_t inb = (b1 << 16) | (b2 << 8) | b3;
 940         out[pos++] = b64enctable[(inb >> 18) & 63];
 941         out[pos++] = b64enctable[(inb >> 12) & 63];
 942         out[pos++] = b64enctable[(inb >> 6) & 63];
 943         out[pos++] = b64enctable[(inb) & 63];
 944         for(int k=outlen-1;k>=outlen-(3-pad);k--) {
 945             out[k] = '=';
 946         }
 947     }
 948
 949     return out;
 950 }
 951
 952 char* util_encrypt_str(DavSession *sn, char *str, char *key) {
 953     DavKey *k = dav_context_get_key(sn->context, key);
 954     if(!k) {
 955         sn->error = DAV_ERROR;
 956         sstr_t err = ucx_sprintf("Key %s not found", key);
 957         dav_session_set_errstr(sn, err.ptr);
 958         free(err.ptr);
 959         return NULL;
 960     }
 961
 962     return util_encrypt_str_k(sn, str, k);
 963 }
 964
 965 char* util_encrypt_str_k(DavSession *sn, char *str, DavKey *key) {
 966     char *enc_str = aes_encrypt(str, strlen(str), key);
 967     char *ret_str = dav_session_strdup(sn, enc_str);
 968     free(enc_str);
 969     return ret_str;
 970 }
 971
 972 char* util_decrypt_str(DavSession *sn, char *str, char *key) {
 973     DavKey *k = dav_context_get_key(sn->context, key);
 974     if(!k) {
 975         sn->error = DAV_ERROR;
 976         sstr_t err = ucx_sprintf("Key %s not found", key);
 977         dav_session_set_errstr(sn, err.ptr);
 978         free(err.ptr);
 979         return NULL;
 980     }
 981
 982     return util_decrypt_str_k(sn, str, k);
 983 }
 984
 985 char* util_decrypt_str_k(DavSession *sn, char *str, DavKey *key) {
 986     size_t len = 0;
 987     char *dec_str = aes_decrypt(str, &len, key);
 988     char *ret_str = dav_session_strdup(sn, dec_str);
 989     free(dec_str);
 990     return ret_str;
 991 }
 992
 993 char* util_random_str() {
 994     unsigned char *str = malloc(25);
 995     str[24] = '\0';
 996
 997     sstr_t t = S(
 998             "01234567890"
 999             "abcdefghijklmnopqrstuvwxyz"
1000             "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
1001     const unsigned char *table = (const unsigned char*)t.ptr;
1002
1003 #ifdef DAV_USE_OPENSSL
1004     RAND_bytes(str, 24);
1005 #else
1006     dav_rand_bytes(str, 24);
1007 #endif
1008     for(int i=0;i<24;i++) {
1009         int c = str[i] % t.length;
1010         str[i] = table[c];
1011     }
1012
1013     return (char*)str;
1014 }
1015
1016 /*
1017  * gets a substring from 0 to the appearance of the token
1018  * tokens are separated by space
1019  * sets sub to the substring and returns the remaining string
1020  */
1021 sstr_t util_getsubstr_until_token(sstr_t str, sstr_t token, sstr_t *sub) {
1022     int i;
1023     int token_start = -1;
1024     int token_end = -1;
1025     for(i=0;i<=str.length;i++) {
1026         int c;
1027         if(i == str.length) {
1028             c = ' ';
1029         } else {
1030             c = str.ptr[i];
1031         }
1032         if(c < 33) {
1033             if(token_start != -1) {
1034                 token_end = i;
1035                 size_t len = token_end - token_start;
1036                 sstr_t tk = sstrsubsl(str, token_start, len);
1037                 //printf("token: {%.*s}\n", token.length, token.ptr);
1038                 if(!sstrcmp(tk, token)) {
1039                     *sub = sstrtrim(sstrsubsl(str, 0, token_start));
1040                     break;
1041                 }
1042                 token_start = -1;
1043                 token_end = -1;
1044             }
1045         } else {
1046             if(token_start == -1) {
1047                 token_start = i;
1048             }
1049         }
1050     }
1051
1052     if(i < str.length) {
1053         return sstrtrim(sstrsubs(str, i));
1054     } else {
1055         str.ptr = NULL;
1056         str.length = 0;
1057         return str;
1058     }
1059 }
1060
1061 sstr_t util_readline(FILE *stream) {
1062     UcxBuffer *buf = ucx_buffer_new(NULL, 128, UCX_BUFFER_AUTOEXTEND);
1063
1064     int c;
1065     while((c = fgetc(stream)) != EOF) {
1066         if(c == '\n') {
1067             break;
1068         }
1069         ucx_buffer_putc(buf, c);
1070     }
1071
1072     sstr_t str = sstrdup(sstrtrim(sstrn(buf->space, buf->size)));
1073     ucx_buffer_free(buf);
1074     return str;
1075 }
1076
1077 char* util_password_input(char *prompt) {
1078     fprintf(stderr, "%s", prompt);
1079     fflush(stderr);
1080
1081 #ifndef _WIN32
1082     // hide terminal input
1083     struct termios oflags, nflags;
1084     tcgetattr(fileno(stdin), &oflags);
1085     nflags = oflags;
1086     nflags.c_lflag &= ~ECHO;
1087     nflags.c_lflag |= ECHONL;
1088     if (tcsetattr(fileno(stdin), TCSANOW, &nflags) != 0) {
1089         perror("tcsetattr");
1090     }
1091 #endif
1092
1093     // read password input
1094     UcxBuffer *buf = ucx_buffer_new(NULL, 128, UCX_BUFFER_AUTOEXTEND);
1095     int c = 0;
1096     while((c = getpasswordchar()) != EOF) {
1097         if(c == '\n' || c == '\r') {
1098             break;
1099         }
1100         ucx_buffer_putc(buf, c);
1101     }
1102     ucx_buffer_putc(buf, 0);
1103     fflush(stdin);
1104
1105 #ifndef _WIN32
1106     // restore terminal settings
1107     if (tcsetattr(fileno(stdin), TCSANOW, &oflags) != 0) {
1108         perror("tcsetattr");
1109     }
1110 #endif
1111
1112     char *str = buf->space;
1113     free(buf); // only free the UcxBuffer struct
1114     return str;
1115 }
1116
1117
1118 char* util_hexstr(const unsigned char *data, size_t len) {
1119     size_t buflen = 2*len + 4;
1120     UcxBuffer *buf = ucx_buffer_new(malloc(buflen), buflen + 1, 0);
1121     for(int i=0;i<len;i++) {
1122         ucx_bprintf(buf, "%02x", data[i]);
1123     }
1124     ucx_buffer_putc(buf, 0);
1125     char *str = buf->space;
1126     ucx_buffer_free(buf);
1127     return str;
1128 }
1129
1130 void util_remove_trailing_pathseparator(char *path) {
1131     size_t len = strlen(path);
1132     if(len < 2) {
1133         return;
1134     }
1135
1136     if(path[len-1] == '/') {
1137         path[len-1] = '\0';
1138     }
1139 }
1140
1141 char* util_file_hash(const char *path) {
1142     FILE *in = fopen(path, "r");
1143     if(!in) {
1144         return NULL;
1145     }
1146
1147     DAV_SHA_CTX *sha = dav_hash_init();
1148     char *buf = malloc(16384);
1149
1150     size_t r;
1151     while((r = fread(buf, 1, 16384, in)) > 0) {
1152         dav_hash_update(sha, buf, r);
1153     }
1154
1155     unsigned char hash[DAV_SHA256_DIGEST_LENGTH];
1156     dav_hash_final(sha, hash);
1157     free(buf);
1158     fclose(in);
1159
1160     return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
1161 }