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