lib/nghttp2_buf.c

   1 /*
   2  * nghttp2 - HTTP/2 C Library
   3  *
   4  * Copyright (c) 2014 Tatsuhiro Tsujikawa
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be
  15  * included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25 #include "nghttp2_buf.h"
  26
  27 #include <stdio.h>
  28
  29 #include "nghttp2_helper.h"
  30
  31 void nghttp2_buf_init(nghttp2_buf *buf) {
  32   buf->begin = NULL;
  33   buf->end = NULL;
  34   buf->pos = NULL;
  35   buf->last = NULL;
  36   buf->mark = NULL;
  37 }
  38
  39 int nghttp2_buf_init2(nghttp2_buf *buf, size_t initial, nghttp2_mem *mem) {
  40   nghttp2_buf_init(buf);
  41   return nghttp2_buf_reserve(buf, initial, mem);
  42 }
  43
  44 void nghttp2_buf_free(nghttp2_buf *buf, nghttp2_mem *mem) {
  45   if (buf == NULL) {
  46     return;
  47   }
  48
  49   nghttp2_mem_free(mem, buf->begin);
  50   buf->begin = NULL;
  51 }
  52
  53 int nghttp2_buf_reserve(nghttp2_buf *buf, size_t new_cap, nghttp2_mem *mem) {
  54   uint8_t *ptr;
  55   size_t cap;
  56
  57   cap = nghttp2_buf_cap(buf);
  58
  59   if (cap >= new_cap) {
  60     return 0;
  61   }
  62
  63   new_cap = nghttp2_max(new_cap, cap * 2);
  64
  65   ptr = nghttp2_mem_realloc(mem, buf->begin, new_cap);
  66   if (ptr == NULL) {
  67     return NGHTTP2_ERR_NOMEM;
  68   }
  69
  70   buf->pos = ptr + (buf->pos - buf->begin);
  71   buf->last = ptr + (buf->last - buf->begin);
  72   buf->mark = ptr + (buf->mark - buf->begin);
  73   buf->begin = ptr;
  74   buf->end = ptr + new_cap;
  75
  76   return 0;
  77 }
  78
  79 void nghttp2_buf_reset(nghttp2_buf *buf) {
  80   buf->pos = buf->last = buf->mark = buf->begin;
  81 }
  82
  83 void nghttp2_buf_wrap_init(nghttp2_buf *buf, uint8_t *begin, size_t len) {
  84   buf->begin = buf->pos = buf->last = buf->mark = begin;
  85   buf->end = begin + len;
  86 }
  87
  88 static int buf_chain_new(nghttp2_buf_chain **chain, size_t chunk_length,
  89                          nghttp2_mem *mem) {
  90   int rv;
  91
  92   *chain = nghttp2_mem_malloc(mem, sizeof(nghttp2_buf_chain));
  93   if (*chain == NULL) {
  94     return NGHTTP2_ERR_NOMEM;
  95   }
  96
  97   (*chain)->next = NULL;
  98
  99   rv = nghttp2_buf_init2(&(*chain)->buf, chunk_length, mem);
 100   if (rv != 0) {
 101     nghttp2_mem_free(mem, *chain);
 102     return NGHTTP2_ERR_NOMEM;
 103   }
 104
 105   return 0;
 106 }
 107
 108 static void buf_chain_del(nghttp2_buf_chain *chain, nghttp2_mem *mem) {
 109   nghttp2_buf_free(&chain->buf, mem);
 110   nghttp2_mem_free(mem, chain);
 111 }
 112
 113 int nghttp2_bufs_init(nghttp2_bufs *bufs, size_t chunk_length, size_t max_chunk,
 114                       nghttp2_mem *mem) {
 115   return nghttp2_bufs_init2(bufs, chunk_length, max_chunk, 0, mem);
 116 }
 117
 118 int nghttp2_bufs_init2(nghttp2_bufs *bufs, size_t chunk_length,
 119                        size_t max_chunk, size_t offset, nghttp2_mem *mem) {
 120   return nghttp2_bufs_init3(bufs, chunk_length, max_chunk, max_chunk, offset,
 121                             mem);
 122 }
 123
 124 int nghttp2_bufs_init3(nghttp2_bufs *bufs, size_t chunk_length,
 125                        size_t max_chunk, size_t chunk_keep, size_t offset,
 126                        nghttp2_mem *mem) {
 127   int rv;
 128   nghttp2_buf_chain *chain;
 129
 130   if (chunk_keep == 0 || max_chunk < chunk_keep || chunk_length < offset) {
 131     return NGHTTP2_ERR_INVALID_ARGUMENT;
 132   }
 133
 134   rv = buf_chain_new(&chain, chunk_length, mem);
 135   if (rv != 0) {
 136     return rv;
 137   }
 138
 139   bufs->mem = mem;
 140   bufs->offset = offset;
 141
 142   bufs->head = chain;
 143   bufs->cur = bufs->head;
 144
 145   nghttp2_buf_shift_right(&bufs->cur->buf, offset);
 146
 147   bufs->chunk_length = chunk_length;
 148   bufs->chunk_used = 1;
 149   bufs->max_chunk = max_chunk;
 150   bufs->chunk_keep = chunk_keep;
 151
 152   return 0;
 153 }
 154
 155 int nghttp2_bufs_realloc(nghttp2_bufs *bufs, size_t chunk_length) {
 156   int rv;
 157   nghttp2_buf_chain *chain;
 158
 159   if (chunk_length < bufs->offset) {
 160     return NGHTTP2_ERR_INVALID_ARGUMENT;
 161   }
 162
 163   rv = buf_chain_new(&chain, chunk_length, bufs->mem);
 164   if (rv != 0) {
 165     return rv;
 166   }
 167
 168   nghttp2_bufs_free(bufs);
 169
 170   bufs->head = chain;
 171   bufs->cur = bufs->head;
 172
 173   nghttp2_buf_shift_right(&bufs->cur->buf, bufs->offset);
 174
 175   bufs->chunk_length = chunk_length;
 176   bufs->chunk_used = 1;
 177
 178   return 0;
 179 }
 180
 181 void nghttp2_bufs_free(nghttp2_bufs *bufs) {
 182   nghttp2_buf_chain *chain, *next_chain;
 183
 184   if (bufs == NULL) {
 185     return;
 186   }
 187
 188   for (chain = bufs->head; chain;) {
 189     next_chain = chain->next;
 190
 191     buf_chain_del(chain, bufs->mem);
 192
 193     chain = next_chain;
 194   }
 195
 196   bufs->head = NULL;
 197 }
 198
 199 int nghttp2_bufs_wrap_init(nghttp2_bufs *bufs, uint8_t *begin, size_t len,
 200                            nghttp2_mem *mem) {
 201   nghttp2_buf_chain *chain;
 202
 203   chain = nghttp2_mem_malloc(mem, sizeof(nghttp2_buf_chain));
 204   if (chain == NULL) {
 205     return NGHTTP2_ERR_NOMEM;
 206   }
 207
 208   chain->next = NULL;
 209
 210   nghttp2_buf_wrap_init(&chain->buf, begin, len);
 211
 212   bufs->mem = mem;
 213   bufs->offset = 0;
 214
 215   bufs->head = chain;
 216   bufs->cur = bufs->head;
 217
 218   bufs->chunk_length = len;
 219   bufs->chunk_used = 1;
 220   bufs->max_chunk = 1;
 221   bufs->chunk_keep = 1;
 222
 223   return 0;
 224 }
 225
 226 void nghttp2_bufs_wrap_free(nghttp2_bufs *bufs) {
 227   if (bufs == NULL) {
 228     return;
 229   }
 230
 231   nghttp2_mem_free(bufs->mem, bufs->head);
 232   bufs->head = NULL;
 233 }
 234
 235 void nghttp2_bufs_seek_last_present(nghttp2_bufs *bufs) {
 236   nghttp2_buf_chain *ci;
 237
 238   for (ci = bufs->cur; ci; ci = ci->next) {
 239     if (nghttp2_buf_len(&ci->buf) == 0) {
 240       return;
 241     } else {
 242       bufs->cur = ci;
 243     }
 244   }
 245 }
 246
 247 ssize_t nghttp2_bufs_len(nghttp2_bufs *bufs) {
 248   nghttp2_buf_chain *ci;
 249   ssize_t len;
 250
 251   len = 0;
 252   for (ci = bufs->head; ci; ci = ci->next) {
 253     len += nghttp2_buf_len(&ci->buf);
 254   }
 255
 256   return len;
 257 }
 258
 259 static ssize_t bufs_avail(nghttp2_bufs *bufs) {
 260   return (ssize_t)(nghttp2_buf_avail(&bufs->cur->buf) +
 261                    (bufs->chunk_length - bufs->offset) *
 262                        (bufs->max_chunk - bufs->chunk_used));
 263 }
 264
 265 static int bufs_alloc_chain(nghttp2_bufs *bufs) {
 266   int rv;
 267   nghttp2_buf_chain *chain;
 268
 269   if (bufs->cur->next) {
 270     bufs->cur = bufs->cur->next;
 271
 272     return 0;
 273   }
 274
 275   if (bufs->max_chunk == bufs->chunk_used) {
 276     return NGHTTP2_ERR_BUFFER_ERROR;
 277   }
 278
 279   rv = buf_chain_new(&chain, bufs->chunk_length, bufs->mem);
 280   if (rv != 0) {
 281     return rv;
 282   }
 283
 284   DEBUGF(fprintf(stderr,
 285                  "new buffer %zu bytes allocated for bufs %p, used %zu\n",
 286                  bufs->chunk_length, bufs, bufs->chunk_used));
 287
 288   ++bufs->chunk_used;
 289
 290   bufs->cur->next = chain;
 291   bufs->cur = chain;
 292
 293   nghttp2_buf_shift_right(&bufs->cur->buf, bufs->offset);
 294
 295   return 0;
 296 }
 297
 298 int nghttp2_bufs_add(nghttp2_bufs *bufs, const void *data, size_t len) {
 299   int rv;
 300   size_t nwrite;
 301   nghttp2_buf *buf;
 302   const uint8_t *p;
 303
 304   if (bufs_avail(bufs) < (ssize_t)len) {
 305     return NGHTTP2_ERR_BUFFER_ERROR;
 306   }
 307
 308   p = data;
 309
 310   while (len) {
 311     buf = &bufs->cur->buf;
 312
 313     nwrite = nghttp2_min((size_t)nghttp2_buf_avail(buf), len);
 314     if (nwrite == 0) {
 315       rv = bufs_alloc_chain(bufs);
 316       if (rv != 0) {
 317         return rv;
 318       }
 319       continue;
 320     }
 321
 322     buf->last = nghttp2_cpymem(buf->last, p, nwrite);
 323     p += len;
 324     len -= nwrite;
 325   }
 326
 327   return 0;
 328 }
 329
 330 static int bufs_ensure_addb(nghttp2_bufs *bufs) {
 331   int rv;
 332   nghttp2_buf *buf;
 333
 334   buf = &bufs->cur->buf;
 335
 336   if (nghttp2_buf_avail(buf) > 0) {
 337     return 0;
 338   }
 339
 340   rv = bufs_alloc_chain(bufs);
 341   if (rv != 0) {
 342     return rv;
 343   }
 344
 345   return 0;
 346 }
 347
 348 int nghttp2_bufs_addb(nghttp2_bufs *bufs, uint8_t b) {
 349   int rv;
 350
 351   rv = bufs_ensure_addb(bufs);
 352   if (rv != 0) {
 353     return rv;
 354   }
 355
 356   *bufs->cur->buf.last++ = b;
 357
 358   return 0;
 359 }
 360
 361 int nghttp2_bufs_addb_hold(nghttp2_bufs *bufs, uint8_t b) {
 362   int rv;
 363
 364   rv = bufs_ensure_addb(bufs);
 365   if (rv != 0) {
 366     return rv;
 367   }
 368
 369   *bufs->cur->buf.last = b;
 370
 371   return 0;
 372 }
 373
 374 int nghttp2_bufs_orb(nghttp2_bufs *bufs, uint8_t b) {
 375   int rv;
 376
 377   rv = bufs_ensure_addb(bufs);
 378   if (rv != 0) {
 379     return rv;
 380   }
 381
 382   *bufs->cur->buf.last++ |= b;
 383
 384   return 0;
 385 }
 386
 387 int nghttp2_bufs_orb_hold(nghttp2_bufs *bufs, uint8_t b) {
 388   int rv;
 389
 390   rv = bufs_ensure_addb(bufs);
 391   if (rv != 0) {
 392     return rv;
 393   }
 394
 395   *bufs->cur->buf.last |= b;
 396
 397   return 0;
 398 }
 399
 400 ssize_t nghttp2_bufs_remove(nghttp2_bufs *bufs, uint8_t **out) {
 401   size_t len;
 402   nghttp2_buf_chain *chain;
 403   nghttp2_buf *buf;
 404   uint8_t *res;
 405   nghttp2_buf resbuf;
 406
 407   len = 0;
 408
 409   for (chain = bufs->head; chain; chain = chain->next) {
 410     len += nghttp2_buf_len(&chain->buf);
 411   }
 412
 413   if (!len) {
 414     res = NULL;
 415   } else {
 416     res = nghttp2_mem_malloc(bufs->mem, len);
 417
 418     if (res == NULL) {
 419       return NGHTTP2_ERR_NOMEM;
 420     }
 421   }
 422
 423   nghttp2_buf_wrap_init(&resbuf, res, len);
 424
 425   for (chain = bufs->head; chain; chain = chain->next) {
 426     buf = &chain->buf;
 427
 428     if (resbuf.last) {
 429       resbuf.last = nghttp2_cpymem(resbuf.last, buf->pos, nghttp2_buf_len(buf));
 430     }
 431
 432     nghttp2_buf_reset(buf);
 433     nghttp2_buf_shift_right(&chain->buf, bufs->offset);
 434   }
 435
 436   bufs->cur = bufs->head;
 437
 438   *out = res;
 439
 440   return (ssize_t)len;
 441 }
 442
 443 void nghttp2_bufs_reset(nghttp2_bufs *bufs) {
 444   nghttp2_buf_chain *chain, *ci;
 445   size_t k;
 446
 447   k = bufs->chunk_keep;
 448
 449   for (ci = bufs->head; ci; ci = ci->next) {
 450     nghttp2_buf_reset(&ci->buf);
 451     nghttp2_buf_shift_right(&ci->buf, bufs->offset);
 452
 453     if (--k == 0) {
 454       break;
 455     }
 456   }
 457
 458   if (ci) {
 459     chain = ci->next;
 460     ci->next = NULL;
 461
 462     for (ci = chain; ci;) {
 463       chain = ci->next;
 464
 465       buf_chain_del(ci, bufs->mem);
 466
 467       ci = chain;
 468     }
 469
 470     bufs->chunk_used = bufs->chunk_keep;
 471   }
 472
 473   bufs->cur = bufs->head;
 474 }
 475
 476 int nghttp2_bufs_advance(nghttp2_bufs *bufs) { return bufs_alloc_chain(bufs); }
 477
 478 int nghttp2_bufs_next_present(nghttp2_bufs *bufs) {
 479   nghttp2_buf_chain *chain;
 480
 481   chain = bufs->cur->next;
 482
 483   return chain && nghttp2_buf_len(&chain->buf);
 484 }