Annotation of embedaddon/sudo/zlib/gzlib.c, revision 1.1
1.1 ! misho 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gzlib.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / zlib