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
 147 void buffer_snprintf(BUFFER *wb, size_t len, const char *fmt, ...)
 148 {
 149     if(unlikely(!fmt || !*fmt)) return;
 150
 151     buffer_need_bytes(wb, len + 1);
 152
 153     va_list args;
 154     va_start(args, fmt);
 155     wb->len += vsnprintfz(&wb->buffer[wb->len], len, fmt, args);
 156     va_end(args);
 157
 158     buffer_overflow_check(wb);
 159
 160     // the buffer is \0 terminated by vsnprintfz
 161 }
 162
 163 void buffer_vsprintf(BUFFER *wb, const char *fmt, va_list args)
 164 {
 165     if(unlikely(!fmt || !*fmt)) return;
 166
 167     buffer_need_bytes(wb, 2);
 168
 169     size_t len = wb->size - wb->len - 1;
 170
 171     wb->len += vsnprintfz(&wb->buffer[wb->len], len, fmt, args);
 172
 173     buffer_overflow_check(wb);
 174
 175     // the buffer is \0 terminated by vsnprintfz
 176 }
 177
 178 void buffer_sprintf(BUFFER *wb, const char *fmt, ...)
 179 {
 180     if(unlikely(!fmt || !*fmt)) return;
 181
 182     buffer_need_bytes(wb, 2);
 183
 184     size_t len = wb->size - wb->len - 1;
 185     size_t wrote;
 186
 187     va_list args;
 188     va_start(args, fmt);
 189     wrote = (size_t) vsnprintfz(&wb->buffer[wb->len], len, fmt, args);
 190     va_end(args);
 191
 192     if(unlikely(wrote >= len)) {
 193         // truncated
 194         buffer_overflow_check(wb);
 195
 196         debug(D_WEB_BUFFER, "web_buffer_sprintf(): increasing web_buffer at position %zu, size = %zu\n", wb->len, wb->size);
 197         buffer_need_bytes(wb, len + WEB_DATA_LENGTH_INCREASE_STEP);
 198
 199         va_start(args, fmt);
 200         buffer_vsprintf(wb, fmt, args);
 201         va_end(args);
 202     }
 203     else
 204         wb->len += wrote;
 205
 206     // the buffer is \0 terminated by vsnprintf
 207 }
 208
 209
 210 void buffer_rrd_value(BUFFER *wb, calculated_number value)
 211 {
 212     buffer_need_bytes(wb, 50);
 213
 214     if(isnan(value) || isinf(value)) {
 215         buffer_strcat(wb, "null");
 216         return;
 217     }
 218     else
 219         wb->len += print_calculated_number(&wb->buffer[wb->len], value);
 220
 221     // terminate it
 222     buffer_need_bytes(wb, 1);
 223     wb->buffer[wb->len] = '\0';
 224
 225     buffer_overflow_check(wb);
 226 }
 227
 228 // generate a javascript date, the fastest possible way...
 229 void buffer_jsdate(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds)
 230 {
 231   //         10        20        30      = 35
 232     // 01234567890123456789012345678901234
 233     // Date(2014,04,01,03,28,20)
 234
 235     buffer_need_bytes(wb, 30);
 236
 237     char *b = &wb->buffer[wb->len], *p;
 238   unsigned int *q = (unsigned int *)b;
 239
 240   #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 241     *q++ = 0x65746144;  // "Date" backwards.
 242   #else
 243     *q++ = 0x44617465;  // "Date"
 244   #endif
 245   p = (char *)q;
 246
 247   *p++ = '(';
 248   *p++ = '0' + year / 1000; year %= 1000;
 249   *p++ = '0' + year / 100;  year %= 100;
 250   *p++ = '0' + year / 10;
 251   *p++ = '0' + year % 10;
 252   *p++ = ',';
 253   *p   = '0' + month / 10; if (*p != '0') p++;
 254   *p++ = '0' + month % 10;
 255   *p++ = ',';
 256   *p   = '0' + day / 10; if (*p != '0') p++;
 257   *p++ = '0' + day % 10;
 258   *p++ = ',';
 259   *p   = '0' + hours / 10; if (*p != '0') p++;
 260   *p++ = '0' + hours % 10;
 261   *p++ = ',';
 262   *p   = '0' + minutes / 10; if (*p != '0') p++;
 263   *p++ = '0' + minutes % 10;
 264   *p++ = ',';
 265   *p   = '0' + seconds / 10; if (*p != '0') p++;
 266   *p++ = '0' + seconds % 10;
 267
 268   unsigned short *r = (unsigned short *)p;
 269
 270 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 271     *r++ = 0x0029;  // ")\0" backwards.
 272   #else
 273     *r++ = 0x2900;  // ")\0"
 274   #endif
 275
 276     wb->len += (size_t)((char *)r - b - 1);
 277
 278     // terminate it
 279     wb->buffer[wb->len] = '\0';
 280     buffer_overflow_check(wb);
 281 }
 282
 283 // generate a date, the fastest possible way...
 284 void buffer_date(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds)
 285 {
 286     //         10        20        30      = 35
 287     // 01234567890123456789012345678901234
 288     // 2014-04-01 03:28:20
 289
 290     buffer_need_bytes(wb, 36);
 291
 292     char *b = &wb->buffer[wb->len];
 293   char *p = b;
 294
 295   *p++ = '0' + year / 1000; year %= 1000;
 296   *p++ = '0' + year / 100;  year %= 100;
 297   *p++ = '0' + year / 10;
 298   *p++ = '0' + year % 10;
 299   *p++ = '-';
 300   *p++ = '0' + month / 10;
 301   *p++ = '0' + month % 10;
 302   *p++ = '-';
 303   *p++ = '0' + day / 10;
 304   *p++ = '0' + day % 10;
 305   *p++ = ' ';
 306   *p++ = '0' + hours / 10;
 307   *p++ = '0' + hours % 10;
 308   *p++ = ':';
 309   *p++ = '0' + minutes / 10;
 310   *p++ = '0' + minutes % 10;
 311   *p++ = ':';
 312   *p++ = '0' + seconds / 10;
 313   *p++ = '0' + seconds % 10;
 314   *p = '\0';
 315
 316     wb->len += (size_t)(p - b);
 317
 318     // terminate it
 319     wb->buffer[wb->len] = '\0';
 320     buffer_overflow_check(wb);
 321 }
 322
 323 BUFFER *buffer_create(size_t size)
 324 {
 325     BUFFER *b;
 326
 327     debug(D_WEB_BUFFER, "Creating new web buffer of size %zu.", size);
 328
 329     b = callocz(1, sizeof(BUFFER));
 330     b->buffer = mallocz(size + sizeof(BUFFER_OVERFLOW_EOF) + 2);
 331     b->buffer[0] = '\0';
 332     b->size = size;
 333     b->contenttype = CT_TEXT_PLAIN;
 334     buffer_overflow_init(b);
 335     buffer_overflow_check(b);
 336
 337     return(b);
 338 }
 339
 340 void buffer_free(BUFFER *b)
 341 {
 342     buffer_overflow_check(b);
 343
 344     debug(D_WEB_BUFFER, "Freeing web buffer of size %zu.", b->size);
 345
 346     freez(b->buffer);
 347     freez(b);
 348 }
 349
 350 void buffer_increase(BUFFER *b, size_t free_size_required)
 351 {
 352     buffer_overflow_check(b);
 353
 354     size_t left = b->size - b->len;
 355
 356     if(left >= free_size_required) return;
 357
 358     size_t increase = free_size_required - left;
 359     if(increase < WEB_DATA_LENGTH_INCREASE_STEP) increase = WEB_DATA_LENGTH_INCREASE_STEP;
 360
 361     debug(D_WEB_BUFFER, "Increasing data buffer from size %zu to %zu.", b->size, b->size + increase);
 362
 363     b->buffer = reallocz(b->buffer, b->size + increase + sizeof(BUFFER_OVERFLOW_EOF) + 2);
 364     b->size += increase;
 365
 366     buffer_overflow_init(b);
 367     buffer_overflow_check(b);
 368 }