src/buffer.c

   1 #include "first.h"
   2
   3 #include "buffer.h"
   4
   5 #include <stdlib.h>
   6 #include <string.h>
   7
   8 static const char hex_chars[] = "0123456789abcdef";
   9
  10 /**
  11  * init the buffer
  12  *
  13  */
  14
  15 buffer* buffer_init(void) {
  16         buffer *b;
  17
  18         b = malloc(sizeof(*b));
  19         force_assert(b);
  20
  21         b->ptr = NULL;
  22         b->size = 0;
  23         b->used = 0;
  24
  25         return b;
  26 }
  27
  28 buffer *buffer_init_buffer(const buffer *src) {
  29         buffer *b = buffer_init();
  30         buffer_copy_buffer(b, src);
  31         return b;
  32 }
  33
  34 buffer *buffer_init_string(const char *str) {
  35         buffer *b = buffer_init();
  36         buffer_copy_string(b, str);
  37         return b;
  38 }
  39
  40 void buffer_free(buffer *b) {
  41         if (NULL == b) return;
  42
  43         free(b->ptr);
  44         free(b);
  45 }
  46
  47 void buffer_reset(buffer *b) {
  48         if (NULL == b) return;
  49
  50         /* limit don't reuse buffer larger than ... bytes */
  51         if (b->size > BUFFER_MAX_REUSE_SIZE) {
  52                 free(b->ptr);
  53                 b->ptr = NULL;
  54                 b->size = 0;
  55         } else if (b->size > 0) {
  56                 b->ptr[0] = '\0';
  57         }
  58
  59         b->used = 0;
  60 }
  61
  62 void buffer_move(buffer *b, buffer *src) {
  63         buffer tmp;
  64
  65         if (NULL == b) {
  66                 buffer_reset(src);
  67                 return;
  68         }
  69         buffer_reset(b);
  70         if (NULL == src) return;
  71
  72         tmp = *src; *src = *b; *b = tmp;
  73 }
  74
  75 #define BUFFER_PIECE_SIZE 64
  76 static size_t buffer_align_size(size_t size) {
  77         size_t align = BUFFER_PIECE_SIZE - (size % BUFFER_PIECE_SIZE);
  78         /* overflow on unsinged size_t is defined to wrap around */
  79         if (size + align < size) return size;
  80         return size + align;
  81 }
  82
  83 /* make sure buffer is at least "size" big. discard old data */
  84 static void buffer_alloc(buffer *b, size_t size) {
  85         force_assert(NULL != b);
  86         if (0 == size) size = 1;
  87
  88         if (size <= b->size) return;
  89
  90         if (NULL != b->ptr) free(b->ptr);
  91
  92         b->used = 0;
  93         b->size = buffer_align_size(size);
  94         b->ptr = malloc(b->size);
  95
  96         force_assert(NULL != b->ptr);
  97 }
  98
  99 /* make sure buffer is at least "size" big. keep old data */
 100 static void buffer_realloc(buffer *b, size_t size) {
 101         force_assert(NULL != b);
 102         if (0 == size) size = 1;
 103
 104         if (size <= b->size) return;
 105
 106         b->size = buffer_align_size(size);
 107         b->ptr = realloc(b->ptr, b->size);
 108
 109         force_assert(NULL != b->ptr);
 110 }
 111
 112
 113 char* buffer_string_prepare_copy(buffer *b, size_t size) {
 114         force_assert(NULL != b);
 115         force_assert(size + 1 > size);
 116
 117         buffer_alloc(b, size + 1);
 118
 119         b->used = 1;
 120         b->ptr[0] = '\0';
 121
 122         return b->ptr;
 123 }
 124
 125 char* buffer_string_prepare_append(buffer *b, size_t size) {
 126         force_assert(NULL !=  b);
 127
 128         if (buffer_string_is_empty(b)) {
 129                 return buffer_string_prepare_copy(b, size);
 130         } else {
 131                 size_t req_size = b->used + size;
 132
 133                 /* not empty, b->used already includes a terminating 0 */
 134                 force_assert(req_size >= b->used);
 135
 136                 /* check for overflow: unsigned overflow is defined to wrap around */
 137                 force_assert(req_size >= b->used);
 138
 139                 buffer_realloc(b, req_size);
 140
 141                 return b->ptr + b->used - 1;
 142         }
 143 }
 144
 145 void buffer_string_set_length(buffer *b, size_t len) {
 146         force_assert(NULL != b);
 147         force_assert(len + 1 > len);
 148
 149         buffer_realloc(b, len + 1);
 150
 151         b->used = len + 1;
 152         b->ptr[len] = '\0';
 153 }
 154
 155 void buffer_commit(buffer *b, size_t size)
 156 {
 157         force_assert(NULL != b);
 158         force_assert(b->size > 0);
 159
 160         if (0 == b->used) b->used = 1;
 161
 162         if (size > 0) {
 163                 /* check for overflow: unsigned overflow is defined to wrap around */
 164                 force_assert(b->used + size > b->used);
 165
 166                 force_assert(b->used + size <= b->size);
 167                 b->used += size;
 168         }
 169
 170         b->ptr[b->used - 1] = '\0';
 171 }
 172
 173 void buffer_copy_string(buffer *b, const char *s) {
 174         buffer_copy_string_len(b, s, NULL != s ? strlen(s) : 0);
 175 }
 176
 177 void buffer_copy_string_len(buffer *b, const char *s, size_t s_len) {
 178         force_assert(NULL != b);
 179         force_assert(NULL != s || s_len == 0);
 180
 181         buffer_string_prepare_copy(b, s_len);
 182
 183         if (0 != s_len) memcpy(b->ptr, s, s_len);
 184
 185         buffer_commit(b, s_len);
 186 }
 187
 188 void buffer_copy_buffer(buffer *b, const buffer *src) {
 189         if (NULL == src || 0 == src->used) {
 190                 buffer_string_prepare_copy(b, 0);
 191                 b->used = 0; /* keep special empty state for now */
 192         } else {
 193                 buffer_copy_string_len(b, src->ptr, buffer_string_length(src));
 194         }
 195 }
 196
 197 void buffer_append_string(buffer *b, const char *s) {
 198         buffer_append_string_len(b, s, NULL != s ? strlen(s) : 0);
 199 }
 200
 201 /**
 202  * append a string to the end of the buffer
 203  *
 204  * the resulting buffer is terminated with a '\0'
 205  * s is treated as a un-terminated string (a \0 is handled a normal character)
 206  *
 207  * @param b a buffer
 208  * @param s the string
 209  * @param s_len size of the string (without the terminating \0)
 210  */
 211
 212 void buffer_append_string_len(buffer *b, const char *s, size_t s_len) {
 213         char *target_buf;
 214
 215         force_assert(NULL != b);
 216         force_assert(NULL != s || s_len == 0);
 217
 218         target_buf = buffer_string_prepare_append(b, s_len);
 219
 220         if (0 == s_len) return; /* nothing to append */
 221
 222         memcpy(target_buf, s, s_len);
 223
 224         buffer_commit(b, s_len);
 225 }
 226
 227 void buffer_append_string_buffer(buffer *b, const buffer *src) {
 228         if (NULL == src) {
 229                 buffer_append_string_len(b, NULL, 0);
 230         } else {
 231                 buffer_append_string_len(b, src->ptr, buffer_string_length(src));
 232         }
 233 }
 234
 235 void buffer_append_uint_hex(buffer *b, uintmax_t value) {
 236         char *buf;
 237         unsigned int shift = 0;
 238
 239         {
 240                 uintmax_t copy = value;
 241                 do {
 242                         copy >>= 8;
 243                         shift += 8; /* counting bits */
 244                 } while (0 != copy);
 245         }
 246
 247         buf = buffer_string_prepare_append(b, shift >> 2); /*nibbles (4 bits)*/
 248         buffer_commit(b, shift >> 2); /* will fill below */
 249
 250         while (shift > 0) {
 251                 shift -= 4;
 252                 *(buf++) = hex_chars[(value >> shift) & 0x0F];
 253         }
 254 }
 255
 256 static char* utostr(char * const buf_end, uintmax_t val) {
 257         char *cur = buf_end;
 258         do {
 259                 int mod = val % 10;
 260                 val /= 10;
 261                 /* prepend digit mod */
 262                 *(--cur) = (char) ('0' + mod);
 263         } while (0 != val);
 264         return cur;
 265 }
 266
 267 static char* itostr(char * const buf_end, intmax_t val) {
 268         /* absolute value not defined for INTMAX_MIN, but can take absolute
 269          * value of any negative number via twos complement cast to unsigned.
 270          * negative sign is prepended after (now unsigned) value is converted
 271          * to string */
 272         uintmax_t uval = val >= 0 ? (uintmax_t)val : ((uintmax_t)~val) + 1;
 273         char *cur = utostr(buf_end, uval);
 274         if (val < 0) *(--cur) = '-';
 275
 276         return cur;
 277 }
 278
 279 void buffer_append_int(buffer *b, intmax_t val) {
 280         char buf[LI_ITOSTRING_LENGTH];
 281         char* const buf_end = buf + sizeof(buf);
 282         char *str;
 283
 284         force_assert(NULL != b);
 285
 286         str = itostr(buf_end, val);
 287         force_assert(buf_end > str && str >= buf);
 288
 289         buffer_append_string_len(b, str, buf_end - str);
 290 }
 291
 292 void buffer_copy_int(buffer *b, intmax_t val) {
 293         force_assert(NULL != b);
 294
 295         b->used = 0;
 296         buffer_append_int(b, val);
 297 }
 298
 299 void buffer_append_strftime(buffer *b, const char *format, const struct tm *tm) {
 300         size_t r;
 301         char* buf;
 302         force_assert(NULL != b);
 303         force_assert(NULL != tm);
 304
 305         if (NULL == format || '\0' == format[0]) {
 306                 /* empty format */
 307                 buffer_string_prepare_append(b, 0);
 308                 return;
 309         }
 310
 311         buf = buffer_string_prepare_append(b, 255);
 312         r = strftime(buf, buffer_string_space(b), format, tm);
 313
 314         /* 0 (in some apis buffer_string_space(b)) signals the string may have
 315          * been too small; but the format could also just have lead to an empty
 316          * string
 317          */
 318         if (0 == r || r >= buffer_string_space(b)) {
 319                 /* give it a second try with a larger string */
 320                 buf = buffer_string_prepare_append(b, 4095);
 321                 r = strftime(buf, buffer_string_space(b), format, tm);
 322         }
 323
 324         if (r >= buffer_string_space(b)) r = 0;
 325
 326         buffer_commit(b, r);
 327 }
 328
 329
 330 void li_itostrn(char *buf, size_t buf_len, intmax_t val) {
 331         char p_buf[LI_ITOSTRING_LENGTH];
 332         char* const p_buf_end = p_buf + sizeof(p_buf);
 333         char* str = p_buf_end - 1;
 334         *str = '\0';
 335
 336         str = itostr(str, val);
 337         force_assert(p_buf_end > str && str >= p_buf);
 338
 339         force_assert(buf_len >= (size_t) (p_buf_end - str));
 340         memcpy(buf, str, p_buf_end - str);
 341 }
 342
 343 void li_utostrn(char *buf, size_t buf_len, uintmax_t val) {
 344         char p_buf[LI_ITOSTRING_LENGTH];
 345         char* const p_buf_end = p_buf + sizeof(p_buf);
 346         char* str = p_buf_end - 1;
 347         *str = '\0';
 348
 349         str = utostr(str, val);
 350         force_assert(p_buf_end > str && str >= p_buf);
 351
 352         force_assert(buf_len >= (size_t) (p_buf_end - str));
 353         memcpy(buf, str, p_buf_end - str);
 354 }
 355
 356 char int2hex(char c) {
 357         return hex_chars[(c & 0x0F)];
 358 }
 359
 360 /* converts hex char (0-9, A-Z, a-z) to decimal.
 361  * returns 0xFF on invalid input.
 362  */
 363 char hex2int(unsigned char hex) {
 364         unsigned char value = hex - '0';
 365         if (value > 9) {
 366                 hex |= 0x20; /* to lower case */
 367                 value = hex - 'a' + 10;
 368                 if (value < 10) value = 0xff;
 369         }
 370         if (value > 15) value = 0xff;
 371
 372         return value;
 373 }
 374
 375 /**
 376  * check if two buffer contain the same data
 377  *
 378  * HISTORY: this function was pretty much optimized, but didn't handled
 379  * alignment properly.
 380  */
 381
 382 int buffer_is_equal(const buffer *a, const buffer *b) {
 383         force_assert(NULL != a && NULL != b);
 384
 385         if (a->used != b->used) return 0;
 386         if (a->used == 0) return 1;
 387
 388         return (0 == memcmp(a->ptr, b->ptr, a->used));
 389 }
 390
 391 int buffer_is_equal_string(const buffer *a, const char *s, size_t b_len) {
 392         force_assert(NULL != a && NULL != s);
 393         force_assert(b_len + 1 > b_len);
 394
 395         if (a->used != b_len + 1) return 0;
 396         if (0 != memcmp(a->ptr, s, b_len)) return 0;
 397         if ('\0' != a->ptr[a->used-1]) return 0;
 398
 399         return 1;
 400 }
 401
 402 /* buffer_is_equal_caseless_string(b, CONST_STR_LEN("value")) */
 403 int buffer_is_equal_caseless_string(const buffer *a, const char *s, size_t b_len) {
 404         force_assert(NULL != a);
 405         if (a->used != b_len + 1) return 0;
 406         force_assert('\0' == a->ptr[a->used - 1]);
 407
 408         return (0 == strcasecmp(a->ptr, s));
 409 }
 410
 411 int buffer_caseless_compare(const char *a, size_t a_len, const char *b, size_t b_len) {
 412         size_t const len = (a_len < b_len) ? a_len : b_len;
 413         size_t i;
 414
 415         for (i = 0; i < len; ++i) {
 416                 unsigned char ca = a[i], cb = b[i];
 417                 if (ca == cb) continue;
 418
 419                 /* always lowercase for transitive results */
 420                 if (ca >= 'A' && ca <= 'Z') ca |= 32;
 421                 if (cb >= 'A' && cb <= 'Z') cb |= 32;
 422
 423                 if (ca == cb) continue;
 424                 return ((int)ca) - ((int)cb);
 425         }
 426         if (a_len == b_len) return 0;
 427         return a_len < b_len ? -1 : 1;
 428 }
 429
 430 int buffer_is_equal_right_len(const buffer *b1, const buffer *b2, size_t len) {
 431         /* no len -> equal */
 432         if (len == 0) return 1;
 433
 434         /* len > 0, but empty buffers -> not equal */
 435         if (b1->used == 0 || b2->used == 0) return 0;
 436
 437         /* buffers too small -> not equal */
 438         if (b1->used - 1 < len || b2->used - 1 < len) return 0;
 439
 440         return 0 == memcmp(b1->ptr + b1->used - 1 - len, b2->ptr + b2->used - 1 - len, len);
 441 }
 442
 443 void li_tohex(char *buf, size_t buf_len, const char *s, size_t s_len) {
 444         size_t i;
 445         force_assert(2 * s_len > s_len);
 446         force_assert(2 * s_len < buf_len);
 447
 448         for (i = 0; i < s_len; i++) {
 449                 buf[2*i] = hex_chars[(s[i] >> 4) & 0x0F];
 450                 buf[2*i+1] = hex_chars[s[i] & 0x0F];
 451         }
 452         buf[2*s_len] = '\0';
 453 }
 454
 455 void buffer_copy_string_hex(buffer *b, const char *in, size_t in_len) {
 456         /* overflow protection */
 457         force_assert(in_len * 2 > in_len);
 458
 459         buffer_string_set_length(b, 2 * in_len);
 460         li_tohex(b->ptr, buffer_string_length(b)+1, in, in_len);
 461 }
 462
 463
 464 void buffer_substr_replace (buffer * const b, const size_t offset,
 465                             const size_t len, const buffer * const replace)
 466 {
 467     const size_t blen = buffer_string_length(b);
 468     const size_t rlen = buffer_string_length(replace);
 469
 470     if (rlen > len) {
 471         buffer_string_set_length(b, blen-len+rlen);
 472         memmove(b->ptr+offset+rlen, b->ptr+offset+len, blen-offset-len);
 473     }
 474
 475     memcpy(b->ptr+offset, replace->ptr, rlen);
 476
 477     if (rlen < len) {
 478         memmove(b->ptr+offset+rlen, b->ptr+offset+len, blen-offset-len);
 479         buffer_string_set_length(b, blen-len+rlen);
 480     }
 481 }
 482
 483
 484 /* everything except: ! ( ) * - . 0-9 A-Z _ a-z */
 485 static const char encoded_chars_rel_uri_part[] = {
 486         /*
 487         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
 488         */
 489         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  00 -  0F control chars */
 490         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  10 -  1F */
 491         1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1,  /*  20 -  2F space " # $ % & ' + , / */
 492         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,  /*  30 -  3F : ; < = > ? */
 493         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  40 -  4F @ */
 494         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,  /*  50 -  5F [ \ ] ^ */
 495         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  60 -  6F ` */
 496         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1,  /*  70 -  7F { | } DEL */
 497         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  80 -  8F */
 498         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  90 -  9F */
 499         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  A0 -  AF */
 500         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  B0 -  BF */
 501         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  C0 -  CF */
 502         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  D0 -  DF */
 503         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  E0 -  EF */
 504         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  F0 -  FF */
 505 };
 506
 507 /* everything except: ! ( ) * - . / 0-9 A-Z _ a-z */
 508 static const char encoded_chars_rel_uri[] = {
 509         /*
 510         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
 511         */
 512         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  00 -  0F control chars */
 513         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  10 -  1F */
 514         1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0,  /*  20 -  2F space " # $ % & ' + , */
 515         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,  /*  30 -  3F : ; < = > ? */
 516         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  40 -  4F @ */
 517         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,  /*  50 -  5F [ \ ] ^ */
 518         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  60 -  6F ` */
 519         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1,  /*  70 -  7F { | } DEL */
 520         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  80 -  8F */
 521         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  90 -  9F */
 522         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  A0 -  AF */
 523         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  B0 -  BF */
 524         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  C0 -  CF */
 525         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  D0 -  DF */
 526         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  E0 -  EF */
 527         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  F0 -  FF */
 528 };
 529
 530 static const char encoded_chars_html[] = {
 531         /*
 532         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
 533         */
 534         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  00 -  0F control chars */
 535         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  10 -  1F */
 536         0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,  /*  20 -  2F " & ' */
 537         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,  /*  30 -  3F < > */
 538         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  40 -  4F */
 539         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  50 -  5F */
 540         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  60 -  6F ` */
 541         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,  /*  70 -  7F DEL */
 542         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  80 -  8F */
 543         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  90 -  9F */
 544         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  A0 -  AF */
 545         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  B0 -  BF */
 546         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  C0 -  CF */
 547         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  D0 -  DF */
 548         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  E0 -  EF */
 549         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  F0 -  FF */
 550 };
 551
 552 static const char encoded_chars_minimal_xml[] = {
 553         /*
 554         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
 555         */
 556         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  00 -  0F control chars */
 557         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  10 -  1F */
 558         0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,  /*  20 -  2F " & ' */
 559         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,  /*  30 -  3F < > */
 560         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  40 -  4F */
 561         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  50 -  5F */
 562         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  60 -  6F ` */
 563         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,  /*  70 -  7F DEL */
 564         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  80 -  8F */
 565         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  90 -  9F */
 566         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  A0 -  AF */
 567         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  B0 -  BF */
 568         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  C0 -  CF */
 569         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  D0 -  DF */
 570         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  E0 -  EF */
 571         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  F0 -  FF */
 572 };
 573
 574 static const char encoded_chars_hex[] = {
 575         /*
 576         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
 577         */
 578         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  00 -  0F control chars */
 579         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  10 -  1F */
 580         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  20 -  2F */
 581         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  30 -  3F */
 582         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  40 -  4F */
 583         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  50 -  5F */
 584         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  60 -  6F */
 585         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  70 -  7F */
 586         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  80 -  8F */
 587         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  90 -  9F */
 588         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  A0 -  AF */
 589         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  B0 -  BF */
 590         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  C0 -  CF */
 591         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  D0 -  DF */
 592         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  E0 -  EF */
 593         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /*  F0 -  FF */
 594 };
 595
 596 static const char encoded_chars_http_header[] = {
 597         /*
 598         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
 599         */
 600         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,  /*  00 -  0F */
 601         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  10 -  1F */
 602         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  20 -  2F */
 603         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  30 -  3F */
 604         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  40 -  4F */
 605         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  50 -  5F */
 606         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  60 -  6F */
 607         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  70 -  7F */
 608         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  80 -  8F */
 609         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  90 -  9F */
 610         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  A0 -  AF */
 611         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  B0 -  BF */
 612         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  C0 -  CF */
 613         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  D0 -  DF */
 614         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  E0 -  EF */
 615         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /*  F0 -  FF */
 616 };
 617
 618
 619
 620 void buffer_append_string_encoded(buffer *b, const char *s, size_t s_len, buffer_encoding_t encoding) {
 621         unsigned char *ds, *d;
 622         size_t d_len, ndx;
 623         const char *map = NULL;
 624
 625         force_assert(NULL != b);
 626         force_assert(NULL != s || 0 == s_len);
 627
 628         if (0 == s_len) return;
 629
 630         switch(encoding) {
 631         case ENCODING_REL_URI:
 632                 map = encoded_chars_rel_uri;
 633                 break;
 634         case ENCODING_REL_URI_PART:
 635                 map = encoded_chars_rel_uri_part;
 636                 break;
 637         case ENCODING_HTML:
 638                 map = encoded_chars_html;
 639                 break;
 640         case ENCODING_MINIMAL_XML:
 641                 map = encoded_chars_minimal_xml;
 642                 break;
 643         case ENCODING_HEX:
 644                 map = encoded_chars_hex;
 645                 break;
 646         case ENCODING_HTTP_HEADER:
 647                 map = encoded_chars_http_header;
 648                 break;
 649         }
 650
 651         force_assert(NULL != map);
 652
 653         /* count to-be-encoded-characters */
 654         for (ds = (unsigned char *)s, d_len = 0, ndx = 0; ndx < s_len; ds++, ndx++) {
 655                 if (map[*ds]) {
 656                         switch(encoding) {
 657                         case ENCODING_REL_URI:
 658                         case ENCODING_REL_URI_PART:
 659                                 d_len += 3;
 660                                 break;
 661                         case ENCODING_HTML:
 662                         case ENCODING_MINIMAL_XML:
 663                                 d_len += 6;
 664                                 break;
 665                         case ENCODING_HTTP_HEADER:
 666                         case ENCODING_HEX:
 667                                 d_len += 2;
 668                                 break;
 669                         }
 670                 } else {
 671                         d_len++;
 672                 }
 673         }
 674
 675         d = (unsigned char*) buffer_string_prepare_append(b, d_len);
 676         buffer_commit(b, d_len); /* fill below */
 677         force_assert('\0' == *d);
 678
 679         for (ds = (unsigned char *)s, d_len = 0, ndx = 0; ndx < s_len; ds++, ndx++) {
 680                 if (map[*ds]) {
 681                         switch(encoding) {
 682                         case ENCODING_REL_URI:
 683                         case ENCODING_REL_URI_PART:
 684                                 d[d_len++] = '%';
 685                                 d[d_len++] = hex_chars[((*ds) >> 4) & 0x0F];
 686                                 d[d_len++] = hex_chars[(*ds) & 0x0F];
 687                                 break;
 688                         case ENCODING_HTML:
 689                         case ENCODING_MINIMAL_XML:
 690                                 d[d_len++] = '&';
 691                                 d[d_len++] = '#';
 692                                 d[d_len++] = 'x';
 693                                 d[d_len++] = hex_chars[((*ds) >> 4) & 0x0F];
 694                                 d[d_len++] = hex_chars[(*ds) & 0x0F];
 695                                 d[d_len++] = ';';
 696                                 break;
 697                         case ENCODING_HEX:
 698                                 d[d_len++] = hex_chars[((*ds) >> 4) & 0x0F];
 699                                 d[d_len++] = hex_chars[(*ds) & 0x0F];
 700                                 break;
 701                         case ENCODING_HTTP_HEADER:
 702                                 d[d_len++] = *ds;
 703                                 d[d_len++] = '\t';
 704                                 break;
 705                         }
 706                 } else {
 707                         d[d_len++] = *ds;
 708                 }
 709         }
 710 }
 711
 712 void buffer_append_string_c_escaped(buffer *b, const char *s, size_t s_len) {
 713         unsigned char *ds, *d;
 714         size_t d_len, ndx;
 715
 716         force_assert(NULL != b);
 717         force_assert(NULL != s || 0 == s_len);
 718
 719         if (0 == s_len) return;
 720
 721         /* count to-be-encoded-characters */
 722         for (ds = (unsigned char *)s, d_len = 0, ndx = 0; ndx < s_len; ds++, ndx++) {
 723                 if ((*ds < 0x20) /* control character */
 724                                 || (*ds >= 0x7f)) { /* DEL + non-ASCII characters */
 725                         switch (*ds) {
 726                         case '\t':
 727                         case '\r':
 728                         case '\n':
 729                                 d_len += 2;
 730                                 break;
 731                         default:
 732                                 d_len += 4; /* \xCC */
 733                                 break;
 734                         }
 735                 } else {
 736                         d_len++;
 737                 }
 738         }
 739
 740         d = (unsigned char*) buffer_string_prepare_append(b, d_len);
 741         buffer_commit(b, d_len); /* fill below */
 742         force_assert('\0' == *d);
 743
 744         for (ds = (unsigned char *)s, d_len = 0, ndx = 0; ndx < s_len; ds++, ndx++) {
 745                 if ((*ds < 0x20) /* control character */
 746                                 || (*ds >= 0x7f)) { /* DEL + non-ASCII characters */
 747                         d[d_len++] = '\\';
 748                         switch (*ds) {
 749                         case '\t':
 750                                 d[d_len++] = 't';
 751                                 break;
 752                         case '\r':
 753                                 d[d_len++] = 'r';
 754                                 break;
 755                         case '\n':
 756                                 d[d_len++] = 'n';
 757                                 break;
 758                         default:
 759                                 d[d_len++] = 'x';
 760                                 d[d_len++] = hex_chars[((*ds) >> 4) & 0x0F];
 761                                 d[d_len++] = hex_chars[(*ds) & 0x0F];
 762                                 break;
 763                         }
 764                 } else {
 765                         d[d_len++] = *ds;
 766                 }
 767         }
 768 }
 769
 770
 771 void buffer_copy_string_encoded_cgi_varnames(buffer *b, const char *s, size_t s_len, int is_http_header) {
 772         size_t i, j;
 773
 774         force_assert(NULL != b);
 775         force_assert(NULL != s || 0 == s_len);
 776
 777         buffer_reset(b);
 778
 779         if (is_http_header && NULL != s && 0 != strcasecmp(s, "CONTENT-TYPE")) {
 780                 buffer_string_prepare_append(b, s_len + 5);
 781                 buffer_copy_string_len(b, CONST_STR_LEN("HTTP_"));
 782         } else {
 783                 buffer_string_prepare_append(b, s_len);
 784         }
 785
 786         j = buffer_string_length(b);
 787         for (i = 0; i < s_len; ++i) {
 788                 unsigned char cr = s[i];
 789                 if (light_isalpha(cr)) {
 790                         /* upper-case */
 791                         cr &= ~32;
 792                 } else if (!light_isdigit(cr)) {
 793                         cr = '_';
 794                 }
 795                 b->ptr[j++] = cr;
 796         }
 797         b->used = j;
 798         b->ptr[b->used++] = '\0';
 799 }
 800
 801 /* decodes url-special-chars inplace.
 802  * replaces non-printable characters with '_'
 803  */
 804
 805 static void buffer_urldecode_internal(buffer *url, int is_query) {
 806         unsigned char high, low;
 807         char *src;
 808         char *dst;
 809
 810         force_assert(NULL != url);
 811         if (buffer_string_is_empty(url)) return;
 812
 813         force_assert('\0' == url->ptr[url->used-1]);
 814
 815         src = (char*) url->ptr;
 816
 817         while ('\0' != *src) {
 818                 if ('%' == *src) break;
 819                 if (is_query && '+' == *src) *src = ' ';
 820                 src++;
 821         }
 822         dst = src;
 823
 824         while ('\0' != *src) {
 825                 if (is_query && *src == '+') {
 826                         *dst = ' ';
 827                 } else if (*src == '%') {
 828                         *dst = '%';
 829
 830                         high = hex2int(*(src + 1));
 831                         if (0xFF != high) {
 832                                 low = hex2int(*(src + 2));
 833                                 if (0xFF != low) {
 834                                         high = (high << 4) | low;
 835
 836                                         /* map control-characters out */
 837                                         if (high < 32 || high == 127) high = '_';
 838
 839                                         *dst = high;
 840                                         src += 2;
 841                                 }
 842                         }
 843                 } else {
 844                         *dst = *src;
 845                 }
 846
 847                 dst++;
 848                 src++;
 849         }
 850
 851         *dst = '\0';
 852         url->used = (dst - url->ptr) + 1;
 853 }
 854
 855 void buffer_urldecode_path(buffer *url) {
 856         buffer_urldecode_internal(url, 0);
 857 }
 858
 859 void buffer_urldecode_query(buffer *url) {
 860         buffer_urldecode_internal(url, 1);
 861 }
 862
 863 /* - special case: empty string returns empty string
 864  * - on windows or cygwin: replace \ with /
 865  * - strip leading spaces
 866  * - prepends "/" if not present already
 867  * - resolve "/../", "//" and "/./" the usual way:
 868  *   the first one removes a preceding component, the other two
 869  *   get compressed to "/".
 870  * - "/." and "/.." at the end are similar, but always leave a trailing
 871  *   "/"
 872  *
 873  * /blah/..         gets  /
 874  * /blah/../foo     gets  /foo
 875  * /abc/./xyz       gets  /abc/xyz
 876  * /abc//xyz        gets  /abc/xyz
 877  *
 878  * NOTE: src and dest can point to the same buffer, in which case,
 879  *       the operation is performed in-place.
 880  */
 881
 882 void buffer_path_simplify(buffer *dest, buffer *src)
 883 {
 884         /* current character, the one before, and the one before that from input */
 885         char c, pre1, pre2;
 886         char *start, *slash, *walk, *out;
 887
 888         force_assert(NULL != dest && NULL != src);
 889
 890         if (buffer_string_is_empty(src)) {
 891                 buffer_string_prepare_copy(dest, 0);
 892                 return;
 893         }
 894
 895         force_assert('\0' == src->ptr[src->used-1]);
 896
 897         /* might need one character more for the '/' prefix */
 898         if (src == dest) {
 899                 buffer_string_prepare_append(dest, 1);
 900         } else {
 901                 buffer_string_prepare_copy(dest, buffer_string_length(src) + 1);
 902         }
 903
 904 #if defined(__WIN32) || defined(__CYGWIN__)
 905         /* cygwin is treating \ and / the same, so we have to that too */
 906         {
 907                 char *p;
 908                 for (p = src->ptr; *p; p++) {
 909                         if (*p == '\\') *p = '/';
 910                 }
 911         }
 912 #endif
 913
 914         walk  = src->ptr;
 915         start = dest->ptr;
 916         out   = dest->ptr;
 917         slash = dest->ptr;
 918
 919         /* skip leading spaces */
 920         while (*walk == ' ') {
 921                 walk++;
 922         }
 923
 924         pre1 = 0;
 925         c = *(walk++);
 926         /* prefix with '/' if not already present */
 927         if (c != '/') {
 928                 pre1 = '/';
 929                 *(out++) = '/';
 930         }
 931
 932         while (c != '\0') {
 933                 /* assert((src != dest || out <= walk) && slash <= out); */
 934                 /* the following comments about out and walk are only interesting if
 935                  * src == dest; otherwise the memory areas don't overlap anyway.
 936                  */
 937                 pre2 = pre1;
 938                 pre1 = c;
 939
 940                 /* possibly: out == walk - need to read first */
 941                 c    = *walk;
 942                 *out = pre1;
 943
 944                 out++;
 945                 walk++;
 946                 /* (out <= walk) still true; also now (slash < out) */
 947
 948                 if (c == '/' || c == '\0') {
 949                         const size_t toklen = out - slash;
 950                         if (toklen == 3 && pre2 == '.' && pre1 == '.') {
 951                                 /* "/../" or ("/.." at end of string) */
 952                                 out = slash;
 953                                 /* if there is something before "/..", there is at least one
 954                                  * component, which needs to be removed */
 955                                 if (out > start) {
 956                                         out--;
 957                                         while (out > start && *out != '/') out--;
 958                                 }
 959
 960                                 /* don't kill trailing '/' at end of path */
 961                                 if (c == '\0') out++;
 962                                 /* slash < out before, so out_new <= slash + 1 <= out_before <= walk */
 963                         } else if (toklen == 1 || (pre2 == '/' && pre1 == '.')) {
 964                                 /* "//" or "/./" or (("/" or "/.") at end of string) */
 965                                 out = slash;
 966                                 /* don't kill trailing '/' at end of path */
 967                                 if (c == '\0') out++;
 968                                 /* slash < out before, so out_new <= slash + 1 <= out_before <= walk */
 969                         }
 970
 971                         slash = out;
 972                 }
 973         }
 974
 975         buffer_string_set_length(dest, out - start);
 976 }
 977
 978 int light_isdigit(int c) {
 979         return (c >= '0' && c <= '9');
 980 }
 981
 982 int light_isxdigit(int c) {
 983         if (light_isdigit(c)) return 1;
 984
 985         c |= 32;
 986         return (c >= 'a' && c <= 'f');
 987 }
 988
 989 int light_isalpha(int c) {
 990         c |= 32;
 991         return (c >= 'a' && c <= 'z');
 992 }
 993
 994 int light_isalnum(int c) {
 995         return light_isdigit(c) || light_isalpha(c);
 996 }
 997
 998 void buffer_to_lower(buffer *b) {
 999         size_t i;
1000
1001         for (i = 0; i < b->used; ++i) {
1002                 char c = b->ptr[i];
1003                 if (c >= 'A' && c <= 'Z') b->ptr[i] |= 0x20;
1004         }
1005 }
1006
1007
1008 void buffer_to_upper(buffer *b) {
1009         size_t i;
1010
1011         for (i = 0; i < b->used; ++i) {
1012                 char c = b->ptr[i];
1013                 if (c >= 'A' && c <= 'Z') b->ptr[i] &= ~0x20;
1014         }
1015 }
1016
1017
1018 #include <stdio.h>
1019
1020 #ifdef HAVE_LIBUNWIND
1021 # define UNW_LOCAL_ONLY
1022 # include <libunwind.h>
1023
1024 static void print_backtrace(FILE *file) {
1025         unw_cursor_t cursor;
1026         unw_context_t context;
1027         int ret;
1028         unsigned int frame = 0;
1029
1030         if (0 != (ret = unw_getcontext(&context))) goto error;
1031         if (0 != (ret = unw_init_local(&cursor, &context))) goto error;
1032
1033         fprintf(file, "Backtrace:\n");
1034
1035         while (0 < (ret = unw_step(&cursor))) {
1036                 unw_word_t proc_ip = 0;
1037                 unw_proc_info_t procinfo;
1038                 char procname[256];
1039                 unw_word_t proc_offset = 0;
1040
1041                 if (0 != (ret = unw_get_reg(&cursor, UNW_REG_IP, &proc_ip))) goto error;
1042
1043                 if (0 == proc_ip) {
1044                         /* without an IP the other functions are useless; unw_get_proc_name would return UNW_EUNSPEC */
1045                         ++frame;
1046                         fprintf(file, "%u: (nil)\n", frame);
1047                         continue;
1048                 }
1049
1050                 if (0 != (ret = unw_get_proc_info(&cursor, &procinfo))) goto error;
1051
1052                 if (0 != (ret = unw_get_proc_name(&cursor, procname, sizeof(procname), &proc_offset))) {
1053                         switch (-ret) {
1054                         case UNW_ENOMEM:
1055                                 memset(procname + sizeof(procname) - 4, '.', 3);
1056                                 procname[sizeof(procname) - 1] = '\0';
1057                                 break;
1058                         case UNW_ENOINFO:
1059                                 procname[0] = '?';
1060                                 procname[1] = '\0';
1061                                 proc_offset = 0;
1062                                 break;
1063                         default:
1064                                 snprintf(procname, sizeof(procname), "?? (unw_get_proc_name error %d)", -ret);
1065                                 break;
1066                         }
1067                 }
1068
1069                 ++frame;
1070                 fprintf(file, "%u: %s (+0x%x) [%p]\n",
1071                         frame,
1072                         procname,
1073                         (unsigned int) proc_offset,
1074                         (void*)(uintptr_t)proc_ip);
1075         }
1076
1077         if (0 != ret) goto error;
1078
1079         return;
1080
1081 error:
1082         fprintf(file, "Error while generating backtrace: unwind error %i\n", (int) -ret);
1083 }
1084 #else
1085 static void print_backtrace(FILE *file) {
1086         UNUSED(file);
1087 }
1088 #endif
1089
1090 void log_failed_assert(const char *filename, unsigned int line, const char *msg) {
1091         /* can't use buffer here; could lead to recursive assertions */
1092         fprintf(stderr, "%s.%u: %s\n", filename, line, msg);
1093         print_backtrace(stderr);
1094         fflush(stderr);
1095         abort();
1096 }