deps/libchdr/deps/zlib-1.3.1/gzwrite.c

   1 /* gzwrite.c -- zlib functions for writing gzip files
   2  * Copyright (C) 2004-2019 Mark Adler
   3  * For conditions of distribution and use, see copyright notice in zlib.h
   4  */
   5
   6 #include "gzguts.h"
   7
   8 /* Initialize state for writing a gzip file.  Mark initialization by setting
   9    state->size to non-zero.  Return -1 on a memory allocation failure, or 0 on
  10    success. */
  11 local int gz_init(gz_statep state) {
  12     int ret;
  13     z_streamp strm = &(state->strm);
  14
  15     /* allocate input buffer (double size for gzprintf) */
  16     state->in = (unsigned char *)malloc(state->want << 1);
  17     if (state->in == NULL) {
  18         gz_error(state, Z_MEM_ERROR, "out of memory");
  19         return -1;
  20     }
  21
  22     /* only need output buffer and deflate state if compressing */
  23     if (!state->direct) {
  24         /* allocate output buffer */
  25         state->out = (unsigned char *)malloc(state->want);
  26         if (state->out == NULL) {
  27             free(state->in);
  28             gz_error(state, Z_MEM_ERROR, "out of memory");
  29             return -1;
  30         }
  31
  32         /* allocate deflate memory, set up for gzip compression */
  33         strm->zalloc = Z_NULL;
  34         strm->zfree = Z_NULL;
  35         strm->opaque = Z_NULL;
  36         ret = deflateInit2(strm, state->level, Z_DEFLATED,
  37                            MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
  38         if (ret != Z_OK) {
  39             free(state->out);
  40             free(state->in);
  41             gz_error(state, Z_MEM_ERROR, "out of memory");
  42             return -1;
  43         }
  44         strm->next_in = NULL;
  45     }
  46
  47     /* mark state as initialized */
  48     state->size = state->want;
  49
  50     /* initialize write buffer if compressing */
  51     if (!state->direct) {
  52         strm->avail_out = state->size;
  53         strm->next_out = state->out;
  54         state->x.next = strm->next_out;
  55     }
  56     return 0;
  57 }
  58
  59 /* Compress whatever is at avail_in and next_in and write to the output file.
  60    Return -1 if there is an error writing to the output file or if gz_init()
  61    fails to allocate memory, otherwise 0.  flush is assumed to be a valid
  62    deflate() flush value.  If flush is Z_FINISH, then the deflate() state is
  63    reset to start a new gzip stream.  If gz->direct is true, then simply write
  64    to the output file without compressing, and ignore flush. */
  65 local int gz_comp(gz_statep state, int flush) {
  66     int ret, writ;
  67     unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
  68     z_streamp strm = &(state->strm);
  69
  70     /* allocate memory if this is the first time through */
  71     if (state->size == 0 && gz_init(state) == -1)
  72         return -1;
  73
  74     /* write directly if requested */
  75     if (state->direct) {
  76         while (strm->avail_in) {
  77             put = strm->avail_in > max ? max : strm->avail_in;
  78             writ = write(state->fd, strm->next_in, put);
  79             if (writ < 0) {
  80                 gz_error(state, Z_ERRNO, zstrerror());
  81                 return -1;
  82             }
  83             strm->avail_in -= (unsigned)writ;
  84             strm->next_in += writ;
  85         }
  86         return 0;
  87     }
  88
  89     /* check for a pending reset */
  90     if (state->reset) {
  91         /* don't start a new gzip member unless there is data to write */
  92         if (strm->avail_in == 0)
  93             return 0;
  94         deflateReset(strm);
  95         state->reset = 0;
  96     }
  97
  98     /* run deflate() on provided input until it produces no more output */
  99     ret = Z_OK;
 100     do {
 101         /* write out current buffer contents if full, or if flushing, but if
 102            doing Z_FINISH then don't write until we get to Z_STREAM_END */
 103         if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
 104             (flush != Z_FINISH || ret == Z_STREAM_END))) {
 105             while (strm->next_out > state->x.next) {
 106                 put = strm->next_out - state->x.next > (int)max ? max :
 107                       (unsigned)(strm->next_out - state->x.next);
 108                 writ = write(state->fd, state->x.next, put);
 109                 if (writ < 0) {
 110                     gz_error(state, Z_ERRNO, zstrerror());
 111                     return -1;
 112                 }
 113                 state->x.next += writ;
 114             }
 115             if (strm->avail_out == 0) {
 116                 strm->avail_out = state->size;
 117                 strm->next_out = state->out;
 118                 state->x.next = state->out;
 119             }
 120         }
 121
 122         /* compress */
 123         have = strm->avail_out;
 124         ret = deflate(strm, flush);
 125         if (ret == Z_STREAM_ERROR) {
 126             gz_error(state, Z_STREAM_ERROR,
 127                       "internal error: deflate stream corrupt");
 128             return -1;
 129         }
 130         have -= strm->avail_out;
 131     } while (have);
 132
 133     /* if that completed a deflate stream, allow another to start */
 134     if (flush == Z_FINISH)
 135         state->reset = 1;
 136
 137     /* all done, no errors */
 138     return 0;
 139 }
 140
 141 /* Compress len zeros to output.  Return -1 on a write error or memory
 142    allocation failure by gz_comp(), or 0 on success. */
 143 local int gz_zero(gz_statep state, z_off64_t len) {
 144     int first;
 145     unsigned n;
 146     z_streamp strm = &(state->strm);
 147
 148     /* consume whatever's left in the input buffer */
 149     if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
 150         return -1;
 151
 152     /* compress len zeros (len guaranteed > 0) */
 153     first = 1;
 154     while (len) {
 155         n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
 156             (unsigned)len : state->size;
 157         if (first) {
 158             memset(state->in, 0, n);
 159             first = 0;
 160         }
 161         strm->avail_in = n;
 162         strm->next_in = state->in;
 163         state->x.pos += n;
 164         if (gz_comp(state, Z_NO_FLUSH) == -1)
 165             return -1;
 166         len -= n;
 167     }
 168     return 0;
 169 }
 170
 171 /* Write len bytes from buf to file.  Return the number of bytes written.  If
 172    the returned value is less than len, then there was an error. */
 173 local z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len) {
 174     z_size_t put = len;
 175
 176     /* if len is zero, avoid unnecessary operations */
 177     if (len == 0)
 178         return 0;
 179
 180     /* allocate memory if this is the first time through */
 181     if (state->size == 0 && gz_init(state) == -1)
 182         return 0;
 183
 184     /* check for seek request */
 185     if (state->seek) {
 186         state->seek = 0;
 187         if (gz_zero(state, state->skip) == -1)
 188             return 0;
 189     }
 190
 191     /* for small len, copy to input buffer, otherwise compress directly */
 192     if (len < state->size) {
 193         /* copy to input buffer, compress when full */
 194         do {
 195             unsigned have, copy;
 196
 197             if (state->strm.avail_in == 0)
 198                 state->strm.next_in = state->in;
 199             have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
 200                               state->in);
 201             copy = state->size - have;
 202             if (copy > len)
 203                 copy = (unsigned)len;
 204             memcpy(state->in + have, buf, copy);
 205             state->strm.avail_in += copy;
 206             state->x.pos += copy;
 207             buf = (const char *)buf + copy;
 208             len -= copy;
 209             if (len && gz_comp(state, Z_NO_FLUSH) == -1)
 210                 return 0;
 211         } while (len);
 212     }
 213     else {
 214         /* consume whatever's left in the input buffer */
 215         if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
 216             return 0;
 217
 218         /* directly compress user buffer to file */
 219         state->strm.next_in = (z_const Bytef *)buf;
 220         do {
 221             unsigned n = (unsigned)-1;
 222             if (n > len)
 223                 n = (unsigned)len;
 224             state->strm.avail_in = n;
 225             state->x.pos += n;
 226             if (gz_comp(state, Z_NO_FLUSH) == -1)
 227                 return 0;
 228             len -= n;
 229         } while (len);
 230     }
 231
 232     /* input was all buffered or compressed */
 233     return put;
 234 }
 235
 236 /* -- see zlib.h -- */
 237 int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len) {
 238     gz_statep state;
 239
 240     /* get internal structure */
 241     if (file == NULL)
 242         return 0;
 243     state = (gz_statep)file;
 244
 245     /* check that we're writing and that there's no error */
 246     if (state->mode != GZ_WRITE || state->err != Z_OK)
 247         return 0;
 248
 249     /* since an int is returned, make sure len fits in one, otherwise return
 250        with an error (this avoids a flaw in the interface) */
 251     if ((int)len < 0) {
 252         gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
 253         return 0;
 254     }
 255
 256     /* write len bytes from buf (the return value will fit in an int) */
 257     return (int)gz_write(state, buf, len);
 258 }
 259
 260 /* -- see zlib.h -- */
 261 z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size, z_size_t nitems,
 262                           gzFile file) {
 263     z_size_t len;
 264     gz_statep state;
 265
 266     /* get internal structure */
 267     if (file == NULL)
 268         return 0;
 269     state = (gz_statep)file;
 270
 271     /* check that we're writing and that there's no error */
 272     if (state->mode != GZ_WRITE || state->err != Z_OK)
 273         return 0;
 274
 275     /* compute bytes to read -- error on overflow */
 276     len = nitems * size;
 277     if (size && len / size != nitems) {
 278         gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
 279         return 0;
 280     }
 281
 282     /* write len bytes to buf, return the number of full items written */
 283     return len ? gz_write(state, buf, len) / size : 0;
 284 }
 285
 286 /* -- see zlib.h -- */
 287 int ZEXPORT gzputc(gzFile file, int c) {
 288     unsigned have;
 289     unsigned char buf[1];
 290     gz_statep state;
 291     z_streamp strm;
 292
 293     /* get internal structure */
 294     if (file == NULL)
 295         return -1;
 296     state = (gz_statep)file;
 297     strm = &(state->strm);
 298
 299     /* check that we're writing and that there's no error */
 300     if (state->mode != GZ_WRITE || state->err != Z_OK)
 301         return -1;
 302
 303     /* check for seek request */
 304     if (state->seek) {
 305         state->seek = 0;
 306         if (gz_zero(state, state->skip) == -1)
 307             return -1;
 308     }
 309
 310     /* try writing to input buffer for speed (state->size == 0 if buffer not
 311        initialized) */
 312     if (state->size) {
 313         if (strm->avail_in == 0)
 314             strm->next_in = state->in;
 315         have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
 316         if (have < state->size) {
 317             state->in[have] = (unsigned char)c;
 318             strm->avail_in++;
 319             state->x.pos++;
 320             return c & 0xff;
 321         }
 322     }
 323
 324     /* no room in buffer or not initialized, use gz_write() */
 325     buf[0] = (unsigned char)c;
 326     if (gz_write(state, buf, 1) != 1)
 327         return -1;
 328     return c & 0xff;
 329 }
 330
 331 /* -- see zlib.h -- */
 332 int ZEXPORT gzputs(gzFile file, const char *s) {
 333     z_size_t len, put;
 334     gz_statep state;
 335
 336     /* get internal structure */
 337     if (file == NULL)
 338         return -1;
 339     state = (gz_statep)file;
 340
 341     /* check that we're writing and that there's no error */
 342     if (state->mode != GZ_WRITE || state->err != Z_OK)
 343         return -1;
 344
 345     /* write string */
 346     len = strlen(s);
 347     if ((int)len < 0 || (unsigned)len != len) {
 348         gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
 349         return -1;
 350     }
 351     put = gz_write(state, s, len);
 352     return put < len ? -1 : (int)len;
 353 }
 354
 355 #if defined(STDC) || defined(Z_HAVE_STDARG_H)
 356 #include <stdarg.h>
 357
 358 /* -- see zlib.h -- */
 359 int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va) {
 360     int len;
 361     unsigned left;
 362     char *next;
 363     gz_statep state;
 364     z_streamp strm;
 365
 366     /* get internal structure */
 367     if (file == NULL)
 368         return Z_STREAM_ERROR;
 369     state = (gz_statep)file;
 370     strm = &(state->strm);
 371
 372     /* check that we're writing and that there's no error */
 373     if (state->mode != GZ_WRITE || state->err != Z_OK)
 374         return Z_STREAM_ERROR;
 375
 376     /* make sure we have some buffer space */
 377     if (state->size == 0 && gz_init(state) == -1)
 378         return state->err;
 379
 380     /* check for seek request */
 381     if (state->seek) {
 382         state->seek = 0;
 383         if (gz_zero(state, state->skip) == -1)
 384             return state->err;
 385     }
 386
 387     /* do the printf() into the input buffer, put length in len -- the input
 388        buffer is double-sized just for this function, so there is guaranteed to
 389        be state->size bytes available after the current contents */
 390     if (strm->avail_in == 0)
 391         strm->next_in = state->in;
 392     next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
 393     next[state->size - 1] = 0;
 394 #ifdef NO_vsnprintf
 395 #  ifdef HAS_vsprintf_void
 396     (void)vsprintf(next, format, va);
 397     for (len = 0; len < state->size; len++)
 398         if (next[len] == 0) break;
 399 #  else
 400     len = vsprintf(next, format, va);
 401 #  endif
 402 #else
 403 #  ifdef HAS_vsnprintf_void
 404     (void)vsnprintf(next, state->size, format, va);
 405     len = strlen(next);
 406 #  else
 407     len = vsnprintf(next, state->size, format, va);
 408 #  endif
 409 #endif
 410
 411     /* check that printf() results fit in buffer */
 412     if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
 413         return 0;
 414
 415     /* update buffer and position, compress first half if past that */
 416     strm->avail_in += (unsigned)len;
 417     state->x.pos += len;
 418     if (strm->avail_in >= state->size) {
 419         left = strm->avail_in - state->size;
 420         strm->avail_in = state->size;
 421         if (gz_comp(state, Z_NO_FLUSH) == -1)
 422             return state->err;
 423         memmove(state->in, state->in + state->size, left);
 424         strm->next_in = state->in;
 425         strm->avail_in = left;
 426     }
 427     return len;
 428 }
 429
 430 int ZEXPORTVA gzprintf(gzFile file, const char *format, ...) {
 431     va_list va;
 432     int ret;
 433
 434     va_start(va, format);
 435     ret = gzvprintf(file, format, va);
 436     va_end(va);
 437     return ret;
 438 }
 439
 440 #else /* !STDC && !Z_HAVE_STDARG_H */
 441
 442 /* -- see zlib.h -- */
 443 int ZEXPORTVA gzprintf(gzFile file, const char *format, int a1, int a2, int a3,
 444                        int a4, int a5, int a6, int a7, int a8, int a9, int a10,
 445                        int a11, int a12, int a13, int a14, int a15, int a16,
 446                        int a17, int a18, int a19, int a20) {
 447     unsigned len, left;
 448     char *next;
 449     gz_statep state;
 450     z_streamp strm;
 451
 452     /* get internal structure */
 453     if (file == NULL)
 454         return Z_STREAM_ERROR;
 455     state = (gz_statep)file;
 456     strm = &(state->strm);
 457
 458     /* check that can really pass pointer in ints */
 459     if (sizeof(int) != sizeof(void *))
 460         return Z_STREAM_ERROR;
 461
 462     /* check that we're writing and that there's no error */
 463     if (state->mode != GZ_WRITE || state->err != Z_OK)
 464         return Z_STREAM_ERROR;
 465
 466     /* make sure we have some buffer space */
 467     if (state->size == 0 && gz_init(state) == -1)
 468         return state->error;
 469
 470     /* check for seek request */
 471     if (state->seek) {
 472         state->seek = 0;
 473         if (gz_zero(state, state->skip) == -1)
 474             return state->error;
 475     }
 476
 477     /* do the printf() into the input buffer, put length in len -- the input
 478        buffer is double-sized just for this function, so there is guaranteed to
 479        be state->size bytes available after the current contents */
 480     if (strm->avail_in == 0)
 481         strm->next_in = state->in;
 482     next = (char *)(strm->next_in + strm->avail_in);
 483     next[state->size - 1] = 0;
 484 #ifdef NO_snprintf
 485 #  ifdef HAS_sprintf_void
 486     sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
 487             a13, a14, a15, a16, a17, a18, a19, a20);
 488     for (len = 0; len < size; len++)
 489         if (next[len] == 0)
 490             break;
 491 #  else
 492     len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
 493                   a12, a13, a14, a15, a16, a17, a18, a19, a20);
 494 #  endif
 495 #else
 496 #  ifdef HAS_snprintf_void
 497     snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
 498              a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 499     len = strlen(next);
 500 #  else
 501     len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
 502                    a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 503 #  endif
 504 #endif
 505
 506     /* check that printf() results fit in buffer */
 507     if (len == 0 || len >= state->size || next[state->size - 1] != 0)
 508         return 0;
 509
 510     /* update buffer and position, compress first half if past that */
 511     strm->avail_in += len;
 512     state->x.pos += len;
 513     if (strm->avail_in >= state->size) {
 514         left = strm->avail_in - state->size;
 515         strm->avail_in = state->size;
 516         if (gz_comp(state, Z_NO_FLUSH) == -1)
 517             return state->err;
 518         memmove(state->in, state->in + state->size, left);
 519         strm->next_in = state->in;
 520         strm->avail_in = left;
 521     }
 522     return (int)len;
 523 }
 524
 525 #endif
 526
 527 /* -- see zlib.h -- */
 528 int ZEXPORT gzflush(gzFile file, int flush) {
 529     gz_statep state;
 530
 531     /* get internal structure */
 532     if (file == NULL)
 533         return Z_STREAM_ERROR;
 534     state = (gz_statep)file;
 535
 536     /* check that we're writing and that there's no error */
 537     if (state->mode != GZ_WRITE || state->err != Z_OK)
 538         return Z_STREAM_ERROR;
 539
 540     /* check flush parameter */
 541     if (flush < 0 || flush > Z_FINISH)
 542         return Z_STREAM_ERROR;
 543
 544     /* check for seek request */
 545     if (state->seek) {
 546         state->seek = 0;
 547         if (gz_zero(state, state->skip) == -1)
 548             return state->err;
 549     }
 550
 551     /* compress remaining data with requested flush */
 552     (void)gz_comp(state, flush);
 553     return state->err;
 554 }
 555
 556 /* -- see zlib.h -- */
 557 int ZEXPORT gzsetparams(gzFile file, int level, int strategy) {
 558     gz_statep state;
 559     z_streamp strm;
 560
 561     /* get internal structure */
 562     if (file == NULL)
 563         return Z_STREAM_ERROR;
 564     state = (gz_statep)file;
 565     strm = &(state->strm);
 566
 567     /* check that we're writing and that there's no error */
 568     if (state->mode != GZ_WRITE || state->err != Z_OK || state->direct)
 569         return Z_STREAM_ERROR;
 570
 571     /* if no change is requested, then do nothing */
 572     if (level == state->level && strategy == state->strategy)
 573         return Z_OK;
 574
 575     /* check for seek request */
 576     if (state->seek) {
 577         state->seek = 0;
 578         if (gz_zero(state, state->skip) == -1)
 579             return state->err;
 580     }
 581
 582     /* change compression parameters for subsequent input */
 583     if (state->size) {
 584         /* flush previous input with previous parameters before changing */
 585         if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
 586             return state->err;
 587         deflateParams(strm, level, strategy);
 588     }
 589     state->level = level;
 590     state->strategy = strategy;
 591     return Z_OK;
 592 }
 593
 594 /* -- see zlib.h -- */
 595 int ZEXPORT gzclose_w(gzFile file) {
 596     int ret = Z_OK;
 597     gz_statep state;
 598
 599     /* get internal structure */
 600     if (file == NULL)
 601         return Z_STREAM_ERROR;
 602     state = (gz_statep)file;
 603
 604     /* check that we're writing */
 605     if (state->mode != GZ_WRITE)
 606         return Z_STREAM_ERROR;
 607
 608     /* check for seek request */
 609     if (state->seek) {
 610         state->seek = 0;
 611         if (gz_zero(state, state->skip) == -1)
 612             ret = state->err;
 613     }
 614
 615     /* flush, free memory, and close file */
 616     if (gz_comp(state, Z_FINISH) == -1)
 617         ret = state->err;
 618     if (state->size) {
 619         if (!state->direct) {
 620             (void)deflateEnd(&(state->strm));
 621             free(state->out);
 622         }
 623         free(state->in);
 624     }
 625     gz_error(state, Z_OK, NULL);
 626     free(state->path);
 627     if (close(state->fd) == -1)
 628         ret = Z_ERRNO;
 629     free(state);
 630     return ret;
 631 }