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 int buffer_is_equal_right_len(const buffer *b1, const buffer *b2, size_t len) { 376 /* no len -> equal */ 377 if (len == 0) return 1; 378 379 /* len > 0, but empty buffers -> not equal */ 380 if (b1->used == 0 || b2->used == 0) return 0; 381 382 /* buffers too small -> not equal */ 383 if (b1->used - 1 < len || b2->used - 1 < len) return 0; 384 385 return 0 == memcmp(b1->ptr + b1->used - 1 - len, b2->ptr + b2->used - 1 - len, len); 386 } 387 388 389 void li_tohex_lc(char * const restrict buf, size_t buf_len, const char * const restrict s, size_t s_len) { 390 force_assert(2 * s_len > s_len); 391 force_assert(2 * s_len < buf_len); 392 393 for (size_t i = 0; i < s_len; ++i) { 394 buf[2*i] = hex_chars_lc[(s[i] >> 4) & 0x0F]; 395 buf[2*i+1] = hex_chars_lc[s[i] & 0x0F]; 396 } 397 buf[2*s_len] = '\0'; 398 } 399 400 void li_tohex_uc(char * const restrict buf, size_t buf_len, const char * const restrict s, size_t s_len) { 401 force_assert(2 * s_len > s_len); 402 force_assert(2 * s_len < buf_len); 403 404 for (size_t i = 0; i < s_len; ++i) { 405 buf[2*i] = hex_chars_uc[(s[i] >> 4) & 0x0F]; 406 buf[2*i+1] = hex_chars_uc[s[i] & 0x0F]; 407 } 408 buf[2*s_len] = '\0'; 409 } 410 411 412 void buffer_substr_replace (buffer * const restrict b, const size_t offset, 413 const size_t len, const buffer * const restrict replace) 414 { 415 const size_t blen = buffer_string_length(b); 416 const size_t rlen = buffer_string_length(replace); 417 418 if (rlen > len) { 419 buffer_string_set_length(b, blen-len+rlen); 420 memmove(b->ptr+offset+rlen, b->ptr+offset+len, blen-offset-len); 421 } 422 423 memcpy(b->ptr+offset, replace->ptr, rlen); 424 425 if (rlen < len) { 426 memmove(b->ptr+offset+rlen, b->ptr+offset+len, blen-offset-len); 427 buffer_string_set_length(b, blen-len+rlen); 428 } 429 } 430 431 432 void buffer_append_string_encoded_hex_lc(buffer * const restrict b, const char * const restrict s, size_t len) { 433 unsigned char * const p = 434 (unsigned char*) buffer_string_prepare_append(b, len*2); 435 buffer_commit(b, len*2); /* fill below */ 436 for (size_t i = 0; i < len; ++i) { 437 p[(i<<1)] = hex_chars_lc[(s[i] >> 4) & 0x0F]; 438 p[(i<<1)+1] = hex_chars_lc[(s[i]) & 0x0F]; 439 } 440 } 441 442 void buffer_append_string_encoded_hex_uc(buffer * const restrict b, const char * const restrict s, size_t len) { 443 unsigned char * const p = 444 (unsigned char*) buffer_string_prepare_append(b, len*2); 445 buffer_commit(b, len*2); /* fill below */ 446 for (size_t i = 0; i < len; ++i) { 447 p[(i<<1)] = hex_chars_uc[(s[i] >> 4) & 0x0F]; 448 p[(i<<1)+1] = hex_chars_uc[(s[i]) & 0x0F]; 449 } 450 } 451 452 453 /* everything except: ! ( ) * - . 0-9 A-Z _ a-z */ 454 static const char encoded_chars_rel_uri_part[] = { 455 /* 456 0 1 2 3 4 5 6 7 8 9 A B C D E F 457 */ 458 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */ 459 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */ 460 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, /* 20 - 2F space " # $ % & ' + , / */ 461 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, /* 30 - 3F : ; < = > ? */ 462 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F @ */ 463 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, /* 50 - 5F [ \ ] ^ */ 464 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F ` */ 465 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* 70 - 7F { | } DEL */ 466 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 8F */ 467 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 90 - 9F */ 468 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* A0 - AF */ 469 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* B0 - BF */ 470 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* C0 - CF */ 471 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* D0 - DF */ 472 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* E0 - EF */ 473 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* F0 - FF */ 474 }; 475 476 /* everything except: ! ( ) * - . / 0-9 A-Z _ a-z */ 477 static const char encoded_chars_rel_uri[] = { 478 /* 479 0 1 2 3 4 5 6 7 8 9 A B C D E F 480 */ 481 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */ 482 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */ 483 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, /* 20 - 2F space " # $ % & ' + , */ 484 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, /* 30 - 3F : ; < = > ? */ 485 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F @ */ 486 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, /* 50 - 5F [ \ ] ^ */ 487 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F ` */ 488 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* 70 - 7F { | } DEL */ 489 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 8F */ 490 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 90 - 9F */ 491 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* A0 - AF */ 492 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* B0 - BF */ 493 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* C0 - CF */ 494 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* D0 - DF */ 495 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* E0 - EF */ 496 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* F0 - FF */ 497 }; 498 499 static const char encoded_chars_html[] = { 500 /* 501 0 1 2 3 4 5 6 7 8 9 A B C D E F 502 */ 503 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */ 504 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */ 505 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, /* 20 - 2F " & ' */ 506 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, /* 30 - 3F < > */ 507 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F */ 508 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 50 - 5F */ 509 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F ` */ 510 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 70 - 7F DEL */ 511 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 8F */ 512 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 90 - 9F */ 513 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* A0 - AF */ 514 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* B0 - BF */ 515 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* C0 - CF */ 516 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* D0 - DF */ 517 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* E0 - EF */ 518 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* F0 - FF */ 519 }; 520 521 static const char encoded_chars_minimal_xml[] = { 522 /* 523 0 1 2 3 4 5 6 7 8 9 A B C D E F 524 */ 525 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */ 526 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */ 527 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, /* 20 - 2F " & ' */ 528 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, /* 30 - 3F < > */ 529 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F */ 530 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 50 - 5F */ 531 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F ` */ 532 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 70 - 7F DEL */ 533 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */ 534 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */ 535 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */ 536 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */ 537 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */ 538 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */ 539 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */ 540 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */ 541 }; 542 543 544 545 void buffer_append_string_encoded(buffer * const restrict b, const char * const restrict s, size_t s_len, buffer_encoding_t encoding) { 546 unsigned char *ds, *d; 547 size_t d_len, ndx; 548 const char *map = NULL; 549 550 if (0 == s_len) return; 551 552 force_assert(NULL != s); 553 554 switch(encoding) { 555 case ENCODING_REL_URI: 556 map = encoded_chars_rel_uri; 557 break; 558 case ENCODING_REL_URI_PART: 559 map = encoded_chars_rel_uri_part; 560 break; 561 case ENCODING_HTML: 562 map = encoded_chars_html; 563 break; 564 case ENCODING_MINIMAL_XML: 565 map = encoded_chars_minimal_xml; 566 break; 567 } 568 569 force_assert(NULL != map); 570 571 /* count to-be-encoded-characters */ 572 for (ds = (unsigned char *)s, d_len = 0, ndx = 0; ndx < s_len; ds++, ndx++) { 573 if (map[*ds & 0xFF]) { 574 switch(encoding) { 575 case ENCODING_REL_URI: 576 case ENCODING_REL_URI_PART: 577 d_len += 3; 578 break; 579 case ENCODING_HTML: 580 case ENCODING_MINIMAL_XML: 581 d_len += 6; 582 break; 583 } 584 } else { 585 d_len++; 586 } 587 } 588 589 d = (unsigned char*) buffer_string_prepare_append(b, d_len); 590 buffer_commit(b, d_len); /* fill below */ 591 592 for (ds = (unsigned char *)s, d_len = 0, ndx = 0; ndx < s_len; ds++, ndx++) { 593 if (map[*ds & 0xFF]) { 594 switch(encoding) { 595 case ENCODING_REL_URI: 596 case ENCODING_REL_URI_PART: 597 d[d_len++] = '%'; 598 d[d_len++] = hex_chars_uc[((*ds) >> 4) & 0x0F]; 599 d[d_len++] = hex_chars_uc[(*ds) & 0x0F]; 600 break; 601 case ENCODING_HTML: 602 case ENCODING_MINIMAL_XML: 603 d[d_len++] = '&'; 604 d[d_len++] = '#'; 605 d[d_len++] = 'x'; 606 d[d_len++] = hex_chars_uc[((*ds) >> 4) & 0x0F]; 607 d[d_len++] = hex_chars_uc[(*ds) & 0x0F]; 608 d[d_len++] = ';'; 609 break; 610 } 611 } else { 612 d[d_len++] = *ds; 613 } 614 } 615 } 616 617 void buffer_append_string_c_escaped(buffer * const restrict b, const char * const restrict s, size_t s_len) { 618 unsigned char *ds, *d; 619 size_t d_len, ndx; 620 621 if (0 == s_len) return; 622 623 force_assert(NULL != s); 624 625 /* count to-be-encoded-characters */ 626 for (ds = (unsigned char *)s, d_len = 0, ndx = 0; ndx < s_len; ds++, ndx++) { 627 if ((*ds < 0x20) /* control character */ 628 || (*ds >= 0x7f)) { /* DEL + non-ASCII characters */ 629 switch (*ds) { 630 case '\t': 631 case '\r': 632 case '\n': 633 d_len += 2; 634 break; 635 default: 636 d_len += 4; /* \xCC */ 637 break; 638 } 639 } else { 640 d_len++; 641 } 642 } 643 644 d = (unsigned char*) buffer_string_prepare_append(b, d_len); 645 buffer_commit(b, d_len); /* fill below */ 646 647 for (ds = (unsigned char *)s, d_len = 0, ndx = 0; ndx < s_len; ds++, ndx++) { 648 if ((*ds < 0x20) /* control character */ 649 || (*ds >= 0x7f)) { /* DEL + non-ASCII characters */ 650 d[d_len++] = '\\'; 651 switch (*ds) { 652 case '\t': 653 d[d_len++] = 't'; 654 break; 655 case '\r': 656 d[d_len++] = 'r'; 657 break; 658 case '\n': 659 d[d_len++] = 'n'; 660 break; 661 default: 662 d[d_len++] = 'x'; 663 d[d_len++] = hex_chars_lc[((*ds) >> 4) & 0x0F]; 664 d[d_len++] = hex_chars_lc[(*ds) & 0x0F]; 665 break; 666 } 667 } else { 668 d[d_len++] = *ds; 669 } 670 } 671 } 672 673 674 void buffer_copy_string_encoded_cgi_varnames(buffer * const restrict b, const char * const restrict s, size_t s_len, int is_http_header) { 675 size_t i, j = 0; 676 677 force_assert(NULL != b); 678 force_assert(NULL != s || 0 == s_len); 679 680 buffer_string_prepare_copy(b, s_len + 5); 681 682 if (is_http_header) { 683 if (s_len == 12 && buffer_eq_icase_ssn(s, "Content-Type", 12)) { 684 buffer_copy_string_len(b, CONST_STR_LEN("CONTENT_TYPE")); 685 return; 686 } 687 buffer_copy_string_len(b, CONST_STR_LEN("HTTP_")); 688 j = 5; /* "HTTP_" */ 689 } 690 691 for (i = 0; i < s_len; ++i) { 692 unsigned char cr = s[i]; 693 if (light_isalpha(cr)) { 694 /* upper-case */ 695 cr &= ~32; 696 } else if (!light_isdigit(cr)) { 697 cr = '_'; 698 } 699 b->ptr[j++] = cr; 700 } 701 b->used = j; 702 b->ptr[b->used++] = '\0'; 703 } 704 705 /* decodes url-special-chars inplace. 706 * replaces non-printable characters with '_' 707 */ 708 709 static void buffer_urldecode_internal(buffer * const url, const int is_query) { 710 unsigned char high, low; 711 char *src; 712 char *dst; 713 714 force_assert(NULL != url); 715 if (buffer_string_is_empty(url)) return; 716 717 force_assert('\0' == url->ptr[url->used-1]); 718 719 src = (char*) url->ptr; 720 721 if (!is_query) { 722 while ('\0' != *src && '%' != *src) ++src; 723 } 724 else { 725 for (; '\0' != *src && '%' != *src; ++src) { 726 if ('+' == *src) *src = ' '; 727 } 728 } 729 730 if ('\0' == *src) return; 731 732 dst = src; 733 734 while ('\0' != *src) { 735 if (is_query && *src == '+') { 736 *dst = ' '; 737 } else if (*src == '%') { 738 *dst = '%'; 739 740 high = hex2int(*(src + 1)); 741 if (0xFF != high) { 742 low = hex2int(*(src + 2)); 743 if (0xFF != low) { 744 high = (high << 4) | low; 745 746 /* map control-characters out */ 747 if (high < 32 || high == 127) high = '_'; 748 749 *dst = high; 750 src += 2; 751 } 752 } 753 } else { 754 *dst = *src; 755 } 756 757 dst++; 758 src++; 759 } 760 761 *dst = '\0'; 762 url->used = (dst - url->ptr) + 1; 763 } 764 765 void buffer_urldecode_path(buffer *url) { 766 buffer_urldecode_internal(url, 0); 767 } 768 769 void buffer_urldecode_query(buffer *url) { 770 buffer_urldecode_internal(url, 1); 771 } 772 773 int buffer_is_valid_UTF8(const buffer *b) { 774 /* https://www.w3.org/International/questions/qa-forms-utf-8 */ 775 const unsigned char *c = (unsigned char *)b->ptr; 776 while (*c) { 777 778 /*(note: includes ctrls)*/ 779 if ( c[0] < 0x80 ) { ++c; continue; } 780 781 if ( 0xc2 <= c[0] && c[0] <= 0xdf 782 && 0x80 <= c[1] && c[1] <= 0xbf ) { c+=2; continue; } 783 784 if ( ( ( 0xe0 == c[0] 785 && 0xa0 <= c[1] && c[1] <= 0xbf) 786 || ( 0xe1 <= c[0] && c[0] <= 0xef && c[0] != 0xed 787 && 0x80 <= c[1] && c[1] <= 0xbf) 788 || ( 0xed == c[0] 789 && 0x80 <= c[1] && c[1] <= 0x9f) ) 790 && 0x80 <= c[2] && c[2] <= 0xbf ) { c+=3; continue; } 791 792 if ( ( ( 0xf0 == c[0] 793 && 0x90 <= c[1] && c[1] <= 0xbf) 794 || ( 0xf1 <= c[0] && c[0] <= 0xf3 795 && 0x80 <= c[1] && c[1] <= 0xbf) 796 || ( 0xf4 == c[0] 797 && 0x80 <= c[1] && c[1] <= 0x8f) ) 798 && 0x80 <= c[2] && c[2] <= 0xbf 799 && 0x80 <= c[3] && c[3] <= 0xbf ) { c+=4; continue; } 800 801 return 0; /* invalid */ 802 } 803 return 1; /* valid */ 804 } 805 806 /* - special case: empty string returns empty string 807 * - on windows or cygwin: replace \ with / 808 * - strip leading spaces 809 * - prepends "/" if not present already 810 * - resolve "/../", "//" and "/./" the usual way: 811 * the first one removes a preceding component, the other two 812 * get compressed to "/". 813 * - "/." and "/.." at the end are similar, but always leave a trailing 814 * "/" 815 * 816 * /blah/.. gets / 817 * /blah/../foo gets /foo 818 * /abc/./xyz gets /abc/xyz 819 * /abc//xyz gets /abc/xyz 820 * 821 * NOTE: src and dest can point to the same buffer, in which case, 822 * the operation is performed in-place. 823 */ 824 825 void buffer_path_simplify(buffer *dest, buffer *src) 826 { 827 /* current character, the one before, and the one before that from input */ 828 char c, pre1, pre2; 829 char *start, *slash, *walk, *out; 830 831 force_assert(NULL != dest && NULL != src); 832 833 if (buffer_string_is_empty(src)) { 834 buffer_copy_string_len(dest, CONST_STR_LEN("")); 835 return; 836 } 837 838 force_assert('\0' == src->ptr[src->used-1]); 839 840 #if defined(__WIN32) || defined(__CYGWIN__) 841 /* cygwin is treating \ and / the same, so we have to that too */ 842 { 843 char *p; 844 for (p = src->ptr; *p; p++) { 845 if (*p == '\\') *p = '/'; 846 } 847 } 848 #endif 849 850 walk = src->ptr; 851 start = dest->ptr; 852 out = dest->ptr; 853 slash = dest->ptr; 854 855 /* skip leading spaces */ 856 while (*walk == ' ') { 857 walk++; 858 } 859 if (*walk == '.') { 860 if (walk[1] == '/' || walk[1] == '\0') 861 ++walk; 862 else if (walk[1] == '.' && (walk[2] == '/' || walk[2] == '\0')) 863 walk+=2; 864 } 865 866 pre1 = 0; 867 c = *(walk++); 868 869 while (c != '\0') { 870 /* assert((src != dest || out <= walk) && slash <= out); */ 871 /* the following comments about out and walk are only interesting if 872 * src == dest; otherwise the memory areas don't overlap anyway. 873 */ 874 pre2 = pre1; 875 pre1 = c; 876 877 /* possibly: out == walk - need to read first */ 878 c = *walk; 879 *out = pre1; 880 881 out++; 882 walk++; 883 /* (out <= walk) still true; also now (slash < out) */ 884 885 if (c == '/' || c == '\0') { 886 const size_t toklen = out - slash; 887 if (toklen == 3 && pre2 == '.' && pre1 == '.' && *slash == '/') { 888 /* "/../" or ("/.." at end of string) */ 889 out = slash; 890 /* if there is something before "/..", there is at least one 891 * component, which needs to be removed */ 892 if (out > start) { 893 out--; 894 while (out > start && *out != '/') out--; 895 } 896 897 /* don't kill trailing '/' at end of path */ 898 if (c == '\0') out++; 899 /* slash < out before, so out_new <= slash + 1 <= out_before <= walk */ 900 } else if (toklen == 1 || (pre2 == '/' && pre1 == '.')) { 901 /* "//" or "/./" or (("/" or "/.") at end of string) */ 902 out = slash; 903 /* don't kill trailing '/' at end of path */ 904 if (c == '\0') out++; 905 /* slash < out before, so out_new <= slash + 1 <= out_before <= walk */ 906 } 907 908 slash = out; 909 } 910 } 911 912 buffer_string_set_length(dest, out - start); 913 } 914 915 void buffer_to_lower(buffer * const b) { 916 unsigned char * const restrict s = (unsigned char *)b->ptr; 917 for (uint32_t i = 0; i < b->used; ++i) { 918 if (light_isupper(s[i])) s[i] |= 0x20; 919 } 920 } 921 922 923 void buffer_to_upper(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_islower(s[i])) s[i] &= 0xdf; 927 } 928 } 929 930 931 #include <stdio.h> 932 933 #ifdef HAVE_LIBUNWIND 934 # define UNW_LOCAL_ONLY 935 # include <libunwind.h> 936 937 static void print_backtrace(FILE *file) { 938 unw_cursor_t cursor; 939 unw_context_t context; 940 int ret; 941 unsigned int frame = 0; 942 943 if (0 != (ret = unw_getcontext(&context))) goto error; 944 if (0 != (ret = unw_init_local(&cursor, &context))) goto error; 945 946 fprintf(file, "Backtrace:\n"); 947 948 while (0 < (ret = unw_step(&cursor))) { 949 unw_word_t proc_ip = 0; 950 unw_proc_info_t procinfo; 951 char procname[256]; 952 unw_word_t proc_offset = 0; 953 954 if (0 != (ret = unw_get_reg(&cursor, UNW_REG_IP, &proc_ip))) goto error; 955 956 if (0 == proc_ip) { 957 /* without an IP the other functions are useless; unw_get_proc_name would return UNW_EUNSPEC */ 958 ++frame; 959 fprintf(file, "%u: (nil)\n", frame); 960 continue; 961 } 962 963 if (0 != (ret = unw_get_proc_info(&cursor, &procinfo))) goto error; 964 965 if (0 != (ret = unw_get_proc_name(&cursor, procname, sizeof(procname), &proc_offset))) { 966 switch (-ret) { 967 case UNW_ENOMEM: 968 memset(procname + sizeof(procname) - 4, '.', 3); 969 procname[sizeof(procname) - 1] = '\0'; 970 break; 971 case UNW_ENOINFO: 972 procname[0] = '?'; 973 procname[1] = '\0'; 974 proc_offset = 0; 975 break; 976 default: 977 snprintf(procname, sizeof(procname), "?? (unw_get_proc_name error %d)", -ret); 978 break; 979 } 980 } 981 982 ++frame; 983 fprintf(file, "%u: %s (+0x%x) [%p]\n", 984 frame, 985 procname, 986 (unsigned int) proc_offset, 987 (void*)(uintptr_t)proc_ip); 988 } 989 990 if (0 != ret) goto error; 991 992 return; 993 994 error: 995 fprintf(file, "Error while generating backtrace: unwind error %i\n", (int) -ret); 996 } 997 #else 998 static void print_backtrace(FILE *file) { 999 UNUSED(file); 1000 } 1001 #endif 1002 1003 void log_failed_assert(const char *filename, unsigned int line, const char *msg) { 1004 /* can't use buffer here; could lead to recursive assertions */ 1005 fprintf(stderr, "%s.%u: %s\n", filename, line, msg); 1006 print_backtrace(stderr); 1007 fflush(stderr); 1008 abort(); 1009 } 1010