The Tor Browser / file comparison
comparison: security/nss/lib/zlib/minigzip.c
security/nss/lib/zlib/minigzip.c
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:e03d678e7e5d |
|---|---|
| 1 /* minigzip.c -- simulate gzip using the zlib compression library | |
| 2 * Copyright (C) 1995-2006, 2010 Jean-loup Gailly. | |
| 3 * For conditions of distribution and use, see copyright notice in zlib.h | |
| 4 */ | |
| 5 | |
| 6 /* | |
| 7 * minigzip is a minimal implementation of the gzip utility. This is | |
| 8 * only an example of using zlib and isn't meant to replace the | |
| 9 * full-featured gzip. No attempt is made to deal with file systems | |
| 10 * limiting names to 14 or 8+3 characters, etc... Error checking is | |
| 11 * very limited. So use minigzip only for testing; use gzip for the | |
| 12 * real thing. On MSDOS, use only on file names without extension | |
| 13 * or in pipe mode. | |
| 14 */ | |
| 15 | |
| 16 /* @(#) $Id$ */ | |
| 17 | |
| 18 #include "zlib.h" | |
| 19 #include <stdio.h> | |
| 20 | |
| 21 #ifdef STDC | |
| 22 # include <string.h> | |
| 23 # include <stdlib.h> | |
| 24 #endif | |
| 25 | |
| 26 #ifdef USE_MMAP | |
| 27 # include <sys/types.h> | |
| 28 # include <sys/mman.h> | |
| 29 # include <sys/stat.h> | |
| 30 #endif | |
| 31 | |
| 32 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__) | |
| 33 # include <fcntl.h> | |
| 34 # include <io.h> | |
| 35 # ifdef UNDER_CE | |
| 36 # include <stdlib.h> | |
| 37 # endif | |
| 38 # define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) | |
| 39 #else | |
| 40 # define SET_BINARY_MODE(file) | |
| 41 #endif | |
| 42 | |
| 43 #ifdef VMS | |
| 44 # define unlink delete | |
| 45 # define GZ_SUFFIX "-gz" | |
| 46 #endif | |
| 47 #ifdef RISCOS | |
| 48 # define unlink remove | |
| 49 # define GZ_SUFFIX "-gz" | |
| 50 # define fileno(file) file->__file | |
| 51 #endif | |
| 52 #if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os | |
| 53 # include <unix.h> /* for fileno */ | |
| 54 #endif | |
| 55 | |
| 56 #if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE) | |
| 57 #ifndef WIN32 /* unlink already in stdio.h for WIN32 */ | |
| 58 extern int unlink OF((const char *)); | |
| 59 #endif | |
| 60 #endif | |
| 61 | |
| 62 #if defined(UNDER_CE) | |
| 63 # include <windows.h> | |
| 64 # define perror(s) pwinerror(s) | |
| 65 | |
| 66 /* Map the Windows error number in ERROR to a locale-dependent error | |
| 67 message string and return a pointer to it. Typically, the values | |
| 68 for ERROR come from GetLastError. | |
| 69 | |
| 70 The string pointed to shall not be modified by the application, | |
| 71 but may be overwritten by a subsequent call to strwinerror | |
| 72 | |
| 73 The strwinerror function does not change the current setting | |
| 74 of GetLastError. */ | |
| 75 | |
| 76 static char *strwinerror (error) | |
| 77 DWORD error; | |
| 78 { | |
| 79 static char buf[1024]; | |
| 80 | |
| 81 wchar_t *msgbuf; | |
| 82 DWORD lasterr = GetLastError(); | |
| 83 DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | |
| 84 | FORMAT_MESSAGE_ALLOCATE_BUFFER, | |
| 85 NULL, | |
| 86 error, | |
| 87 0, /* Default language */ | |
| 88 (LPVOID)&msgbuf, | |
| 89 0, | |
| 90 NULL); | |
| 91 if (chars != 0) { | |
| 92 /* If there is an \r\n appended, zap it. */ | |
| 93 if (chars >= 2 | |
| 94 && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { | |
| 95 chars -= 2; | |
| 96 msgbuf[chars] = 0; | |
| 97 } | |
| 98 | |
| 99 if (chars > sizeof (buf) - 1) { | |
| 100 chars = sizeof (buf) - 1; | |
| 101 msgbuf[chars] = 0; | |
| 102 } | |
| 103 | |
| 104 wcstombs(buf, msgbuf, chars + 1); | |
| 105 LocalFree(msgbuf); | |
| 106 } | |
| 107 else { | |
| 108 sprintf(buf, "unknown win32 error (%ld)", error); | |
| 109 } | |
| 110 | |
| 111 SetLastError(lasterr); | |
| 112 return buf; | |
| 113 } | |
| 114 | |
| 115 static void pwinerror (s) | |
| 116 const char *s; | |
| 117 { | |
| 118 if (s && *s) | |
| 119 fprintf(stderr, "%s: %s\n", s, strwinerror(GetLastError ())); | |
| 120 else | |
| 121 fprintf(stderr, "%s\n", strwinerror(GetLastError ())); | |
| 122 } | |
| 123 | |
| 124 #endif /* UNDER_CE */ | |
| 125 | |
| 126 #ifndef GZ_SUFFIX | |
| 127 # define GZ_SUFFIX ".gz" | |
| 128 #endif | |
| 129 #define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1) | |
| 130 | |
| 131 #define BUFLEN 16384 | |
| 132 #define MAX_NAME_LEN 1024 | |
| 133 | |
| 134 #ifdef MAXSEG_64K | |
| 135 # define local static | |
| 136 /* Needed for systems with limitation on stack size. */ | |
| 137 #else | |
| 138 # define local | |
| 139 #endif | |
| 140 | |
| 141 char *prog; | |
| 142 | |
| 143 void error OF((const char *msg)); | |
| 144 void gz_compress OF((FILE *in, gzFile out)); | |
| 145 #ifdef USE_MMAP | |
| 146 int gz_compress_mmap OF((FILE *in, gzFile out)); | |
| 147 #endif | |
| 148 void gz_uncompress OF((gzFile in, FILE *out)); | |
| 149 void file_compress OF((char *file, char *mode)); | |
| 150 void file_uncompress OF((char *file)); | |
| 151 int main OF((int argc, char *argv[])); | |
| 152 | |
| 153 /* =========================================================================== | |
| 154 * Display error message and exit | |
| 155 */ | |
| 156 void error(msg) | |
| 157 const char *msg; | |
| 158 { | |
| 159 fprintf(stderr, "%s: %s\n", prog, msg); | |
| 160 exit(1); | |
| 161 } | |
| 162 | |
| 163 /* =========================================================================== | |
| 164 * Compress input to output then close both files. | |
| 165 */ | |
| 166 | |
| 167 void gz_compress(in, out) | |
| 168 FILE *in; | |
| 169 gzFile out; | |
| 170 { | |
| 171 local char buf[BUFLEN]; | |
| 172 int len; | |
| 173 int err; | |
| 174 | |
| 175 #ifdef USE_MMAP | |
| 176 /* Try first compressing with mmap. If mmap fails (minigzip used in a | |
| 177 * pipe), use the normal fread loop. | |
| 178 */ | |
| 179 if (gz_compress_mmap(in, out) == Z_OK) return; | |
| 180 #endif | |
| 181 for (;;) { | |
| 182 len = (int)fread(buf, 1, sizeof(buf), in); | |
| 183 if (ferror(in)) { | |
| 184 perror("fread"); | |
| 185 exit(1); | |
| 186 } | |
| 187 if (len == 0) break; | |
| 188 | |
| 189 if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err)); | |
| 190 } | |
| 191 fclose(in); | |
| 192 if (gzclose(out) != Z_OK) error("failed gzclose"); | |
| 193 } | |
| 194 | |
| 195 #ifdef USE_MMAP /* MMAP version, Miguel Albrecht <malbrech@eso.org> */ | |
| 196 | |
| 197 /* Try compressing the input file at once using mmap. Return Z_OK if | |
| 198 * if success, Z_ERRNO otherwise. | |
| 199 */ | |
| 200 int gz_compress_mmap(in, out) | |
| 201 FILE *in; | |
| 202 gzFile out; | |
| 203 { | |
| 204 int len; | |
| 205 int err; | |
| 206 int ifd = fileno(in); | |
| 207 caddr_t buf; /* mmap'ed buffer for the entire input file */ | |
| 208 off_t buf_len; /* length of the input file */ | |
| 209 struct stat sb; | |
| 210 | |
| 211 /* Determine the size of the file, needed for mmap: */ | |
| 212 if (fstat(ifd, &sb) < 0) return Z_ERRNO; | |
| 213 buf_len = sb.st_size; | |
| 214 if (buf_len <= 0) return Z_ERRNO; | |
| 215 | |
| 216 /* Now do the actual mmap: */ | |
| 217 buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); | |
| 218 if (buf == (caddr_t)(-1)) return Z_ERRNO; | |
| 219 | |
| 220 /* Compress the whole file at once: */ | |
| 221 len = gzwrite(out, (char *)buf, (unsigned)buf_len); | |
| 222 | |
| 223 if (len != (int)buf_len) error(gzerror(out, &err)); | |
| 224 | |
| 225 munmap(buf, buf_len); | |
| 226 fclose(in); | |
| 227 if (gzclose(out) != Z_OK) error("failed gzclose"); | |
| 228 return Z_OK; | |
| 229 } | |
| 230 #endif /* USE_MMAP */ | |
| 231 | |
| 232 /* =========================================================================== | |
| 233 * Uncompress input to output then close both files. | |
| 234 */ | |
| 235 void gz_uncompress(in, out) | |
| 236 gzFile in; | |
| 237 FILE *out; | |
| 238 { | |
| 239 local char buf[BUFLEN]; | |
| 240 int len; | |
| 241 int err; | |
| 242 | |
| 243 for (;;) { | |
| 244 len = gzread(in, buf, sizeof(buf)); | |
| 245 if (len < 0) error (gzerror(in, &err)); | |
| 246 if (len == 0) break; | |
| 247 | |
| 248 if ((int)fwrite(buf, 1, (unsigned)len, out) != len) { | |
| 249 error("failed fwrite"); | |
| 250 } | |
| 251 } | |
| 252 if (fclose(out)) error("failed fclose"); | |
| 253 | |
| 254 if (gzclose(in) != Z_OK) error("failed gzclose"); | |
| 255 } | |
| 256 | |
| 257 | |
| 258 /* =========================================================================== | |
| 259 * Compress the given file: create a corresponding .gz file and remove the | |
| 260 * original. | |
| 261 */ | |
| 262 void file_compress(file, mode) | |
| 263 char *file; | |
| 264 char *mode; | |
| 265 { | |
| 266 local char outfile[MAX_NAME_LEN]; | |
| 267 FILE *in; | |
| 268 gzFile out; | |
| 269 | |
| 270 if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) { | |
| 271 fprintf(stderr, "%s: filename too long\n", prog); | |
| 272 exit(1); | |
| 273 } | |
| 274 | |
| 275 strcpy(outfile, file); | |
| 276 strcat(outfile, GZ_SUFFIX); | |
| 277 | |
| 278 in = fopen(file, "rb"); | |
| 279 if (in == NULL) { | |
| 280 perror(file); | |
| 281 exit(1); | |
| 282 } | |
| 283 out = gzopen(outfile, mode); | |
| 284 if (out == NULL) { | |
| 285 fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile); | |
| 286 exit(1); | |
| 287 } | |
| 288 gz_compress(in, out); | |
| 289 | |
| 290 unlink(file); | |
| 291 } | |
| 292 | |
| 293 | |
| 294 /* =========================================================================== | |
| 295 * Uncompress the given file and remove the original. | |
| 296 */ | |
| 297 void file_uncompress(file) | |
| 298 char *file; | |
| 299 { | |
| 300 local char buf[MAX_NAME_LEN]; | |
| 301 char *infile, *outfile; | |
| 302 FILE *out; | |
| 303 gzFile in; | |
| 304 size_t len = strlen(file); | |
| 305 | |
| 306 if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) { | |
| 307 fprintf(stderr, "%s: filename too long\n", prog); | |
| 308 exit(1); | |
| 309 } | |
| 310 | |
| 311 strcpy(buf, file); | |
| 312 | |
| 313 if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) { | |
| 314 infile = file; | |
| 315 outfile = buf; | |
| 316 outfile[len-3] = '\0'; | |
| 317 } else { | |
| 318 outfile = file; | |
| 319 infile = buf; | |
| 320 strcat(infile, GZ_SUFFIX); | |
| 321 } | |
| 322 in = gzopen(infile, "rb"); | |
| 323 if (in == NULL) { | |
| 324 fprintf(stderr, "%s: can't gzopen %s\n", prog, infile); | |
| 325 exit(1); | |
| 326 } | |
| 327 out = fopen(outfile, "wb"); | |
| 328 if (out == NULL) { | |
| 329 perror(file); | |
| 330 exit(1); | |
| 331 } | |
| 332 | |
| 333 gz_uncompress(in, out); | |
| 334 | |
| 335 unlink(infile); | |
| 336 } | |
| 337 | |
| 338 | |
| 339 /* =========================================================================== | |
| 340 * Usage: minigzip [-c] [-d] [-f] [-h] [-r] [-1 to -9] [files...] | |
| 341 * -c : write to standard output | |
| 342 * -d : decompress | |
| 343 * -f : compress with Z_FILTERED | |
| 344 * -h : compress with Z_HUFFMAN_ONLY | |
| 345 * -r : compress with Z_RLE | |
| 346 * -1 to -9 : compression level | |
| 347 */ | |
| 348 | |
| 349 int main(argc, argv) | |
| 350 int argc; | |
| 351 char *argv[]; | |
| 352 { | |
| 353 int copyout = 0; | |
| 354 int uncompr = 0; | |
| 355 gzFile file; | |
| 356 char *bname, outmode[20]; | |
| 357 | |
| 358 strcpy(outmode, "wb6 "); | |
| 359 | |
| 360 prog = argv[0]; | |
| 361 bname = strrchr(argv[0], '/'); | |
| 362 if (bname) | |
| 363 bname++; | |
| 364 else | |
| 365 bname = argv[0]; | |
| 366 argc--, argv++; | |
| 367 | |
| 368 if (!strcmp(bname, "gunzip")) | |
| 369 uncompr = 1; | |
| 370 else if (!strcmp(bname, "zcat")) | |
| 371 copyout = uncompr = 1; | |
| 372 | |
| 373 while (argc > 0) { | |
| 374 if (strcmp(*argv, "-c") == 0) | |
| 375 copyout = 1; | |
| 376 else if (strcmp(*argv, "-d") == 0) | |
| 377 uncompr = 1; | |
| 378 else if (strcmp(*argv, "-f") == 0) | |
| 379 outmode[3] = 'f'; | |
| 380 else if (strcmp(*argv, "-h") == 0) | |
| 381 outmode[3] = 'h'; | |
| 382 else if (strcmp(*argv, "-r") == 0) | |
| 383 outmode[3] = 'R'; | |
| 384 else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' && | |
| 385 (*argv)[2] == 0) | |
| 386 outmode[2] = (*argv)[1]; | |
| 387 else | |
| 388 break; | |
| 389 argc--, argv++; | |
| 390 } | |
| 391 if (outmode[3] == ' ') | |
| 392 outmode[3] = 0; | |
| 393 if (argc == 0) { | |
| 394 SET_BINARY_MODE(stdin); | |
| 395 SET_BINARY_MODE(stdout); | |
| 396 if (uncompr) { | |
| 397 file = gzdopen(fileno(stdin), "rb"); | |
| 398 if (file == NULL) error("can't gzdopen stdin"); | |
| 399 gz_uncompress(file, stdout); | |
| 400 } else { | |
| 401 file = gzdopen(fileno(stdout), outmode); | |
| 402 if (file == NULL) error("can't gzdopen stdout"); | |
| 403 gz_compress(stdin, file); | |
| 404 } | |
| 405 } else { | |
| 406 if (copyout) { | |
| 407 SET_BINARY_MODE(stdout); | |
| 408 } | |
| 409 do { | |
| 410 if (uncompr) { | |
| 411 if (copyout) { | |
| 412 file = gzopen(*argv, "rb"); | |
| 413 if (file == NULL) | |
| 414 fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv); | |
| 415 else | |
| 416 gz_uncompress(file, stdout); | |
| 417 } else { | |
| 418 file_uncompress(*argv); | |
| 419 } | |
| 420 } else { | |
| 421 if (copyout) { | |
| 422 FILE * in = fopen(*argv, "rb"); | |
| 423 | |
| 424 if (in == NULL) { | |
| 425 perror(*argv); | |
| 426 } else { | |
| 427 file = gzdopen(fileno(stdout), outmode); | |
| 428 if (file == NULL) error("can't gzdopen stdout"); | |
| 429 | |
| 430 gz_compress(in, file); | |
| 431 } | |
| 432 | |
| 433 } else { | |
| 434 file_compress(*argv, outmode); | |
| 435 } | |
| 436 } | |
| 437 } while (argv++, --argc); | |
| 438 } | |
| 439 return 0; | |
| 440 } |
