src/web_buffer.c

   1 #include "common.h"
   2
   3 #define BUFFER_OVERFLOW_EOF "EOF"
   4
   5 static inline void buffer_overflow_init(BUFFER *b)
   6 {
   7     b->buffer[b->size] = '\0';
   8     strcpy(&b->buffer[b->size + 1], BUFFER_OVERFLOW_EOF);
   9 }
  10
  11 #ifdef NETDATA_INTERNAL_CHECKS
  12 #define buffer_overflow_check(b) _buffer_overflow_check(b, __FILE__, __FUNCTION__, __LINE__)
  13 #else
  14 #define buffer_overflow_check(b)
  15 #endif
  16
  17 static inline void _buffer_overflow_check(BUFFER *b, const char *file, const char *function, const unsigned long line)
  18 {
  19     if(b->len > b->size) {
  20         error("BUFFER: length %zu is above size %zu, at line %lu, at function %s() of file '%s'.", b->len, b->size, line, function, file);
  21         b->len = b->size;
  22     }
  23
  24     if(b->buffer[b->size] != '\0' || strcmp(&b->buffer[b->size + 1], BUFFER_OVERFLOW_EOF)) {
  25         error("BUFFER: detected overflow at line %lu, at function %s() of file '%s'.", line, function, file);
  26         buffer_overflow_init(b);
  27     }
  28 }
  29
  30
  31 void buffer_reset(BUFFER *wb)
  32 {
  33     buffer_flush(wb);
  34
  35     wb->contenttype = CT_TEXT_PLAIN;
  36     wb->options = 0;
  37     wb->date = 0;
  38     wb->expires = 0;
  39
  40     buffer_overflow_check(wb);
  41 }
  42
  43 const char *buffer_tostring(BUFFER *wb)
  44 {
  45     buffer_need_bytes(wb, 1);
  46     wb->buffer[wb->len] = '\0';
  47
  48     buffer_overflow_check(wb);
  49
  50     return(wb->buffer);
  51 }
  52
  53 void buffer_char_replace(BUFFER *wb, char from, char to)
  54 {
  55     char *s = wb->buffer, *end = &wb->buffer[wb->len];
  56
  57     while(s != end) {
  58         if(*s == from) *s = to;
  59         s++;
  60     }
  61
  62     buffer_overflow_check(wb);
  63 }
  64
  65 // This trick seems to give an 80% speed increase in 32bit systems
  66 // print_calculated_number_llu_r() will just print the digits up to the
  67 // point the remaining value fits in 32 bits, and then calls
  68 // print_calculated_number_lu_r() to print the rest with 32 bit arithmetic.
  69
  70 inline char *print_number_lu_r(char *str, unsigned long uvalue) {
  71     char *wstr = str;
  72
  73     // print each digit
  74     do *wstr++ = (char)('0' + (uvalue % 10)); while(uvalue /= 10);
  75     return wstr;
  76 }
  77
  78 inline char *print_number_llu_r(char *str, unsigned long long uvalue) {
  79     char *wstr = str;
  80
  81     // print each digit
  82     do *wstr++ = (char)('0' + (uvalue % 10)); while((uvalue /= 10) && uvalue > (unsigned long long)0xffffffff);
  83     if(uvalue) return print_number_lu_r(wstr, uvalue);
  84     return wstr;
  85 }
  86
  87 void buffer_print_llu(BUFFER *wb, unsigned long long uvalue)
  88 {
  89     buffer_need_bytes(wb, 50);
  90
  91     char *str = &wb->buffer[wb->len];
  92     char *wstr = str;
  93
  94 #ifdef ENVIRONMENT32
  95     if(uvalue > (unsigned long long)0xffffffff)
  96         wstr = print_number_llu_r(wstr, uvalue);
  97     else
  98         wstr = print_number_lu_r(wstr, uvalue);
  99 #else
 100     do *wstr++ = (char)('0' + (uvalue % 10)); while(uvalue /= 10);
 101 #endif
 102
 103     // terminate it
 104     *wstr = '\0';
 105
 106     // reverse it
 107     char *begin = str, *end = wstr - 1, aux;
 108     while (end > begin) aux = *end, *end-- = *begin, *begin++ = aux;
 109
 110     // return the buffer length
 111     wb->len += wstr - str;
 112 }
 113
 114 void buffer_strcat(BUFFER *wb, const char *txt)
 115 {
 116     if(unlikely(!txt || !*txt)) return;
 117
 118     buffer_need_bytes(wb, 1);
 119
 120     char *s = &wb->buffer[wb->len], *start, *end = &wb->buffer[wb->size];
 121     size_t len = wb->len;
 122
 123     start = s;
 124     while(*txt && s != end)
 125         *s++ = *txt++;
 126
 127     len += s - start;
 128
 129     wb->len = len;
 130     buffer_overflow_check(wb);
 131
 132     if(*txt) {
 133         debug(D_WEB_BUFFER, "strcat(): increasing web_buffer at position %zu, size = %zu\n", wb->len, wb->size);
 134         len = strlen(txt);
 135         buffer_increase(wb, len);
 136         buffer_strcat(wb, txt);
 137     }
 138     else {
 139         // terminate the string
 140         // without increasing the length
 141         buffer_need_bytes(wb, (size_t)1);
 142         wb->buffer[wb->len] = '\0';
 143     }
 144 }
 145
 146 void buffer_strcat_htmlescape(BUFFER *wb, const char *txt)
 147 {
 148     char b[2] = { [0] = '\0', [1] = '\0' };
 149
 150     while(*txt) {
 151         switch(*txt) {
 152             case '&': buffer_strcat(wb, "&amp;"); break;
 153             case '<': buffer_strcat(wb, "&lt;"); break;
 154             case '>': buffer_strcat(wb, "&gt;"); break;
 155             case '"': buffer_strcat(wb, "&quot;"); break;
 156             case '/': buffer_strcat(wb, "&#x2F;"); break;
 157             case '\'': buffer_strcat(wb, "&#x27;"); break;
 158             default: {
 159                 b[0] = *txt;
 160                 buffer_strcat(wb, b);
 161             }
 162         }
 163         txt++;
 164     }
 165 }
 166
 167 void buffer_snprintf(BUFFER *wb, size_t len, const char *fmt, ...)
 168 {
 169     if(unlikely(!fmt || !*fmt)) return;
 170
 171     buffer_need_bytes(wb, len + 1);
 172
 173     va_list args;
 174     va_start(args, fmt);
 175     wb->len += vsnprintfz(&wb->buffer[wb->len], len, fmt, args);
 176     va_end(args);
 177
 178     buffer_overflow_check(wb);
 179
 180     // the buffer is \0 terminated by vsnprintfz
 181 }
 182
 183 void buffer_vsprintf(BUFFER *wb, const char *fmt, va_list args)
 184 {
 185     if(unlikely(!fmt || !*fmt)) return;
 186
 187     buffer_need_bytes(wb, 2);
 188
 189     size_t len = wb->size - wb->len - 1;
 190
 191     wb->len += vsnprintfz(&wb->buffer[wb->len], len, fmt, args);
 192
 193     buffer_overflow_check(wb);
 194
 195     // the buffer is \0 terminated by vsnprintfz
 196 }
 197
 198 void buffer_sprintf(BUFFER *wb, const char *fmt, ...)
 199 {
 200     if(unlikely(!fmt || !*fmt)) return;
 201
 202     buffer_need_bytes(wb, 2);
 203
 204     size_t len = wb->size - wb->len - 1;
 205     size_t wrote;
 206
 207     va_list args;
 208     va_start(args, fmt);
 209     wrote = (size_t) vsnprintfz(&wb->buffer[wb->len], len, fmt, args);
 210     va_end(args);
 211
 212     if(unlikely(wrote >= len)) {
 213         // truncated
 214         buffer_overflow_check(wb);
 215
 216         debug(D_WEB_BUFFER, "web_buffer_sprintf(): increasing web_buffer at position %zu, size = %zu\n", wb->len, wb->size);
 217         buffer_need_bytes(wb, len + WEB_DATA_LENGTH_INCREASE_STEP);
 218
 219         va_start(args, fmt);
 220         buffer_vsprintf(wb, fmt, args);
 221         va_end(args);
 222     }
 223     else
 224         wb->len += wrote;
 225
 226     // the buffer is \0 terminated by vsnprintf
 227 }
 228
 229
 230 void buffer_rrd_value(BUFFER *wb, calculated_number value)
 231 {
 232     buffer_need_bytes(wb, 50);
 233
 234     if(isnan(value) || isinf(value)) {
 235         buffer_strcat(wb, "null");
 236         return;
 237     }
 238     else
 239         wb->len += print_calculated_number(&wb->buffer[wb->len], value);
 240
 241     // terminate it
 242     buffer_need_bytes(wb, 1);
 243     wb->buffer[wb->len] = '\0';
 244
 245     buffer_overflow_check(wb);
 246 }
 247
 248 // generate a javascript date, the fastest possible way...
 249 void buffer_jsdate(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds)
 250 {
 251   //         10        20        30      = 35
 252     // 01234567890123456789012345678901234
 253     // Date(2014,04,01,03,28,20)
 254
 255     buffer_need_bytes(wb, 30);
 256
 257     char *b = &wb->buffer[wb->len], *p;
 258   unsigned int *q = (unsigned int *)b;
 259
 260   #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 261     *q++ = 0x65746144;  // "Date" backwards.
 262   #else
 263     *q++ = 0x44617465;  // "Date"
 264   #endif
 265   p = (char *)q;
 266
 267   *p++ = '(';
 268   *p++ = '0' + year / 1000; year %= 1000;
 269   *p++ = '0' + year / 100;  year %= 100;
 270   *p++ = '0' + year / 10;
 271   *p++ = '0' + year % 10;
 272   *p++ = ',';
 273   *p   = '0' + month / 10; if (*p != '0') p++;
 274   *p++ = '0' + month % 10;
 275   *p++ = ',';
 276   *p   = '0' + day / 10; if (*p != '0') p++;
 277   *p++ = '0' + day % 10;
 278   *p++ = ',';
 279   *p   = '0' + hours / 10; if (*p != '0') p++;
 280   *p++ = '0' + hours % 10;
 281   *p++ = ',';
 282   *p   = '0' + minutes / 10; if (*p != '0') p++;
 283   *p++ = '0' + minutes % 10;
 284   *p++ = ',';
 285   *p   = '0' + seconds / 10; if (*p != '0') p++;
 286   *p++ = '0' + seconds % 10;
 287
 288   unsigned short *r = (unsigned short *)p;
 289
 290 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 291     *r++ = 0x0029;  // ")\0" backwards.
 292   #else
 293     *r++ = 0x2900;  // ")\0"
 294   #endif
 295
 296     wb->len += (size_t)((char *)r - b - 1);
 297
 298     // terminate it
 299     wb->buffer[wb->len] = '\0';
 300     buffer_overflow_check(wb);
 301 }
 302
 303 // generate a date, the fastest possible way...
 304 void buffer_date(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds)
 305 {
 306     //         10        20        30      = 35
 307     // 01234567890123456789012345678901234
 308     // 2014-04-01 03:28:20
 309
 310     buffer_need_bytes(wb, 36);
 311
 312     char *b = &wb->buffer[wb->len];
 313   char *p = b;
 314
 315   *p++ = '0' + year / 1000; year %= 1000;
 316   *p++ = '0' + year / 100;  year %= 100;
 317   *p++ = '0' + year / 10;
 318   *p++ = '0' + year % 10;
 319   *p++ = '-';
 320   *p++ = '0' + month / 10;
 321   *p++ = '0' + month % 10;
 322   *p++ = '-';
 323   *p++ = '0' + day / 10;
 324   *p++ = '0' + day % 10;
 325   *p++ = ' ';
 326   *p++ = '0' + hours / 10;
 327   *p++ = '0' + hours % 10;
 328   *p++ = ':';
 329   *p++ = '0' + minutes / 10;
 330   *p++ = '0' + minutes % 10;
 331   *p++ = ':';
 332   *p++ = '0' + seconds / 10;
 333   *p++ = '0' + seconds % 10;
 334   *p = '\0';
 335
 336     wb->len += (size_t)(p - b);
 337
 338     // terminate it
 339     wb->buffer[wb->len] = '\0';
 340     buffer_overflow_check(wb);
 341 }
 342
 343 BUFFER *buffer_create(size_t size)
 344 {
 345     BUFFER *b;
 346
 347     debug(D_WEB_BUFFER, "Creating new web buffer of size %zu.", size);
 348
 349     b = callocz(1, sizeof(BUFFER));
 350     b->buffer = mallocz(size + sizeof(BUFFER_OVERFLOW_EOF) + 2);
 351     b->buffer[0] = '\0';
 352     b->size = size;
 353     b->contenttype = CT_TEXT_PLAIN;
 354     buffer_overflow_init(b);
 355     buffer_overflow_check(b);
 356
 357     return(b);
 358 }
 359
 360 void buffer_free(BUFFER *b)
 361 {
 362     buffer_overflow_check(b);
 363
 364     debug(D_WEB_BUFFER, "Freeing web buffer of size %zu.", b->size);
 365
 366     freez(b->buffer);
 367     freez(b);
 368 }
 369
 370 void buffer_increase(BUFFER *b, size_t free_size_required)
 371 {
 372     buffer_overflow_check(b);
 373
 374     size_t left = b->size - b->len;
 375
 376     if(left >= free_size_required) return;
 377
 378     size_t increase = free_size_required - left;
 379     if(increase < WEB_DATA_LENGTH_INCREASE_STEP) increase = WEB_DATA_LENGTH_INCREASE_STEP;
 380
 381     debug(D_WEB_BUFFER, "Increasing data buffer from size %zu to %zu.", b->size, b->size + increase);
 382
 383     b->buffer = reallocz(b->buffer, b->size + increase + sizeof(BUFFER_OVERFLOW_EOF) + 2);
 384     b->size += increase;
 385
 386     buffer_overflow_init(b);
 387     buffer_overflow_check(b);
 388 }