ucx/buffer.c

   1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   3  *
   4  * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  *   1. Redistributions of source code must retain the above copyright
  10  *      notice, this list of conditions and the following disclaimer.
  11  *
  12  *   2. Redistributions in binary form must reproduce the above copyright
  13  *      notice, this list of conditions and the following disclaimer in the
  14  *      documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "cx/buffer.h"
  30 #include "cx/utils.h"
  31
  32 #include <stdio.h>
  33 #include <string.h>
  34
  35 int cxBufferInit(
  36         CxBuffer *buffer,
  37         void *space,
  38         size_t capacity,
  39         CxAllocator const *allocator,
  40         int flags
  41 ) {
  42     if (allocator == NULL) allocator = cxDefaultAllocator;
  43     buffer->allocator = allocator;
  44     buffer->flags = flags;
  45     if (!space) {
  46         buffer->bytes = cxMalloc(allocator, capacity);
  47         if (buffer->bytes == NULL) {
  48             return 1;
  49         }
  50         buffer->flags |= CX_BUFFER_FREE_CONTENTS;
  51     } else {
  52         buffer->bytes = space;
  53     }
  54     buffer->capacity = capacity;
  55     buffer->size = 0;
  56     buffer->pos = 0;
  57
  58     buffer->flush_func = NULL;
  59     buffer->flush_target = NULL;
  60     buffer->flush_blkmax = 0;
  61     buffer->flush_blksize = 4096;
  62     buffer->flush_threshold = SIZE_MAX;
  63
  64     return 0;
  65 }
  66
  67 void cxBufferDestroy(CxBuffer *buffer) {
  68     if ((buffer->flags & CX_BUFFER_FREE_CONTENTS) == CX_BUFFER_FREE_CONTENTS) {
  69         cxFree(buffer->allocator, buffer->bytes);
  70     }
  71 }
  72
  73 int cxBufferSeek(
  74         CxBuffer *buffer,
  75         off_t offset,
  76         int whence
  77 ) {
  78     size_t npos;
  79     switch (whence) {
  80         case SEEK_CUR:
  81             npos = buffer->pos;
  82             break;
  83         case SEEK_END:
  84             npos = buffer->size;
  85             break;
  86         case SEEK_SET:
  87             npos = 0;
  88             break;
  89         default:
  90             return -1;
  91     }
  92
  93     size_t opos = npos;
  94     npos += offset;
  95
  96     if ((offset > 0 && npos < opos) || (offset < 0 && npos > opos)) {
  97         return -1;
  98     }
  99
 100     if (npos >= buffer->size) {
 101         return -1;
 102     } else {
 103         buffer->pos = npos;
 104         return 0;
 105     }
 106
 107 }
 108
 109 void cxBufferClear(CxBuffer *buffer) {
 110     memset(buffer->bytes, 0, buffer->size);
 111     buffer->size = 0;
 112     buffer->pos = 0;
 113 }
 114
 115 int cxBufferEof(CxBuffer const *buffer) {
 116     return buffer->pos >= buffer->size;
 117 }
 118
 119 int cxBufferMinimumCapacity(
 120         CxBuffer *buffer,
 121         size_t newcap
 122 ) {
 123     if (newcap <= buffer->capacity) {
 124         return 0;
 125     }
 126
 127     if (cxReallocate(buffer->allocator,
 128                      (void **) &buffer->bytes, newcap) == 0) {
 129         buffer->capacity = newcap;
 130         return 0;
 131     } else {
 132         return -1;
 133     }
 134 }
 135
 136 /**
 137  * Helps flushing data to the flush target of a buffer.
 138  *
 139  * @param buffer the buffer containing the config
 140  * @param space the data to flush
 141  * @param size the element size
 142  * @param nitems the number of items
 143  * @return the number of items flushed
 144  */
 145 static size_t cx_buffer_write_flush_helper(
 146         CxBuffer *buffer,
 147         unsigned char const *space,
 148         size_t size,
 149         size_t nitems
 150 ) {
 151     size_t pos = 0;
 152     size_t remaining = nitems;
 153     size_t max_items = buffer->flush_blksize / size;
 154     while (remaining > 0) {
 155         size_t items = remaining > max_items ? max_items : remaining;
 156         size_t flushed = buffer->flush_func(
 157                 space + pos,
 158                 size, items,
 159                 buffer->flush_target);
 160         if (flushed > 0) {
 161             pos += (flushed * size);
 162             remaining -= flushed;
 163         } else {
 164             // if no bytes can be flushed out anymore, we give up
 165             break;
 166         }
 167     }
 168     return nitems - remaining;
 169 }
 170
 171 size_t cxBufferWrite(
 172         void const *ptr,
 173         size_t size,
 174         size_t nitems,
 175         CxBuffer *buffer
 176 ) {
 177     // optimize for easy case
 178     if (size == 1 && (buffer->capacity - buffer->pos) >= nitems) {
 179         memcpy(buffer->bytes + buffer->pos, ptr, nitems);
 180         buffer->pos += nitems;
 181         if (buffer->pos > buffer->size) {
 182             buffer->size = buffer->pos;
 183         }
 184         return nitems;
 185     }
 186
 187     size_t len;
 188     size_t nitems_out = nitems;
 189     if (cx_szmul(size, nitems, &len)) {
 190         return 0;
 191     }
 192     size_t required = buffer->pos + len;
 193     if (buffer->pos > required) {
 194         return 0;
 195     }
 196
 197     bool perform_flush = false;
 198     if (required > buffer->capacity) {
 199         if ((buffer->flags & CX_BUFFER_AUTO_EXTEND) == CX_BUFFER_AUTO_EXTEND && required) {
 200             if (buffer->flush_blkmax > 0 && required > buffer->flush_threshold) {
 201                 perform_flush = true;
 202             } else {
 203                 if (cxBufferMinimumCapacity(buffer, required)) {
 204                     return 0;
 205                 }
 206             }
 207         } else {
 208             if (buffer->flush_blkmax > 0) {
 209                 perform_flush = true;
 210             } else {
 211                 // truncate data to be written, if we can neither extend nor flush
 212                 len = buffer->capacity - buffer->pos;
 213                 if (size > 1) {
 214                     len -= len % size;
 215                 }
 216                 nitems_out = len / size;
 217             }
 218         }
 219     }
 220
 221     if (len == 0) {
 222         return len;
 223     }
 224
 225     if (perform_flush) {
 226         size_t flush_max;
 227         if (cx_szmul(buffer->flush_blkmax, buffer->flush_blksize, &flush_max)) {
 228             return 0;
 229         }
 230         size_t flush_pos = buffer->flush_func == NULL || buffer->flush_target == NULL
 231                            ? buffer->pos
 232                            : cx_buffer_write_flush_helper(buffer, buffer->bytes, 1, buffer->pos);
 233         if (flush_pos == buffer->pos) {
 234             // entire buffer has been flushed, we can reset
 235             buffer->size = buffer->pos = 0;
 236
 237             size_t items_flush; // how many items can also be directly flushed
 238             size_t items_keep; // how many items have to be written to the buffer
 239
 240             items_flush = flush_max >= required ? nitems : (flush_max - flush_pos) / size;
 241             if (items_flush > 0) {
 242                 items_flush = cx_buffer_write_flush_helper(buffer, ptr, size, items_flush / size);
 243                 // in case we could not flush everything, keep the rest
 244             }
 245             items_keep = nitems - items_flush;
 246             if (items_keep > 0) {
 247                 // try again with the remaining stuff
 248                 unsigned char const *new_ptr = ptr;
 249                 new_ptr += items_flush * size;
 250                 // report the directly flushed items as written plus the remaining stuff
 251                 return items_flush + cxBufferWrite(new_ptr, size, items_keep, buffer);
 252             } else {
 253                 // all items have been flushed - report them as written
 254                 return nitems;
 255             }
 256         } else if (flush_pos == 0) {
 257             // nothing could be flushed at all, we immediately give up without writing any data
 258             return 0;
 259         } else {
 260             // we were partially successful, we shift left and try again
 261             cxBufferShiftLeft(buffer, flush_pos);
 262             return cxBufferWrite(ptr, size, nitems, buffer);
 263         }
 264     } else {
 265         memcpy(buffer->bytes + buffer->pos, ptr, len);
 266         buffer->pos += len;
 267         if (buffer->pos > buffer->size) {
 268             buffer->size = buffer->pos;
 269         }
 270         return nitems_out;
 271     }
 272
 273 }
 274
 275 int cxBufferPut(
 276         CxBuffer *buffer,
 277         int c
 278 ) {
 279     c &= 0xFF;
 280     unsigned char const ch = c;
 281     if (cxBufferWrite(&ch, 1, 1, buffer) == 1) {
 282         return c;
 283     } else {
 284         return EOF;
 285     }
 286 }
 287
 288 size_t cxBufferPutString(
 289         CxBuffer *buffer,
 290         const char *str
 291 ) {
 292     return cxBufferWrite(str, 1, strlen(str), buffer);
 293 }
 294
 295 size_t cxBufferRead(
 296         void *ptr,
 297         size_t size,
 298         size_t nitems,
 299         CxBuffer *buffer
 300 ) {
 301     size_t len;
 302     if (cx_szmul(size, nitems, &len)) {
 303         return 0;
 304     }
 305     if (buffer->pos + len > buffer->size) {
 306         len = buffer->size - buffer->pos;
 307         if (size > 1) len -= len % size;
 308     }
 309
 310     if (len <= 0) {
 311         return len;
 312     }
 313
 314     memcpy(ptr, buffer->bytes + buffer->pos, len);
 315     buffer->pos += len;
 316
 317     return len / size;
 318 }
 319
 320 int cxBufferGet(CxBuffer *buffer) {
 321     if (cxBufferEof(buffer)) {
 322         return EOF;
 323     } else {
 324         int c = buffer->bytes[buffer->pos];
 325         buffer->pos++;
 326         return c;
 327     }
 328 }
 329
 330 int cxBufferShiftLeft(
 331         CxBuffer *buffer,
 332         size_t shift
 333 ) {
 334     if (shift >= buffer->size) {
 335         buffer->pos = buffer->size = 0;
 336     } else {
 337         memmove(buffer->bytes, buffer->bytes + shift, buffer->size - shift);
 338         buffer->size -= shift;
 339
 340         if (buffer->pos >= shift) {
 341             buffer->pos -= shift;
 342         } else {
 343             buffer->pos = 0;
 344         }
 345     }
 346     return 0;
 347 }
 348
 349 int cxBufferShiftRight(
 350         CxBuffer *buffer,
 351         size_t shift
 352 ) {
 353     size_t req_capacity = buffer->size + shift;
 354     size_t movebytes;
 355
 356     // auto extend buffer, if required and enabled
 357     if (buffer->capacity < req_capacity) {
 358         if ((buffer->flags & CX_BUFFER_AUTO_EXTEND) == CX_BUFFER_AUTO_EXTEND) {
 359             if (cxBufferMinimumCapacity(buffer, req_capacity)) {
 360                 return 1;
 361             }
 362             movebytes = buffer->size;
 363         } else {
 364             movebytes = buffer->capacity - shift;
 365         }
 366     } else {
 367         movebytes = buffer->size;
 368     }
 369
 370     memmove(buffer->bytes + shift, buffer->bytes, movebytes);
 371     buffer->size = shift + movebytes;
 372
 373     buffer->pos += shift;
 374     if (buffer->pos > buffer->size) {
 375         buffer->pos = buffer->size;
 376     }
 377
 378     return 0;
 379 }
 380
 381 int cxBufferShift(
 382         CxBuffer *buffer,
 383         off_t shift
 384 ) {
 385     if (shift < 0) {
 386         return cxBufferShiftLeft(buffer, (size_t) (-shift));
 387     } else if (shift > 0) {
 388         return cxBufferShiftRight(buffer, (size_t) shift);
 389     } else {
 390         return 0;
 391     }
 392 }