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