12 static const char hex_chars
[] = "0123456789abcdef";
19 buffer
* buffer_init(void) {
22 b
= malloc(sizeof(*b
));
32 buffer
*buffer_init_buffer(const buffer
*src
) {
33 buffer
*b
= buffer_init();
34 buffer_copy_buffer(b
, src
);
38 buffer
*buffer_init_string(const char *str
) {
39 buffer
*b
= buffer_init();
40 buffer_copy_string(b
, str
);
44 void buffer_free(buffer
*b
) {
45 if (NULL
== b
) return;
51 void buffer_reset(buffer
*b
) {
52 if (NULL
== b
) return;
54 /* limit don't reuse buffer larger than ... bytes */
55 if (b
->size
> BUFFER_MAX_REUSE_SIZE
) {
59 } else if (b
->size
> 0) {
66 void buffer_move(buffer
*b
, buffer
*src
) {
74 if (NULL
== src
) return;
76 tmp
= *src
; *src
= *b
; *b
= tmp
;
79 #define BUFFER_PIECE_SIZE 64
80 static size_t buffer_align_size(size_t size
) {
81 size_t align
= BUFFER_PIECE_SIZE
- (size
% BUFFER_PIECE_SIZE
);
82 /* overflow on unsinged size_t is defined to wrap around */
83 if (size
+ align
< size
) return size
;
87 /* make sure buffer is at least "size" big. discard old data */
88 static void buffer_alloc(buffer
*b
, size_t size
) {
89 force_assert(NULL
!= b
);
90 if (0 == size
) size
= 1;
92 if (size
<= b
->size
) return;
94 if (NULL
!= b
->ptr
) free(b
->ptr
);
97 b
->size
= buffer_align_size(size
);
98 b
->ptr
= malloc(b
->size
);
100 force_assert(NULL
!= b
->ptr
);
103 /* make sure buffer is at least "size" big. keep old data */
104 static void buffer_realloc(buffer
*b
, size_t size
) {
105 force_assert(NULL
!= b
);
106 if (0 == size
) size
= 1;
108 if (size
<= b
->size
) return;
110 b
->size
= buffer_align_size(size
);
111 b
->ptr
= realloc(b
->ptr
, b
->size
);
113 force_assert(NULL
!= b
->ptr
);
117 char* buffer_string_prepare_copy(buffer
*b
, size_t size
) {
118 force_assert(NULL
!= b
);
119 force_assert(size
+ 1 > size
);
121 buffer_alloc(b
, size
+ 1);
129 char* buffer_string_prepare_append(buffer
*b
, size_t size
) {
130 force_assert(NULL
!= b
);
132 if (buffer_string_is_empty(b
)) {
133 return buffer_string_prepare_copy(b
, size
);
135 size_t req_size
= b
->used
+ size
;
137 /* not empty, b->used already includes a terminating 0 */
138 force_assert(req_size
>= b
->used
);
140 /* check for overflow: unsigned overflow is defined to wrap around */
141 force_assert(req_size
>= b
->used
);
143 buffer_realloc(b
, req_size
);
145 return b
->ptr
+ b
->used
- 1;
149 void buffer_string_set_length(buffer
*b
, size_t len
) {
150 force_assert(NULL
!= b
);
151 force_assert(len
+ 1 > len
);
153 buffer_realloc(b
, len
+ 1);
159 void buffer_commit(buffer
*b
, size_t size
)
161 force_assert(NULL
!= b
);
162 force_assert(b
->size
> 0);
164 if (0 == b
->used
) b
->used
= 1;
167 /* check for overflow: unsigned overflow is defined to wrap around */
168 force_assert(b
->used
+ size
> b
->used
);
170 force_assert(b
->used
+ size
<= b
->size
);
174 b
->ptr
[b
->used
- 1] = '\0';
177 void buffer_copy_string(buffer
*b
, const char *s
) {
178 buffer_copy_string_len(b
, s
, NULL
!= s
? strlen(s
) : 0);
181 void buffer_copy_string_len(buffer
*b
, const char *s
, size_t s_len
) {
182 force_assert(NULL
!= b
);
183 force_assert(NULL
!= s
|| s_len
== 0);
185 buffer_string_prepare_copy(b
, s_len
);
187 if (0 != s_len
) memcpy(b
->ptr
, s
, s_len
);
189 buffer_commit(b
, s_len
);
192 void buffer_copy_buffer(buffer
*b
, const buffer
*src
) {
193 if (NULL
== src
|| 0 == src
->used
) {
194 buffer_string_prepare_copy(b
, 0);
195 b
->used
= 0; /* keep special empty state for now */
197 buffer_copy_string_len(b
, src
->ptr
, buffer_string_length(src
));
201 void buffer_append_string(buffer
*b
, const char *s
) {
202 buffer_append_string_len(b
, s
, NULL
!= s
? strlen(s
) : 0);
206 * append a string to the end of the buffer
208 * the resulting buffer is terminated with a '\0'
209 * s is treated as a un-terminated string (a \0 is handled a normal character)
212 * @param s the string
213 * @param s_len size of the string (without the terminating \0)
216 void buffer_append_string_len(buffer
*b
, const char *s
, size_t s_len
) {
219 force_assert(NULL
!= b
);
220 force_assert(NULL
!= s
|| s_len
== 0);
222 target_buf
= buffer_string_prepare_append(b
, s_len
);
224 if (0 == s_len
) return; /* nothing to append */
226 memcpy(target_buf
, s
, s_len
);
228 buffer_commit(b
, s_len
);
231 void buffer_append_string_buffer(buffer
*b
, const buffer
*src
) {
233 buffer_append_string_len(b
, NULL
, 0);
235 buffer_append_string_len(b
, src
->ptr
, buffer_string_length(src
));
239 void buffer_append_uint_hex(buffer
*b
, uintmax_t value
) {
244 uintmax_t copy
= value
;
247 shift
+= 2; /* counting nibbles (4 bits) */
251 buf
= buffer_string_prepare_append(b
, shift
);
252 buffer_commit(b
, shift
); /* will fill below */
254 shift
<<= 2; /* count bits now */
257 *(buf
++) = hex_chars
[(value
>> shift
) & 0x0F];
261 static char* utostr(char * const buf_end
, uintmax_t val
) {
266 /* prepend digit mod */
267 *(--cur
) = (char) ('0' + mod
);
272 static char* itostr(char * const buf_end
, intmax_t val
) {
274 if (val
>= 0) return utostr(buf_end
, (uintmax_t) val
);
276 /* can't take absolute value, as it isn't defined for INTMAX_MIN */
280 /* val * 10 + mod == orig val, -10 < mod < 10 */
281 /* we want a negative mod */
286 /* prepend digit abs(mod) */
287 *(--cur
) = (char) ('0' + (-mod
));
294 void buffer_append_int(buffer
*b
, intmax_t val
) {
295 char buf
[LI_ITOSTRING_LENGTH
];
296 char* const buf_end
= buf
+ sizeof(buf
);
299 force_assert(NULL
!= b
);
301 str
= itostr(buf_end
, val
);
302 force_assert(buf_end
> str
&& str
>= buf
);
304 buffer_append_string_len(b
, str
, buf_end
- str
);
307 void buffer_copy_int(buffer
*b
, intmax_t val
) {
308 force_assert(NULL
!= b
);
311 buffer_append_int(b
, val
);
314 void buffer_append_strftime(buffer
*b
, const char *format
, const struct tm
*tm
) {
317 force_assert(NULL
!= b
);
318 force_assert(NULL
!= tm
);
320 if (NULL
== format
|| '\0' == format
[0]) {
322 buffer_string_prepare_append(b
, 0);
326 buf
= buffer_string_prepare_append(b
, 255);
327 r
= strftime(buf
, buffer_string_space(b
), format
, tm
);
329 /* 0 (in some apis buffer_string_space(b)) signals the string may have
330 * been too small; but the format could also just have lead to an empty
333 if (0 == r
|| r
>= buffer_string_space(b
)) {
334 /* give it a second try with a larger string */
335 buf
= buffer_string_prepare_append(b
, 4095);
336 r
= strftime(buf
, buffer_string_space(b
), format
, tm
);
339 if (r
>= buffer_string_space(b
)) r
= 0;
345 void li_itostrn(char *buf
, size_t buf_len
, intmax_t val
) {
346 char p_buf
[LI_ITOSTRING_LENGTH
];
347 char* const p_buf_end
= p_buf
+ sizeof(p_buf
);
348 char* str
= p_buf_end
- 1;
351 str
= itostr(str
, val
);
352 force_assert(p_buf_end
> str
&& str
>= p_buf
);
354 force_assert(buf_len
>= (size_t) (p_buf_end
- str
));
355 memcpy(buf
, str
, p_buf_end
- str
);
358 void li_utostrn(char *buf
, size_t buf_len
, uintmax_t val
) {
359 char p_buf
[LI_ITOSTRING_LENGTH
];
360 char* const p_buf_end
= p_buf
+ sizeof(p_buf
);
361 char* str
= p_buf_end
- 1;
364 str
= utostr(str
, val
);
365 force_assert(p_buf_end
> str
&& str
>= p_buf
);
367 force_assert(buf_len
>= (size_t) (p_buf_end
- str
));
368 memcpy(buf
, str
, p_buf_end
- str
);
371 char int2hex(char c
) {
372 return hex_chars
[(c
& 0x0F)];
375 /* converts hex char (0-9, A-Z, a-z) to decimal.
376 * returns 0xFF on invalid input.
378 char hex2int(unsigned char hex
) {
379 unsigned char value
= hex
- '0';
381 hex
|= 0x20; /* to lower case */
382 value
= hex
- 'a' + 10;
383 if (value
< 10) value
= 0xff;
385 if (value
> 15) value
= 0xff;
390 char * buffer_search_string_len(buffer
*b
, const char *needle
, size_t len
) {
392 force_assert(NULL
!= b
);
393 force_assert(0 != len
&& NULL
!= needle
); /* empty needles not allowed */
395 if (b
->used
< len
) return NULL
;
397 for(i
= 0; i
< b
->used
- len
; i
++) {
398 if (0 == memcmp(b
->ptr
+ i
, needle
, len
)) {
406 int buffer_is_empty(const buffer
*b
) {
407 return NULL
== b
|| 0 == b
->used
;
410 int buffer_string_is_empty(const buffer
*b
) {
411 return 0 == buffer_string_length(b
);
415 * check if two buffer contain the same data
417 * HISTORY: this function was pretty much optimized, but didn't handled
418 * alignment properly.
421 int buffer_is_equal(const buffer
*a
, const buffer
*b
) {
422 force_assert(NULL
!= a
&& NULL
!= b
);
424 if (a
->used
!= b
->used
) return 0;
425 if (a
->used
== 0) return 1;
427 return (0 == memcmp(a
->ptr
, b
->ptr
, a
->used
));
430 int buffer_is_equal_string(const buffer
*a
, const char *s
, size_t b_len
) {
431 force_assert(NULL
!= a
&& NULL
!= s
);
432 force_assert(b_len
+ 1 > b_len
);
434 if (a
->used
!= b_len
+ 1) return 0;
435 if (0 != memcmp(a
->ptr
, s
, b_len
)) return 0;
436 if ('\0' != a
->ptr
[a
->used
-1]) return 0;
441 /* buffer_is_equal_caseless_string(b, CONST_STR_LEN("value")) */
442 int buffer_is_equal_caseless_string(const buffer
*a
, const char *s
, size_t b_len
) {
443 force_assert(NULL
!= a
);
444 if (a
->used
!= b_len
+ 1) return 0;
445 force_assert('\0' == a
->ptr
[a
->used
- 1]);
447 return (0 == strcasecmp(a
->ptr
, s
));
450 int buffer_caseless_compare(const char *a
, size_t a_len
, const char *b
, size_t b_len
) {
451 size_t const len
= (a_len
< b_len
) ? a_len
: b_len
;
454 for (i
= 0; i
< len
; ++i
) {
455 unsigned char ca
= a
[i
], cb
= b
[i
];
456 if (ca
== cb
) continue;
458 /* always lowercase for transitive results */
459 if (ca
>= 'A' && ca
<= 'Z') ca
|= 32;
460 if (cb
>= 'A' && cb
<= 'Z') cb
|= 32;
462 if (ca
== cb
) continue;
463 return ((int)ca
) - ((int)cb
);
465 if (a_len
== b_len
) return 0;
466 return a_len
< b_len
? -1 : 1;
469 int buffer_is_equal_right_len(const buffer
*b1
, const buffer
*b2
, size_t len
) {
470 /* no len -> equal */
471 if (len
== 0) return 1;
473 /* len > 0, but empty buffers -> not equal */
474 if (b1
->used
== 0 || b2
->used
== 0) return 0;
476 /* buffers too small -> not equal */
477 if (b1
->used
- 1 < len
|| b2
->used
- 1 < len
) return 0;
479 return 0 == memcmp(b1
->ptr
+ b1
->used
- 1 - len
, b2
->ptr
+ b2
->used
- 1 - len
, len
);
482 void li_tohex(char *buf
, size_t buf_len
, const char *s
, size_t s_len
) {
484 force_assert(2 * s_len
> s_len
);
485 force_assert(2 * s_len
< buf_len
);
487 for (i
= 0; i
< s_len
; i
++) {
488 buf
[2*i
] = hex_chars
[(s
[i
] >> 4) & 0x0F];
489 buf
[2*i
+1] = hex_chars
[s
[i
] & 0x0F];
494 void buffer_copy_string_hex(buffer
*b
, const char *in
, size_t in_len
) {
495 /* overflow protection */
496 force_assert(in_len
* 2 > in_len
);
498 buffer_string_set_length(b
, 2 * in_len
);
499 li_tohex(b
->ptr
, buffer_string_space(b
)+1, in
, in_len
);
502 /* everything except: ! ( ) * - . 0-9 A-Z _ a-z ~ */
503 static const char encoded_chars_rel_uri_part
[] = {
505 0 1 2 3 4 5 6 7 8 9 A B C D E F
507 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */
508 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */
509 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, /* 20 - 2F space " # $ % & ' + , / */
510 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, /* 30 - 3F : ; < = > ? */
511 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F @ */
512 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, /* 50 - 5F [ \ ] ^ */
513 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F ` */
514 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* 70 - 7F { | } ~ DEL */
515 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 8F */
516 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 90 - 9F */
517 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* A0 - AF */
518 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* B0 - BF */
519 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* C0 - CF */
520 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* D0 - DF */
521 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* E0 - EF */
522 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* F0 - FF */
525 /* everything except: ! ( ) * - . / 0-9 A-Z _ a-z ~ */
526 static const char encoded_chars_rel_uri
[] = {
528 0 1 2 3 4 5 6 7 8 9 A B C D E F
530 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */
531 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */
532 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, /* 20 - 2F space " # $ % & ' + , */
533 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, /* 30 - 3F : ; < = > ? */
534 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F @ */
535 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, /* 50 - 5F [ \ ] ^ */
536 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F ` */
537 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* 70 - 7F { | } ~ DEL */
538 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 8F */
539 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 90 - 9F */
540 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* A0 - AF */
541 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* B0 - BF */
542 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* C0 - CF */
543 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* D0 - DF */
544 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* E0 - EF */
545 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* F0 - FF */
548 static const char encoded_chars_html
[] = {
550 0 1 2 3 4 5 6 7 8 9 A B C D E F
552 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */
553 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */
554 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 20 - 2F & */
555 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, /* 30 - 3F < > */
556 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F */
557 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 50 - 5F */
558 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F */
559 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 70 - 7F DEL */
560 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 8F */
561 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 90 - 9F */
562 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* A0 - AF */
563 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* B0 - BF */
564 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* C0 - CF */
565 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* D0 - DF */
566 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* E0 - EF */
567 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* F0 - FF */
570 static const char encoded_chars_minimal_xml
[] = {
572 0 1 2 3 4 5 6 7 8 9 A B C D E F
574 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */
575 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */
576 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 20 - 2F & */
577 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, /* 30 - 3F < > */
578 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F */
579 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 50 - 5F */
580 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F */
581 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 70 - 7F DEL */
582 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */
583 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */
584 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */
585 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */
586 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */
587 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */
588 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */
589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */
592 static const char encoded_chars_hex
[] = {
594 0 1 2 3 4 5 6 7 8 9 A B C D E F
596 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 0F control chars */
597 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 - 1F */
598 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 20 - 2F */
599 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 30 - 3F */
600 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 40 - 4F */
601 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 50 - 5F */
602 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 60 - 6F */
603 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 70 - 7F */
604 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 8F */
605 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 90 - 9F */
606 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* A0 - AF */
607 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* B0 - BF */
608 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* C0 - CF */
609 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* D0 - DF */
610 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* E0 - EF */
611 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* F0 - FF */
614 static const char encoded_chars_http_header
[] = {
616 0 1 2 3 4 5 6 7 8 9 A B C D E F
618 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* 00 - 0F */
619 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 1F */
620 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 20 - 2F */
621 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 30 - 3F */
622 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40 - 4F */
623 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 50 - 5F */
624 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6F */
625 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 70 - 7F */
626 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */
627 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */
628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */
629 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */
630 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */
631 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */
632 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */
633 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */
638 void buffer_append_string_encoded(buffer
*b
, const char *s
, size_t s_len
, buffer_encoding_t encoding
) {
639 unsigned char *ds
, *d
;
641 const char *map
= NULL
;
643 force_assert(NULL
!= b
);
644 force_assert(NULL
!= s
|| 0 == s_len
);
646 if (0 == s_len
) return;
649 case ENCODING_REL_URI
:
650 map
= encoded_chars_rel_uri
;
652 case ENCODING_REL_URI_PART
:
653 map
= encoded_chars_rel_uri_part
;
656 map
= encoded_chars_html
;
658 case ENCODING_MINIMAL_XML
:
659 map
= encoded_chars_minimal_xml
;
662 map
= encoded_chars_hex
;
664 case ENCODING_HTTP_HEADER
:
665 map
= encoded_chars_http_header
;
669 force_assert(NULL
!= map
);
671 /* count to-be-encoded-characters */
672 for (ds
= (unsigned char *)s
, d_len
= 0, ndx
= 0; ndx
< s_len
; ds
++, ndx
++) {
675 case ENCODING_REL_URI
:
676 case ENCODING_REL_URI_PART
:
680 case ENCODING_MINIMAL_XML
:
683 case ENCODING_HTTP_HEADER
:
693 d
= (unsigned char*) buffer_string_prepare_append(b
, d_len
);
694 buffer_commit(b
, d_len
); /* fill below */
695 force_assert('\0' == *d
);
697 for (ds
= (unsigned char *)s
, d_len
= 0, ndx
= 0; ndx
< s_len
; ds
++, ndx
++) {
700 case ENCODING_REL_URI
:
701 case ENCODING_REL_URI_PART
:
703 d
[d_len
++] = hex_chars
[((*ds
) >> 4) & 0x0F];
704 d
[d_len
++] = hex_chars
[(*ds
) & 0x0F];
707 case ENCODING_MINIMAL_XML
:
711 d
[d_len
++] = hex_chars
[((*ds
) >> 4) & 0x0F];
712 d
[d_len
++] = hex_chars
[(*ds
) & 0x0F];
716 d
[d_len
++] = hex_chars
[((*ds
) >> 4) & 0x0F];
717 d
[d_len
++] = hex_chars
[(*ds
) & 0x0F];
719 case ENCODING_HTTP_HEADER
:
730 void buffer_append_string_c_escaped(buffer
*b
, const char *s
, size_t s_len
) {
731 unsigned char *ds
, *d
;
734 force_assert(NULL
!= b
);
735 force_assert(NULL
!= s
|| 0 == s_len
);
737 if (0 == s_len
) return;
739 /* count to-be-encoded-characters */
740 for (ds
= (unsigned char *)s
, d_len
= 0, ndx
= 0; ndx
< s_len
; ds
++, ndx
++) {
741 if ((*ds
< 0x20) /* control character */
742 || (*ds
>= 0x7f)) { /* DEL + non-ASCII characters */
750 d_len
+= 4; /* \xCC */
758 d
= (unsigned char*) buffer_string_prepare_append(b
, d_len
);
759 buffer_commit(b
, d_len
); /* fill below */
760 force_assert('\0' == *d
);
762 for (ds
= (unsigned char *)s
, d_len
= 0, ndx
= 0; ndx
< s_len
; ds
++, ndx
++) {
763 if ((*ds
< 0x20) /* control character */
764 || (*ds
>= 0x7f)) { /* DEL + non-ASCII characters */
778 d
[d_len
++] = hex_chars
[((*ds
) >> 4) & 0x0F];
779 d
[d_len
++] = hex_chars
[(*ds
) & 0x0F];
789 void buffer_copy_string_encoded_cgi_varnames(buffer
*b
, const char *s
, size_t s_len
, int is_http_header
) {
792 force_assert(NULL
!= b
);
793 force_assert(NULL
!= s
|| 0 == s_len
);
797 if (is_http_header
&& NULL
!= s
&& 0 != strcasecmp(s
, "CONTENT-TYPE")) {
798 buffer_string_prepare_append(b
, s_len
+ 5);
799 buffer_copy_string_len(b
, CONST_STR_LEN("HTTP_"));
801 buffer_string_prepare_append(b
, s_len
);
804 j
= buffer_string_length(b
);
805 for (i
= 0; i
< s_len
; ++i
) {
806 unsigned char cr
= s
[i
];
807 if (light_isalpha(cr
)) {
810 } else if (!light_isdigit(cr
)) {
816 b
->ptr
[b
->used
++] = '\0';
819 /* decodes url-special-chars inplace.
820 * replaces non-printable characters with '_'
823 static void buffer_urldecode_internal(buffer
*url
, int is_query
) {
824 unsigned char high
, low
;
828 force_assert(NULL
!= url
);
829 if (buffer_string_is_empty(url
)) return;
831 force_assert('\0' == url
->ptr
[url
->used
-1]);
833 src
= (char*) url
->ptr
;
835 while ('\0' != *src
) {
836 if ('%' == *src
) break;
837 if (is_query
&& '+' == *src
) *src
= ' ';
842 while ('\0' != *src
) {
843 if (is_query
&& *src
== '+') {
845 } else if (*src
== '%') {
848 high
= hex2int(*(src
+ 1));
850 low
= hex2int(*(src
+ 2));
852 high
= (high
<< 4) | low
;
854 /* map control-characters out */
855 if (high
< 32 || high
== 127) high
= '_';
870 url
->used
= (dst
- url
->ptr
) + 1;
873 void buffer_urldecode_path(buffer
*url
) {
874 buffer_urldecode_internal(url
, 0);
877 void buffer_urldecode_query(buffer
*url
) {
878 buffer_urldecode_internal(url
, 1);
881 /* - special case: empty string returns empty string
882 * - on windows or cygwin: replace \ with /
883 * - strip leading spaces
884 * - prepends "/" if not present already
885 * - resolve "/../", "//" and "/./" the usual way:
886 * the first one removes a preceding component, the other two
887 * get compressed to "/".
888 * - "/." and "/.." at the end are similar, but always leave a trailing
892 * /blah/../foo gets /foo
893 * /abc/./xyz gets /abc/xyz
894 * /abc//xyz gets /abc/xyz
896 * NOTE: src and dest can point to the same buffer, in which case,
897 * the operation is performed in-place.
900 void buffer_path_simplify(buffer
*dest
, buffer
*src
)
902 /* current character, the one before, and the one before that from input */
904 char *start
, *slash
, *walk
, *out
;
906 force_assert(NULL
!= dest
&& NULL
!= src
);
908 if (buffer_string_is_empty(src
)) {
909 buffer_string_prepare_copy(dest
, 0);
913 force_assert('\0' == src
->ptr
[src
->used
-1]);
915 /* might need one character more for the '/' prefix */
917 buffer_string_prepare_append(dest
, 1);
919 buffer_string_prepare_copy(dest
, buffer_string_length(src
) + 1);
922 #if defined(__WIN32) || defined(__CYGWIN__)
923 /* cygwin is treating \ and / the same, so we have to that too */
926 for (p
= src
->ptr
; *p
; p
++) {
927 if (*p
== '\\') *p
= '/';
937 /* skip leading spaces */
938 while (*walk
== ' ') {
944 /* prefix with '/' if not already present */
951 /* assert((src != dest || out <= walk) && slash <= out); */
952 /* the following comments about out and walk are only interesting if
953 * src == dest; otherwise the memory areas don't overlap anyway.
958 /* possibly: out == walk - need to read first */
964 /* (out <= walk) still true; also now (slash < out) */
966 if (c
== '/' || c
== '\0') {
967 const size_t toklen
= out
- slash
;
968 if (toklen
== 3 && pre2
== '.' && pre1
== '.') {
969 /* "/../" or ("/.." at end of string) */
971 /* if there is something before "/..", there is at least one
972 * component, which needs to be removed */
975 while (out
> start
&& *out
!= '/') out
--;
978 /* don't kill trailing '/' at end of path */
979 if (c
== '\0') out
++;
980 /* slash < out before, so out_new <= slash + 1 <= out_before <= walk */
981 } else if (toklen
== 1 || (pre2
== '/' && pre1
== '.')) {
982 /* "//" or "/./" or (("/" or "/.") at end of string) */
984 /* don't kill trailing '/' at end of path */
985 if (c
== '\0') out
++;
986 /* slash < out before, so out_new <= slash + 1 <= out_before <= walk */
993 buffer_string_set_length(dest
, out
- start
);
996 int light_isdigit(int c
) {
997 return (c
>= '0' && c
<= '9');
1000 int light_isxdigit(int c
) {
1001 if (light_isdigit(c
)) return 1;
1004 return (c
>= 'a' && c
<= 'f');
1007 int light_isalpha(int c
) {
1009 return (c
>= 'a' && c
<= 'z');
1012 int light_isalnum(int c
) {
1013 return light_isdigit(c
) || light_isalpha(c
);
1016 void buffer_to_lower(buffer
*b
) {
1019 for (i
= 0; i
< b
->used
; ++i
) {
1021 if (c
>= 'A' && c
<= 'Z') b
->ptr
[i
] |= 0x20;
1026 void buffer_to_upper(buffer
*b
) {
1029 for (i
= 0; i
< b
->used
; ++i
) {
1031 if (c
>= 'A' && c
<= 'Z') b
->ptr
[i
] &= ~0x20;
1035 #ifdef HAVE_LIBUNWIND
1036 # define UNW_LOCAL_ONLY
1037 # include <libunwind.h>
1039 void print_backtrace(FILE *file
) {
1040 unw_cursor_t cursor
;
1041 unw_context_t context
;
1043 unsigned int frame
= 0;
1045 if (0 != (ret
= unw_getcontext(&context
))) goto error
;
1046 if (0 != (ret
= unw_init_local(&cursor
, &context
))) goto error
;
1048 fprintf(file
, "Backtrace:\n");
1050 while (0 < (ret
= unw_step(&cursor
))) {
1051 unw_word_t proc_ip
= 0;
1052 unw_proc_info_t procinfo
;
1054 unw_word_t proc_offset
= 0;
1056 if (0 != (ret
= unw_get_reg(&cursor
, UNW_REG_IP
, &proc_ip
))) goto error
;
1059 /* without an IP the other functions are useless; unw_get_proc_name would return UNW_EUNSPEC */
1061 fprintf(file
, "%u: (nil)\n", frame
);
1065 if (0 != (ret
= unw_get_proc_info(&cursor
, &procinfo
))) goto error
;
1067 if (0 != (ret
= unw_get_proc_name(&cursor
, procname
, sizeof(procname
), &proc_offset
))) {
1070 memset(procname
+ sizeof(procname
) - 4, '.', 3);
1071 procname
[sizeof(procname
) - 1] = '\0';
1079 snprintf(procname
, sizeof(procname
), "?? (unw_get_proc_name error %d)", -ret
);
1085 fprintf(file
, "%u: %s (+0x%x) [%p]\n",
1088 (unsigned int) proc_offset
,
1089 (void*)(uintptr_t)proc_ip
);
1092 if (0 != ret
) goto error
;
1097 fprintf(file
, "Error while generating backtrace: unwind error %i\n", (int) -ret
);
1100 void print_backtrace(FILE *file
) {
1105 void log_failed_assert(const char *filename
, unsigned int line
, const char *msg
) {
1106 /* can't use buffer here; could lead to recursive assertions */
1107 fprintf(stderr
, "%s.%d: %s\n", filename
, line
, msg
);
1108 print_backtrace(stderr
);