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