"Fossies" - the Fresh Open Source Software Archive

Member "mariadb-connector-c-3.0.9-src/zlib/gzlib.c" (8 Feb 2019, 14071 Bytes) of package /linux/misc/mariadb-connector-c-3.0.9-src.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /* gzlib.c -- zlib functions common to reading and writing gzip files
    2  * Copyright (C) 2004, 2010 Mark Adler
    3  * For conditions of distribution and use, see copyright notice in zlib.h
    4  */
    5 
    6 #include "gzguts.h"
    7 
    8 #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
    9 #  define LSEEK lseek64
   10 #else
   11 #  define LSEEK lseek
   12 #endif
   13 
   14 /* Local functions */
   15 local void gz_reset OF((gz_statep));
   16 local gzFile gz_open OF((const char *, int, const char *));
   17 
   18 #if defined UNDER_CE
   19 
   20 /* Map the Windows error number in ERROR to a locale-dependent error message
   21    string and return a pointer to it.  Typically, the values for ERROR come
   22    from GetLastError.
   23 
   24    The string pointed to shall not be modified by the application, but may be
   25    overwritten by a subsequent call to gz_strwinerror
   26 
   27    The gz_strwinerror function does not change the current setting of
   28    GetLastError. */
   29 char ZLIB_INTERNAL *gz_strwinerror (error)
   30      DWORD error;
   31 {
   32     static char buf[1024];
   33 
   34     wchar_t *msgbuf;
   35     DWORD lasterr = GetLastError();
   36     DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
   37         | FORMAT_MESSAGE_ALLOCATE_BUFFER,
   38         NULL,
   39         error,
   40         0, /* Default language */
   41         (LPVOID)&msgbuf,
   42         0,
   43         NULL);
   44     if (chars != 0) {
   45         /* If there is an \r\n appended, zap it.  */
   46         if (chars >= 2
   47             && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
   48             chars -= 2;
   49             msgbuf[chars] = 0;
   50         }
   51 
   52         if (chars > sizeof (buf) - 1) {
   53             chars = sizeof (buf) - 1;
   54             msgbuf[chars] = 0;
   55         }
   56 
   57         wcstombs(buf, msgbuf, chars + 1);
   58         LocalFree(msgbuf);
   59     }
   60     else {
   61         sprintf(buf, "unknown win32 error (%ld)", error);
   62     }
   63 
   64     SetLastError(lasterr);
   65     return buf;
   66 }
   67 
   68 #endif /* UNDER_CE */
   69 
   70 /* Reset gzip file state */
   71 local void gz_reset(state)
   72     gz_statep state;
   73 {
   74     if (state->mode == GZ_READ) {   /* for reading ... */
   75         state->have = 0;            /* no output data available */
   76         state->eof = 0;             /* not at end of file */
   77         state->how = LOOK;          /* look for gzip header */
   78         state->direct = 1;          /* default for empty file */
   79     }
   80     state->seek = 0;                /* no seek request pending */
   81     gz_error(state, Z_OK, NULL);    /* clear error */
   82     state->pos = 0;                 /* no uncompressed data yet */
   83     state->strm.avail_in = 0;       /* no input data yet */
   84 }
   85 
   86 /* Open a gzip file either by name or file descriptor. */
   87 local gzFile gz_open(path, fd, mode)
   88     const char *path;
   89     int fd;
   90     const char *mode;
   91 {
   92     gz_statep state;
   93 
   94     /* allocate gzFile structure to return */
   95     state = malloc(sizeof(gz_state));
   96     if (state == NULL)
   97         return NULL;
   98     state->size = 0;            /* no buffers allocated yet */
   99     state->want = GZBUFSIZE;    /* requested buffer size */
  100     state->msg = NULL;          /* no error message yet */
  101 
  102     /* interpret mode */
  103     state->mode = GZ_NONE;
  104     state->level = Z_DEFAULT_COMPRESSION;
  105     state->strategy = Z_DEFAULT_STRATEGY;
  106     while (*mode) {
  107         if (*mode >= '0' && *mode <= '9')
  108             state->level = *mode - '0';
  109         else
  110             switch (*mode) {
  111             case 'r':
  112                 state->mode = GZ_READ;
  113                 break;
  114 #ifndef NO_GZCOMPRESS
  115             case 'w':
  116                 state->mode = GZ_WRITE;
  117                 break;
  118             case 'a':
  119                 state->mode = GZ_APPEND;
  120                 break;
  121 #endif
  122             case '+':       /* can't read and write at the same time */
  123                 free(state);
  124                 return NULL;
  125             case 'b':       /* ignore -- will request binary anyway */
  126                 break;
  127             case 'f':
  128                 state->strategy = Z_FILTERED;
  129                 break;
  130             case 'h':
  131                 state->strategy = Z_HUFFMAN_ONLY;
  132                 break;
  133             case 'R':
  134                 state->strategy = Z_RLE;
  135                 break;
  136             case 'F':
  137                 state->strategy = Z_FIXED;
  138             default:        /* could consider as an error, but just ignore */
  139                 ;
  140             }
  141         mode++;
  142     }
  143 
  144     /* must provide an "r", "w", or "a" */
  145     if (state->mode == GZ_NONE) {
  146         free(state);
  147         return NULL;
  148     }
  149 
  150     /* save the path name for error messages */
  151     state->path = malloc(strlen(path) + 1);
  152     if (state->path == NULL) {
  153         free(state);
  154         return NULL;
  155     }
  156     strcpy(state->path, path);
  157 
  158     /* open the file with the appropriate mode (or just use fd) */
  159     state->fd = fd != -1 ? fd :
  160         open(path,
  161 #ifdef O_LARGEFILE
  162             O_LARGEFILE |
  163 #endif
  164 #ifdef O_BINARY
  165             O_BINARY |
  166 #endif
  167             (state->mode == GZ_READ ?
  168                 O_RDONLY :
  169                 (O_WRONLY | O_CREAT | (
  170                     state->mode == GZ_WRITE ?
  171                         O_TRUNC :
  172                         O_APPEND))),
  173             0666);
  174     if (state->fd == -1) {
  175         free(state->path);
  176         free(state);
  177         return NULL;
  178     }
  179     if (state->mode == GZ_APPEND)
  180         state->mode = GZ_WRITE;         /* simplify later checks */
  181 
  182     /* save the current position for rewinding (only if reading) */
  183     if (state->mode == GZ_READ) {
  184         state->start = LSEEK(state->fd, 0, SEEK_CUR);
  185         if (state->start == -1) state->start = 0;
  186     }
  187 
  188     /* initialize stream */
  189     gz_reset(state);
  190 
  191     /* return stream */
  192     return (gzFile)state;
  193 }
  194 
  195 /* -- see zlib.h -- */
  196 gzFile ZEXPORT gzopen(path, mode)
  197     const char *path;
  198     const char *mode;
  199 {
  200     return gz_open(path, -1, mode);
  201 }
  202 
  203 /* -- see zlib.h -- */
  204 gzFile ZEXPORT gzopen64(path, mode)
  205     const char *path;
  206     const char *mode;
  207 {
  208     return gz_open(path, -1, mode);
  209 }
  210 
  211 /* -- see zlib.h -- */
  212 gzFile ZEXPORT gzdopen(fd, mode)
  213     int fd;
  214     const char *mode;
  215 {
  216     char *path;         /* identifier for error messages */
  217     gzFile gz;
  218 
  219     if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL)
  220         return NULL;
  221     sprintf(path, "<fd:%d>", fd);   /* for debugging */
  222     gz = gz_open(path, fd, mode);
  223     free(path);
  224     return gz;
  225 }
  226 
  227 /* -- see zlib.h -- */
  228 int ZEXPORT gzbuffer(file, size)
  229     gzFile file;
  230     unsigned size;
  231 {
  232     gz_statep state;
  233 
  234     /* get internal structure and check integrity */
  235     if (file == NULL)
  236         return -1;
  237     state = (gz_statep)file;
  238     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
  239         return -1;
  240 
  241     /* make sure we haven't already allocated memory */
  242     if (state->size != 0)
  243         return -1;
  244 
  245     /* check and set requested size */
  246     if (size == 0)
  247         return -1;
  248     state->want = size;
  249     return 0;
  250 }
  251 
  252 /* -- see zlib.h -- */
  253 int ZEXPORT gzrewind(file)
  254     gzFile file;
  255 {
  256     gz_statep state;
  257 
  258     /* get internal structure */
  259     if (file == NULL)
  260         return -1;
  261     state = (gz_statep)file;
  262 
  263     /* check that we're reading and that there's no error */
  264     if (state->mode != GZ_READ || state->err != Z_OK)
  265         return -1;
  266 
  267     /* back up and start over */
  268     if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
  269         return -1;
  270     gz_reset(state);
  271     return 0;
  272 }
  273 
  274 /* -- see zlib.h -- */
  275 z_off64_t ZEXPORT gzseek64(file, offset, whence)
  276     gzFile file;
  277     z_off64_t offset;
  278     int whence;
  279 {
  280     unsigned n;
  281     z_off64_t ret;
  282     gz_statep state;
  283 
  284     /* get internal structure and check integrity */
  285     if (file == NULL)
  286         return -1;
  287     state = (gz_statep)file;
  288     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
  289         return -1;
  290 
  291     /* check that there's no error */
  292     if (state->err != Z_OK)
  293         return -1;
  294 
  295     /* can only seek from start or relative to current position */
  296     if (whence != SEEK_SET && whence != SEEK_CUR)
  297         return -1;
  298 
  299     /* normalize offset to a SEEK_CUR specification */
  300     if (whence == SEEK_SET)
  301         offset -= state->pos;
  302     else if (state->seek)
  303         offset += state->skip;
  304     state->seek = 0;
  305 
  306     /* if within raw area while reading, just go there */
  307     if (state->mode == GZ_READ && state->how == COPY &&
  308         state->pos + offset >= state->raw) {
  309         ret = LSEEK(state->fd, offset - state->have, SEEK_CUR);
  310         if (ret == -1)
  311             return -1;
  312         state->have = 0;
  313         state->eof = 0;
  314         state->seek = 0;
  315         gz_error(state, Z_OK, NULL);
  316         state->strm.avail_in = 0;
  317         state->pos += offset;
  318         return state->pos;
  319     }
  320 
  321     /* calculate skip amount, rewinding if needed for back seek when reading */
  322     if (offset < 0) {
  323         if (state->mode != GZ_READ)         /* writing -- can't go backwards */
  324             return -1;
  325         offset += state->pos;
  326         if (offset < 0)                     /* before start of file! */
  327             return -1;
  328         if (gzrewind(file) == -1)           /* rewind, then skip to offset */
  329             return -1;
  330     }
  331 
  332     /* if reading, skip what's in output buffer (one less gzgetc() check) */
  333     if (state->mode == GZ_READ) {
  334         n = GT_OFF(state->have) || (z_off64_t)state->have > offset ?
  335             (unsigned)offset : state->have;
  336         state->have -= n;
  337         state->next += n;
  338         state->pos += n;
  339         offset -= n;
  340     }
  341 
  342     /* request skip (if not zero) */
  343     if (offset) {
  344         state->seek = 1;
  345         state->skip = offset;
  346     }
  347     return state->pos + offset;
  348 }
  349 
  350 /* -- see zlib.h -- */
  351 z_off_t ZEXPORT gzseek(file, offset, whence)
  352     gzFile file;
  353     z_off_t offset;
  354     int whence;
  355 {
  356     z_off64_t ret;
  357 
  358     ret = gzseek64(file, (z_off64_t)offset, whence);
  359     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
  360 }
  361 
  362 /* -- see zlib.h -- */
  363 z_off64_t ZEXPORT gztell64(file)
  364     gzFile file;
  365 {
  366     gz_statep state;
  367 
  368     /* get internal structure and check integrity */
  369     if (file == NULL)
  370         return -1;
  371     state = (gz_statep)file;
  372     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
  373         return -1;
  374 
  375     /* return position */
  376     return state->pos + (state->seek ? state->skip : 0);
  377 }
  378 
  379 /* -- see zlib.h -- */
  380 z_off_t ZEXPORT gztell(file)
  381     gzFile file;
  382 {
  383     z_off64_t ret;
  384 
  385     ret = gztell64(file);
  386     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
  387 }
  388 
  389 /* -- see zlib.h -- */
  390 z_off64_t ZEXPORT gzoffset64(file)
  391     gzFile file;
  392 {
  393     z_off64_t offset;
  394     gz_statep state;
  395 
  396     /* get internal structure and check integrity */
  397     if (file == NULL)
  398         return -1;
  399     state = (gz_statep)file;
  400     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
  401         return -1;
  402 
  403     /* compute and return effective offset in file */
  404     offset = LSEEK(state->fd, 0, SEEK_CUR);
  405     if (offset == -1)
  406         return -1;
  407     if (state->mode == GZ_READ)             /* reading */
  408         offset -= state->strm.avail_in;     /* don't count buffered input */
  409     return offset;
  410 }
  411 
  412 /* -- see zlib.h -- */
  413 z_off_t ZEXPORT gzoffset(file)
  414     gzFile file;
  415 {
  416     z_off64_t ret;
  417 
  418     ret = gzoffset64(file);
  419     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
  420 }
  421 
  422 /* -- see zlib.h -- */
  423 int ZEXPORT gzeof(file)
  424     gzFile file;
  425 {
  426     gz_statep state;
  427 
  428     /* get internal structure and check integrity */
  429     if (file == NULL)
  430         return 0;
  431     state = (gz_statep)file;
  432     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
  433         return 0;
  434 
  435     /* return end-of-file state */
  436     return state->mode == GZ_READ ?
  437         (state->eof && state->strm.avail_in == 0 && state->have == 0) : 0;
  438 }
  439 
  440 /* -- see zlib.h -- */
  441 const char * ZEXPORT gzerror(file, errnum)
  442     gzFile file;
  443     int *errnum;
  444 {
  445     gz_statep state;
  446 
  447     /* get internal structure and check integrity */
  448     if (file == NULL)
  449         return NULL;
  450     state = (gz_statep)file;
  451     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
  452         return NULL;
  453 
  454     /* return error information */
  455     if (errnum != NULL)
  456         *errnum = state->err;
  457     return state->msg == NULL ? "" : state->msg;
  458 }
  459 
  460 /* -- see zlib.h -- */
  461 void ZEXPORT gzclearerr(file)
  462     gzFile file;
  463 {
  464     gz_statep state;
  465 
  466     /* get internal structure and check integrity */
  467     if (file == NULL)
  468         return;
  469     state = (gz_statep)file;
  470     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
  471         return;
  472 
  473     /* clear error and end-of-file */
  474     if (state->mode == GZ_READ)
  475         state->eof = 0;
  476     gz_error(state, Z_OK, NULL);
  477 }
  478 
  479 /* Create an error message in allocated memory and set state->err and
  480    state->msg accordingly.  Free any previous error message already there.  Do
  481    not try to free or allocate space if the error is Z_MEM_ERROR (out of
  482    memory).  Simply save the error message as a static string.  If there is an
  483    allocation failure constructing the error message, then convert the error to
  484    out of memory. */
  485 void ZLIB_INTERNAL gz_error(state, err, msg)
  486     gz_statep state;
  487     int err;
  488     const char *msg;
  489 {
  490     /* free previously allocated message and clear */
  491     if (state->msg != NULL) {
  492         if (state->err != Z_MEM_ERROR)
  493             free(state->msg);
  494         state->msg = NULL;
  495     }
  496 
  497     /* set error code, and if no message, then done */
  498     state->err = err;
  499     if (msg == NULL)
  500         return;
  501 
  502     /* for an out of memory error, save as static string */
  503     if (err == Z_MEM_ERROR) {
  504         state->msg = (char *)msg;
  505         return;
  506     }
  507 
  508     /* construct error message with path */
  509     if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) {
  510         state->err = Z_MEM_ERROR;
  511         state->msg = (char *)"out of memory";
  512         return;
  513     }
  514     strcpy(state->msg, state->path);
  515     strcat(state->msg, ": ");
  516     strcat(state->msg, msg);
  517     return;
  518 }
  519 
  520 #ifndef INT_MAX
  521 /* portably return maximum value for an int (when limits.h presumed not
  522    available) -- we need to do this to cover cases where 2's complement not
  523    used, since C standard permits 1's complement and sign-bit representations,
  524    otherwise we could just use ((unsigned)-1) >> 1 */
  525 unsigned ZLIB_INTERNAL gz_intmax()
  526 {
  527     unsigned p, q;
  528 
  529     p = 1;
  530     do {
  531         q = p;
  532         p <<= 1;
  533         p++;
  534     } while (p > q);
  535     return q >> 1;
  536 }
  537 #endif