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