fastjar/jartool.c

   1 /*
   2   jartool.c - main functions for fastjar utility
   3   Copyright (C) 2002 Free Software Foundation
   4   Copyright (C) 1999, 2000, 2001  Bryan Burns
   5
   6   This program is free software; you can redistribute it and/or
   7   modify it under the terms of the GNU General Public License
   8   as published by the Free Software Foundation; either version 2
   9   of the License, or (at your option) any later version.
  10
  11   This program is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with this program; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19 */
  20
  21 /*
  22    Revision 1.10  2002/01/03 04:57:56  rodrigc
  23    2001-01-02  Craig Rodrigues  <rodrigc@gcc.gnu.org>
  24
  25            PR bootstrap/5117
  26            * configure.in (AC_CHECK_HEADERS): Check for stdlib.h.
  27            * Makefile.am: Move grepjar to bin_PROGRAMS.
  28            * config.h.in: Regenerated.
  29            * Makefile.in: Regenerated.
  30            * aclocal.m4: Regenerated.
  31            * jargrep.c: Eliminate some signed/unsigned and default
  32            uninitialized warnings. Use HAVE_STDLIB_H instead of
  33            STDC_HEADERS macro.
  34            * jartool.c: Likewise.
  35            * compress.c: Likewise.
  36
  37    Revision 1.9  2001/10/12 00:49:42  bryce
  38            * jatool.c (extract_jar): Account for null termination when
  39         determining whether to expand "filename".
  40
  41    Revision 1.8  2001/08/29 01:35:31  apbianco
  42    2001-08-28  Alexandre Petit-Bianco  <apbianco@redhat.com>
  43
  44         * jartool.c (add_to_jar): Return 1 if `stat' initialy failed.
  45         Fixes PR java/3949.
  46
  47    (http://gcc.gnu.org/ml/gcc-patches/2001-08/msg01641.html)
  48
  49    Revision 1.7  2001/08/27 23:09:37  tromey
  50         * jartool.c (jarfile): Remove length limitation.
  51         (main): Use jt_strdup when initializing jarfile.
  52
  53    Revision 1.6  2001/07/04 18:33:53  tromey
  54         Modified from patch by Julian Hall <jules@acris.co.uk>:
  55         * jartool.c (errno): Conditionally declare.
  56         (O_BINARY): Conditionally define.
  57         (main): Use open, not creat.  Use O_BINARY everywhere.
  58         (make_manifest): Use O_BINARY.
  59         (add_to_jar): Likewise.
  60
  61    Revision 1.5  2001/05/03 21:40:47  danglin
  62         * jartool.c (jt_strdup): New function.
  63         (get_next_arg): Use jt_strdup instead of strdup.
  64
  65    Revision 1.4  2000/12/28 21:47:37  robertl
  66    2000-12-28  Robert Lipe <robertl@sco.com>
  67
  68            * jartool.c (MAXPATHLEN): Provide if not defined.
  69
  70    Revision 1.3  2000/12/14 18:45:35  ghazi
  71    Warning fixes:
  72
  73         * compress.c: Include stdlib.h and compress.h.
  74         (rcsid): Delete.
  75         (report_str_error): Make static.
  76         (ez_inflate_str): Delete unused variable.  Add parens in if-stmt.
  77         (hrd_inflate_str): Likewise.
  78
  79         * compress.h (init_compression, end_compression, init_inflation,
  80         end_inflation): Prototype void arguments.
  81
  82         * dostime.c (rcsid): Delete.
  83
  84         * jargrep.c: Include ctype.h, stdlib.h, zlib.h and compress.h.
  85         Make functions static.  Cast ctype function argument to `unsigned
  86         char'.  Add parens in if-stmts.  Constify.
  87         (Usage): Change into a macro.
  88         (jargrep): Remove unused parameter.
  89
  90         * jartool.c: Constify.  Add parens in if-stmts.  Align
  91         signed/unsigned char pointers in functions calls using casts.
  92         (rcsid): Delete.
  93         (list_jar): Fix printf format specifier.
  94         (usage): Chop long string into bits.  Reformat.
  95
  96         * pushback.c (rcsid): Delete.
  97
  98    Revision 1.2  2000/12/13 18:11:57  tromey
  99         * jartool.c (extract_jar): Use strchr, not index.
 100
 101    Revision 1.1  2000/12/09 03:08:23  apbianco
 102    2000-12-08  Alexandre Petit-Bianco  <apbianco@cygnus.com>
 103
 104            * fastjar: Imported.
 105
 106    Revision 1.5  2000/08/24 15:01:27  cory
 107    Made certain that fastjar opened the jar file before trying to update it
 108    with the -u option.
 109
 110    Revision 1.4  2000/08/24 13:39:21  cory
 111    Changed +'s to |'s in jartool.c to insure there was no confusion with sign
 112    when byte swapping.  Better safe than sorry.
 113
 114    Revision 1.3  2000/08/23 19:42:17  cory
 115    Added support for more Unix platforms.  The following code has been hacked
 116    to work on AIX, Solaris, True 64, and HP-UX.
 117    Added bigendian check.  Probably works on most big and little endian platforms
 118    now.
 119
 120    Revision 1.2  1999/12/06 07:38:28  toast
 121    fixed recursive archiving bug
 122
 123    Revision 1.1.1.1  1999/12/06 03:09:34  toast
 124    initial checkin..
 125
 126
 127
 128    Revision 1.22  1999/10/12 19:45:13  burnsbr
 129    adding patch to fix compat problem
 130
 131    Revision 1.21  1999/05/10 09:15:49  burnsbr
 132    fixed manifest file version info
 133
 134    Revision 1.20  1999/05/10 08:53:16  burnsbr
 135    *** empty log message ***
 136
 137    Revision 1.19  1999/05/10 08:30:39  burnsbr
 138    added extract / listing code
 139
 140    Revision 1.18  1999/04/28 04:24:29  burnsbr
 141    updated version
 142
 143    Revision 1.17  1999/04/28 04:21:23  burnsbr
 144    added support for -C dir-changing flag.. Updated total compression display
 145
 146    Revision 1.16  1999/04/27 10:28:22  burnsbr
 147    updated version string
 148
 149    Revision 1.15  1999/04/27 10:04:06  burnsbr
 150    configure support
 151
 152    Revision 1.14  1999/04/27 08:56:14  burnsbr
 153    added -V flag, better error messages
 154
 155    Revision 1.13  1999/04/26 02:35:21  burnsbr
 156    changed all sorts of stuff.. compression now works 100%
 157
 158    Revision 1.12  1999/04/23 12:00:45  burnsbr
 159    90% done with compression code
 160
 161    Revision 1.11  1999/04/22 04:12:57  burnsbr
 162    finished first round of Manifest file support..
 163    might need to do more, digest etc..
 164
 165    Revision 1.10  1999/04/22 02:35:23  burnsbr
 166    added more manifest support, about 75% done now.  Replaced all the
 167    redundant shifts and bit-logic with a macro or two, making the code
 168    easier to read.
 169
 170    Revision 1.9  1999/04/21 09:55:16  burnsbr
 171    pulled out printfs
 172
 173    Revision 1.8  1999/04/21 02:58:01  burnsbr
 174    started manifest code
 175
 176    Revision 1.7  1999/04/20 23:15:28  burnsbr
 177    added patch sent by John Bley <jbb6@acpub.duke.edu>
 178
 179    Revision 1.6  1999/04/20 08:56:02  burnsbr
 180    added GPL comment
 181
 182    Revision 1.5  1999/04/20 08:16:09  burnsbr
 183    fixed verbose flag, did some optimization
 184
 185    Revision 1.4  1999/04/20 05:09:59  burnsbr
 186    added rcsid variable
 187
 188    Revision 1.3  1999/04/20 05:08:54  burnsbr
 189    fixed Log statement
 190
 191 */
 192
 193 #include "config.h"
 194
 195 #include <zlib.h>
 196
 197 #ifdef HAVE_STDLIB_H
 198 #include <stdlib.h>
 199 #endif
 200
 201 #ifdef HAVE_UNISTD_H
 202 #include <unistd.h>
 203 #endif
 204
 205 #include <stdio.h>
 206 #include <sys/stat.h>
 207 #include <sys/types.h>
 208
 209 #ifdef HAVE_SYS_PARAM_H
 210 #include <sys/param.h>
 211 #endif
 212
 213 #ifndef MAXPATHLEN
 214 #define MAXPATHLEN 1024
 215 #endif
 216
 217 #ifdef HAVE_DIRENT_H
 218 #include <dirent.h>
 219 #endif
 220
 221 #ifdef HAVE_FCNTL_H
 222 #include <fcntl.h>
 223 #endif
 224
 225 #include <string.h>
 226 #include <errno.h>
 227
 228 #ifdef TM_IN_SYS_TIME
 229 #include <sys/time.h>
 230 #else
 231 #include <time.h>
 232 #endif
 233
 234 #include <getopt.h>
 235
 236 #include "jartool.h"
 237 #include "zipfile.h"
 238 #include "dostime.h"
 239 #include "pushback.h"
 240 #include "compress.h"
 241
 242 /* Some systems have mkdir that takes a single argument.  */
 243 #ifdef MKDIR_TAKES_ONE_ARG
 244 # define mkdir(a,b) mkdir(a)
 245 #endif
 246
 247
 248 #ifdef WORDS_BIGENDIAN
 249
 250 #define L2BI(l) ((l & 0xff000000) >> 24) | \
 251                 ((l & 0x00ff0000) >> 8)  | \
 252                 ((l & 0x0000ff00) << 8)  | \
 253                 ((l & 0x000000ff) << 24);
 254
 255 #define L2BS(l) ((l & 0xff00) >> 8) | ((l & 0x00ff) << 8);
 256
 257 #endif
 258
 259 #ifndef errno
 260 extern int errno;
 261 #endif
 262
 263 #ifndef O_BINARY
 264 #define O_BINARY 0
 265 #endif
 266
 267 void usage(const char*);
 268 void help(const char *);
 269 void version(void);
 270 void add_entry(struct zipentry *);
 271 void init_headers(void);
 272
 273 int consume(pb_file *, int);
 274 int list_jar(int, char**, int);
 275 int extract_jar(int, char**, int);
 276 int add_file_to_jar(int, int, const char*, struct stat*);
 277 int add_to_jar(int, const char*, const char*);
 278 int create_central_header(int);
 279 int make_manifest(int, const char*);
 280 static void init_args(char **, int);
 281 static char *get_next_arg (void);
 282 static char *jt_strdup (char*);
 283 static void expand_options (int *argcp, char ***argvp);
 284
 285 /* global variables */
 286 ub1 file_header[30];
 287 ub1 data_descriptor[16];
 288 int do_compress;
 289 int seekable;
 290 int verbose;
 291 char *jarfile;
 292
 293 /* If non zero, then don't recurse in directory. Instead, add the
 294    directory entry and relie on an explicit list of files to populate
 295    the archive. This option isn't supported by the original jar tool. */
 296 int use_explicit_list_only;
 297
 298 /* If non zero, then read the entry names from stdin. This option
 299    isn't supported by the original jar tool. */
 300 int read_names_from_stdin;
 301
 302 zipentry *ziplist; /* linked list of entries */
 303 zipentry *ziptail; /* tail of the linked list */
 304
 305 int number_of_entries; /* number of entries in the linked list */
 306
 307 /* This is used to mark options with no short value.  */
 308 #define LONG_OPT(Num)  ((Num) + 128)
 309
 310 #define OPT_HELP     LONG_OPT (0)
 311
 312 /* This holds all options.  */
 313 #define OPTION_STRING "-ctxuvVf:m:C:0ME@"
 314
 315 static const struct option options[] =
 316 {
 317   { "help", no_argument, NULL, OPT_HELP },
 318   { "version", no_argument, NULL, 'V' },
 319   { NULL, no_argument, NULL, 0 }
 320 };
 321
 322 int main(int argc, char **argv){
 323
 324   char *mfile = NULL;
 325
 326   int action = ACTION_NONE;
 327   int manifest = TRUE;
 328   int opt;
 329
 330   int jarfd = -1;
 331
 332   /* These are used to collect file names and `-C' options for the
 333      second pass through the command line.  */
 334   int new_argc;
 335   char **new_argv;
 336
 337   do_compress = TRUE;
 338   verbose = FALSE;
 339
 340   ziplist = NULL;
 341
 342   number_of_entries = 0;
 343
 344   if(argc < 2)
 345     usage(argv[0]);
 346
 347   new_argc = 0;
 348   new_argv = (char **) malloc (argc * sizeof (char *));
 349
 350   expand_options (&argc, &argv);
 351   while ((opt = getopt_long (argc, argv, OPTION_STRING,
 352                              options, NULL)) != -1) {
 353     switch(opt){
 354     case 'C':
 355       new_argv[new_argc++] = (char *) "-C";
 356       /* ... fall through ... */
 357     case 1:
 358       /* File name or unparsed option, due to RETURN_IN_ORDER.  */
 359       new_argv[new_argc++] = optarg;
 360       break;
 361     case 'c':
 362       action = ACTION_CREATE;
 363       break;
 364     case 't':
 365       action = ACTION_LIST;
 366       break;
 367     case 'x':
 368       action = ACTION_EXTRACT;
 369       break;
 370     case 'u':
 371       action = ACTION_UPDATE;
 372       break;
 373     case 'v':
 374       verbose = TRUE;
 375       break;
 376     case 'V':
 377       version();
 378       exit(0);
 379     case 'f':
 380       jarfile = optarg;
 381       break;
 382     case 'm':
 383       mfile = optarg;
 384       break;
 385     case '0':
 386       do_compress = FALSE;
 387       break;
 388     case 'M':
 389       manifest = FALSE;
 390       break;
 391
 392     case OPT_HELP:
 393       help(argv[0]);
 394       break;
 395
 396     /* The following options aren't supported by the original jar tool. */
 397     case 'E':
 398       use_explicit_list_only = TRUE;
 399       break;
 400     case '@':
 401       read_names_from_stdin = TRUE;
 402       break;
 403     default:
 404       usage(argv[0]);
 405     }
 406   }
 407
 408   /* We might have seen `--'.  In this case we want to make sure that
 409      all following options are handled as file names.  */
 410   while (optind < argc)
 411     new_argv[new_argc++] = argv[optind++];
 412   new_argv[new_argc] = NULL;
 413
 414   if(action == ACTION_NONE){
 415     fprintf(stderr, "One of options -{ctxu} must be specified.\n");
 416     usage(argv[0]);
 417   }
 418
 419   if(action == ACTION_UPDATE){
 420     fprintf(stderr, "%s: `-u' mode unimplemented.\n", argv[0]);
 421     exit(1);
 422   }
 423
 424   /* Verify unsupported combinations and warn of the use of non
 425      standard features */
 426   if(verbose && use_explicit_list_only)
 427     fprintf (stderr, "Warning: using non standard '-E' option\n");
 428   if(verbose && read_names_from_stdin)
 429     fprintf (stderr, "Warning: using non standard '-@' option\n");
 430   if(read_names_from_stdin
 431       && (action != ACTION_CREATE && action != ACTION_UPDATE)){
 432       fprintf(stderr, "Option '-@' is supported only with '-c' or '-u'.\n");
 433       usage(argv[0]);
 434   }
 435
 436   /* create the jarfile */
 437   if(action == ACTION_CREATE){
 438     if(jarfile){
 439       jarfd = open(jarfile, O_CREAT | O_BINARY | O_WRONLY | O_TRUNC, 0666);
 440
 441       if(jarfd < 0){
 442         fprintf(stderr, "Error opening %s for writing!\n", jarfile);
 443         perror(jarfile);
 444         exit(1);
 445       }
 446
 447       /* We assume that the file is seekable */
 448       seekable = TRUE;
 449
 450     } else {
 451
 452       jarfd = STDOUT_FILENO;  /* jarfd is stdout otherwise */
 453
 454       /* standard out is not seekable */
 455       seekable = FALSE;
 456
 457       /* don't want our output to be part of the jar file.. figured this one
 458          out the hard way.. =P */
 459       verbose = FALSE;
 460     }
 461   } else if(action == ACTION_LIST || action == ACTION_EXTRACT){
 462
 463     if(jarfile){
 464       jarfd = open(jarfile, O_RDONLY | O_BINARY);
 465
 466       if(jarfd < 0){
 467         fprintf(stderr, "Error opening %s for reading!\n", jarfile);
 468         perror(jarfile);
 469         exit(1);
 470       }
 471
 472       seekable = TRUE;
 473     } else {
 474       jarfd = STDIN_FILENO; /* jarfd is standard in */
 475
 476       /* we assume that the stream isn't seekable for safety */
 477       seekable = FALSE;
 478     }
 479   }
 480
 481   if(action == ACTION_CREATE || action == ACTION_UPDATE){
 482     const char *arg;
 483     init_headers();
 484
 485    if((action == ACTION_UPDATE) && jarfile) {
 486       if((jarfd = open(jarfile, O_RDWR | O_BINARY)) < 0) {
 487         fprintf(stderr, "Error opening %s for reading!\n", jarfile);
 488         perror(jarfile);
 489         exit(1);
 490       }
 491     }
 492
 493     if(do_compress)
 494       init_compression();
 495
 496
 497     /* Add the META-INF/ directory and the manifest */
 498     if(manifest && mfile)
 499       make_manifest(jarfd, mfile);
 500     else if(manifest)
 501       make_manifest(jarfd, NULL);
 502
 503     init_args (new_argv, 0);
 504     /* now we add the files to the archive */
 505     while ((arg = get_next_arg ())){
 506
 507       if(!strcmp(arg, "-C")){
 508         const char *dir_to_change = get_next_arg ();
 509         const char *file_to_add = get_next_arg ();
 510         if(!dir_to_change
 511            || !file_to_add
 512            || add_to_jar(jarfd, dir_to_change, file_to_add)){
 513           printf("Error adding %s to jar archive!\n", arg);
 514           exit(1);
 515         }
 516       } else {
 517         if(add_to_jar(jarfd, NULL, arg)){
 518           printf("Error adding %s to jar archive!\n", arg);
 519           exit(1);
 520         }
 521       }
 522     }
 523     /* de-initialize the compression DS */
 524     if(do_compress)
 525       end_compression();
 526
 527     create_central_header(jarfd);
 528
 529     if (close(jarfd) != 0) {
 530       fprintf(stderr, "Error closing jar archive!\n");
 531     }
 532   } else if(action == ACTION_LIST){
 533     list_jar(jarfd, &new_argv[0], new_argc);
 534   } else if(action == ACTION_EXTRACT){
 535     extract_jar(jarfd, &new_argv[0], new_argc);
 536   }
 537
 538   exit(0);
 539 }
 540
 541 static int args_current_g;
 542 static char **args_g;
 543
 544 static void
 545 init_args(args, current)
 546      char **args;
 547      int current;
 548 {
 549   if(!read_names_from_stdin)
 550     {
 551       args_g = args;
 552       args_current_g = current;
 553     }
 554 }
 555
 556 static char *
 557 get_next_arg ()
 558 {
 559   static int reached_end = 0;
 560
 561   if (reached_end)
 562     return NULL;
 563
 564   if (args_g)
 565     {
 566       if (!args_g [args_current_g])
 567         {
 568           reached_end = 1;
 569           return NULL;
 570         }
 571       return args_g [args_current_g++];
 572     }
 573   else
 574     {
 575       /* Read the name from stdin. Delimiters are '\n' and
 576          '\r'. Reading EOF indicates that we don't have anymore file
 577          names characters to read. */
 578
 579       char s [MAXPATHLEN];
 580       int  pos = 0;
 581
 582       /* Get rid of '\n' and '\r' first. */
 583       while (1)
 584         {
 585           int c = getc (stdin);
 586           if (c == '\n' || c == '\r')
 587             continue;
 588           else
 589             {
 590               if (c == EOF)
 591                 return NULL;
 592               ungetc (c, stdin);
 593               break;
 594             }
 595         }
 596
 597       while (1)
 598         {
 599           int c = getc (stdin);
 600           /* Exit when we get a delimiter or don't have any characters
 601              to read */
 602           if (c == '\n'|| c == '\r'|| c == EOF)
 603             break;
 604           s [pos++] = (char) c;
 605         }
 606
 607       if (pos)
 608         {
 609           s [pos] = '\0';
 610           return jt_strdup (s);
 611         }
 612       else
 613         return NULL;
 614     }
 615 }
 616
 617 void init_headers(){
 618   /* packing file header */
 619   /* magic number */
 620   file_header[0] = 0x50;
 621   file_header[1] = 0x4b;
 622   file_header[2] = 0x03;
 623   file_header[3] = 0x04;
 624   /* version number (Unix 1.0)*/
 625   file_header[4] = 10;
 626   file_header[5] = 0;
 627   /* bit flag (normal deflation)*/
 628   file_header[6] = 0x00;
 629
 630   file_header[7] = 0x00;
 631   /* do_compression method (deflation) */
 632   file_header[8] = 0;
 633   file_header[9] = 0;
 634
 635   /* last mod file time (MS-DOS format) */
 636   file_header[10] = 0;
 637   file_header[11] = 0;
 638   /* last mod file date (MS-DOS format) */
 639   file_header[12] = 0;
 640   file_header[13] = 0;
 641   /* CRC 32 */
 642   file_header[14] = 0;
 643   file_header[15] = 0;
 644   file_header[16] = 0;
 645   file_header[17] = 0;
 646   /* compressed size */
 647   file_header[18] = 0;
 648   file_header[19] = 0;
 649   file_header[20] = 0;
 650   file_header[21] = 0;
 651   /* uncompressed size */
 652   file_header[22] = 0;
 653   file_header[23] = 0;
 654   file_header[24] = 0;
 655   file_header[25] = 0;
 656   /* filename length */
 657   file_header[26] = 0;
 658   file_header[27] = 0;
 659   /* extra field length */
 660   file_header[28] = 0;
 661   file_header[29] = 0;
 662
 663   /* Initialize the compression DS */
 664   PACK_UB4(data_descriptor, 0, 0x08074b50);
 665
 666 }
 667
 668 void add_entry(struct zipentry *ze){
 669
 670   if(ziplist == NULL){
 671     ziplist = ze;
 672     ziptail = ziplist;
 673   } else {
 674     ziplist->next_entry = ze;
 675     ziplist = ze;
 676   }
 677
 678   number_of_entries++;
 679 }
 680
 681 int make_manifest(int jfd, const char *mf_name){
 682   time_t current_time;
 683   int nlen;   /* length of file name */
 684   int mod_time; /* file modification time */
 685   struct zipentry *ze;
 686
 687   nlen = 9;  /* trust me on this one */
 688
 689   memset((file_header + 12), '\0', 16); /*clear mod time, crc, size fields*/
 690
 691   current_time = time(NULL);
 692   if(current_time == (time_t)-1){
 693     perror("time");
 694     exit(1);
 695   }
 696
 697   mod_time = unix2dostime(&current_time);
 698
 699   PACK_UB2(file_header, LOC_EXTRA, 0);
 700   PACK_UB2(file_header, LOC_COMP, 0);
 701   PACK_UB2(file_header, LOC_FNLEN, nlen);
 702   PACK_UB4(file_header, LOC_MODTIME, mod_time);
 703
 704   if(verbose)
 705     printf("adding: META-INF/ (in=0) (out=0) (stored 0%%)\n");
 706
 707   ze = (zipentry*)malloc(sizeof(zipentry));
 708   if(ze == NULL){
 709     perror("malloc");
 710     exit(1);
 711   }
 712
 713   memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/
 714   ze->filename = (char*)malloc((nlen + 1) * sizeof(char) + 1);
 715   strcpy(ze->filename, "META-INF/");
 716   ze->filename[nlen] = '\0';
 717
 718   ze->offset = lseek(jfd, 0, SEEK_CUR);
 719   ze->mod_time = (ub2)(mod_time & 0x0000ffff);
 720   ze->mod_date = (ub2)((mod_time & 0xffff0000) >> 16);
 721   ze->compressed = FALSE;
 722
 723   add_entry(ze);
 724
 725   write(jfd, file_header, 30);
 726   write(jfd, "META-INF/", nlen);
 727
 728   /* if the user didn't specify an external manifest file... */
 729   if(mf_name == NULL){
 730     int mf_len = 37 + strlen(VERSION);
 731     char *mf;
 732
 733     if((mf = (char *) malloc(mf_len + 1))) {
 734     uLong crc;
 735
 736     sprintf(mf, "Manifest-Version: 1.0\nCreated-By: %s\n\n", VERSION);
 737
 738     crc = crc32(0L, Z_NULL, 0);
 739
 740     crc = crc32(crc, (const unsigned char *)mf, mf_len);
 741
 742     nlen = 20;  /* once again, trust me */
 743
 744     PACK_UB2(file_header, LOC_EXTRA, 0);
 745     PACK_UB2(file_header, LOC_COMP, 0);
 746     PACK_UB2(file_header, LOC_FNLEN, nlen);
 747     PACK_UB4(file_header, LOC_USIZE, mf_len);
 748
 749     memcpy((file_header + LOC_CSIZE), (file_header + LOC_USIZE), 4);
 750
 751     PACK_UB4(file_header, LOC_CRC, crc);
 752
 753     if(verbose)
 754       printf("adding: META-INF/MANIFEST.MF (in=56) (out=56) (stored 0%%)\n");
 755
 756     ze = (zipentry*)malloc(sizeof(zipentry));
 757     if(ze == NULL){
 758       perror("malloc");
 759       exit(1);
 760     }
 761
 762     memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/
 763     ze->filename = (char*)malloc((nlen + 1) * sizeof(char) + 1);
 764     strcpy(ze->filename, "META-INF/MANIFEST.MF");
 765     ze->filename[nlen] = '\0';
 766
 767     ze->offset = lseek(jfd, 0, SEEK_CUR);
 768     ze->mod_time = (ub2)(mod_time & 0x0000ffff);
 769     ze->mod_date = (ub2)((mod_time & 0xffff0000) >> 16);
 770     ze->crc = crc;
 771     ze->csize = mf_len;
 772     ze->usize = ze->csize;
 773     ze->compressed = FALSE;
 774
 775     add_entry(ze);
 776
 777     write(jfd, file_header, 30);
 778     write(jfd, "META-INF/MANIFEST.MF", nlen);
 779     write(jfd, mf, mf_len);
 780     free(mf);
 781     }
 782     else {
 783         printf("malloc errror\n");
 784         exit(-1);
 785     }
 786   } else {
 787     int mfd;
 788     struct stat statbuf;
 789
 790     stat(mf_name, &statbuf);
 791
 792     if(!S_ISREG(statbuf.st_mode)){
 793       fprintf(stderr, "Invalid manifest file specified.\n");
 794       exit(1);
 795     }
 796
 797     mfd = open(mf_name, O_RDONLY | O_BINARY);
 798
 799     if(mfd < 0){
 800       fprintf(stderr, "Error opening %s.\n", mf_name);
 801       exit(1);
 802     }
 803
 804     if(add_file_to_jar(jfd, mfd, "META-INF/MANIFEST.MF", &statbuf)){
 805       perror("error writing to jar");
 806       exit(1);
 807     }
 808
 809   }
 810
 811   return 0;
 812 }
 813
 814 int add_to_jar(int fd, const char *new_dir, const char *file){
 815   struct stat statbuf;
 816   DIR *dir;
 817   struct dirent *de;
 818   zipentry *ze;
 819   int stat_return;
 820   char *old_dir = NULL;
 821
 822   /* This is a quick compatibility fix -- Simon Weijgers <simon@weijgers.com>
 823    * It fixes this:
 824    *   "normal" jar : org/apache/java/io/LogRecord.class
 825    *   fastjar      : ./org/apache/java/io/LogRecord.class
 826    * Fastjar's preservation of the ./'s makes the jarfile unusuable for use
 827    * with both kaffe-1.0b4 and JDK.
 828    */
 829   while (*file=='.' && *(file+1)=='/')
 830     file+=2;
 831
 832   /* If new_dir isn't null, we need to change to that directory.  However,
 833      we also need to return to the old directory when we're done */
 834   if(new_dir != NULL){
 835     old_dir = getcwd(NULL, 0);
 836
 837     if(chdir(new_dir) == -1){
 838       perror(new_dir);
 839       return 1;
 840     }
 841   }
 842
 843   if(jarfile && !strcmp(file, jarfile)){
 844     if(verbose)
 845       printf("skipping: %s\n", file);
 846     return 0;  /* we don't want to add ourselves.. */
 847   }
 848
 849   stat_return = stat(file, &statbuf);
 850
 851   if(stat_return == -1){
 852     perror(file);
 853     return 1;
 854   } else if(S_ISDIR(statbuf.st_mode)){
 855     char *fullname;
 856     char *t_ptr;
 857     int nlen;
 858     unsigned long mod_time;
 859
 860     dir = opendir(file);
 861
 862     if(dir == NULL){
 863       perror("opendir");
 864       return 1;
 865     }
 866
 867     nlen = strlen(file) + 256;
 868     fullname = (char*)malloc(nlen * sizeof(char));
 869     memset(fullname, 0, (nlen * sizeof(char)));
 870
 871     if(fullname == NULL){
 872       fprintf(stderr, "Filename is NULL!\n");
 873       return 1;
 874     }
 875
 876     strcpy(fullname, file);
 877     nlen = strlen(file);
 878
 879     if(fullname[nlen - 1] != '/'){
 880       fullname[nlen] = '/';
 881       t_ptr = (fullname + nlen + 1);
 882     } else
 883       t_ptr = (fullname + nlen);
 884
 885
 886     memset((file_header + 12), '\0', 16); /*clear mod time, crc, size fields*/
 887
 888     nlen = (t_ptr - fullname);
 889
 890     mod_time = unix2dostime(&statbuf.st_mtime);
 891
 892     PACK_UB2(file_header, LOC_EXTRA, 0);
 893     PACK_UB2(file_header, LOC_COMP, 0);
 894     PACK_UB2(file_header, LOC_FNLEN, nlen);
 895     PACK_UB4(file_header, LOC_MODTIME, mod_time);
 896
 897     if(verbose)
 898       printf("adding: %s (in=%d) (out=%d) (stored 0%%)\n", fullname, 0, 0);
 899
 900     ze = (zipentry*)malloc(sizeof(zipentry));
 901     if(ze == NULL){
 902       perror("malloc");
 903       exit(1);
 904     }
 905
 906     memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/
 907     ze->filename = (char*)malloc((nlen + 1) * sizeof(char) + 1);
 908     strcpy(ze->filename, fullname);
 909     ze->filename[nlen] = '\0';
 910
 911     ze->offset = lseek(fd, 0, SEEK_CUR);
 912     ze->mod_time = (ub2)(mod_time & 0x0000ffff);
 913     ze->mod_date = (ub2)((mod_time & 0xffff0000) >> 16);
 914     ze->compressed = FALSE;
 915
 916     add_entry(ze);
 917
 918     write(fd, file_header, 30);
 919     write(fd, fullname, nlen);
 920
 921     while(!use_explicit_list_only && (de = readdir(dir)) != NULL){
 922       if(de->d_name[0] == '.')
 923         continue;
 924       if(jarfile && !strcmp(de->d_name, jarfile)){
 925         /* we don't want to add ourselves.  Believe me */
 926         if(verbose)
 927           printf("skipping: %s\n", de->d_name);
 928         continue;
 929       }
 930
 931       strcpy(t_ptr, de->d_name);
 932
 933       if(add_to_jar(fd, NULL, fullname)){
 934         fprintf(stderr, "Error adding file to jar!\n");
 935         return 1;
 936       }
 937     }
 938
 939     free(fullname);
 940     closedir(dir);
 941
 942   } else if(S_ISREG(statbuf.st_mode)){
 943     int add_fd;
 944
 945     add_fd = open(file, O_RDONLY | O_BINARY);
 946     if(add_fd < 0){
 947       fprintf(stderr, "Error opening %s.\n", file);
 948       return 0;
 949     }
 950
 951     if(add_file_to_jar(fd, add_fd, file, &statbuf)){
 952       fprintf(stderr, "Error adding file to jar!\n");
 953       return 1;
 954     }
 955
 956   } else {
 957     fprintf(stderr, "Illegal file specified: %s\n", file);
 958   }
 959
 960   if(old_dir != NULL){
 961     if(chdir(old_dir))
 962       perror(old_dir);
 963
 964     free(old_dir);
 965   }
 966
 967   return 0;
 968 }
 969
 970 int add_file_to_jar(int jfd, int ffd, const char *fname, struct stat *statbuf){
 971
 972   unsigned short file_name_length;
 973   unsigned long mod_time;
 974   ub1 rd_buff[RDSZ];
 975   uLong crc = 0;
 976   off_t offset = 0;
 977   int rdamt;
 978   struct zipentry *ze;
 979
 980   mod_time = unix2dostime(&(statbuf->st_mtime));
 981   file_name_length = strlen(fname);
 982
 983   if(!seekable && !do_compress){
 984     crc = crc32(0L, Z_NULL, 0);
 985
 986     while((rdamt = read(ffd, rd_buff, RDSZ)) != 0)
 987       crc = crc32(crc, rd_buff, rdamt);
 988
 989     lseek(ffd, 0, SEEK_SET);
 990   }
 991
 992   /* data descriptor */
 993   if(!seekable && do_compress){
 994     PACK_UB2(file_header, LOC_EXTRA, 8);
 995   } else {
 996     PACK_UB2(file_header, LOC_EXTRA, 0);
 997   }
 998
 999   if(do_compress){
1000     PACK_UB2(file_header, LOC_COMP, 8);
1001   } else {
1002     PACK_UB2(file_header, LOC_COMP, 0);
1003   }
1004
1005   PACK_UB4(file_header, LOC_MODTIME, mod_time);
1006   PACK_UB2(file_header, LOC_FNLEN, file_name_length);
1007
1008   if(!seekable && !do_compress){
1009     PACK_UB4(file_header, LOC_CRC, crc);
1010     PACK_UB4(file_header, LOC_USIZE, statbuf->st_size);
1011     PACK_UB4(file_header, LOC_CSIZE, statbuf->st_size);
1012   } else
1013     memset((file_header + LOC_CRC), '\0', 12); /* clear crc/usize/csize */
1014
1015   ze = (zipentry*)malloc(sizeof(zipentry));
1016   if(ze == NULL){
1017     perror("malloc");
1018     exit(1);
1019   }
1020
1021   memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/
1022   ze->filename = (char*)malloc((file_name_length + 1) * sizeof(char));
1023   strcpy(ze->filename, fname);
1024
1025   ze->mod_time = (ub2)(mod_time & 0x0000ffff);
1026   ze->mod_date = (ub2)((mod_time & 0xffff0000) >> 16);
1027
1028   if(!seekable && !do_compress)
1029     ze->crc = crc;
1030
1031   ze->csize = statbuf->st_size;
1032   ze->usize = ze->csize;
1033   ze->offset = lseek(jfd, 0, SEEK_CUR);
1034   if(do_compress)
1035     ze->compressed = TRUE;
1036   else
1037     ze->compressed = FALSE;
1038
1039   add_entry(ze);
1040
1041   /* Write the local header */
1042   write(jfd, file_header, 30);
1043
1044   /* write the file name to the zip file */
1045   write(jfd, fname, file_name_length);
1046
1047
1048   if(verbose){
1049     printf("adding: %s ", fname);
1050     fflush(stdout);
1051   }
1052
1053   if(do_compress){
1054     /* compress the file */
1055     compress_file(ffd, jfd, ze);
1056   } else {
1057     /* Write the contents of the file (uncompressed) to the zip file */
1058     /* calculate the CRC as we go along */
1059     ze->crc = crc32(0L, Z_NULL, 0);
1060
1061     while((rdamt = read(ffd, rd_buff, RDSZ)) != 0){
1062       ze->crc = crc32(ze->crc, rd_buff, rdamt);
1063       if(write(jfd, rd_buff, rdamt) != rdamt){
1064         perror("write");
1065         return 0;
1066       }
1067     }
1068   }
1069   close(ffd);
1070
1071   /* write out data descriptor */
1072   PACK_UB4(data_descriptor, 4, ze->crc);
1073   PACK_UB4(data_descriptor, 8, ze->csize);
1074   PACK_UB4(data_descriptor, 12, ze->usize);
1075
1076   /* we need to seek back and fill the header */
1077   if(seekable){
1078     offset = (ze->csize + strlen(ze->filename) + 16);
1079
1080     if(lseek(jfd, -offset, SEEK_CUR) == (off_t)-1){
1081       perror("lseek");
1082       exit(1);
1083     }
1084
1085     if(write(jfd, (data_descriptor + 4), 12) != 12){
1086       perror("write");
1087       return 0;
1088     }
1089
1090     offset -= 12;
1091
1092     if(lseek(jfd, offset, SEEK_CUR) == (off_t)-1){
1093       perror("lseek");
1094       exit(1);
1095     }
1096   } else if(do_compress){
1097     /* Sun's jar tool will only allow a data descriptor if the entry is
1098        compressed, but we'll save 16 bytes/entry if we only use it when
1099        we can't seek back on the file */
1100
1101     if(write(jfd, data_descriptor, 16) != 16){
1102       perror("write");
1103       return 0;
1104     }
1105   }
1106
1107   if(verbose)
1108     printf("(in=%d) (out=%d) (%s %d%%)\n",
1109            (int)ze->usize, (int)ze->csize,
1110            (do_compress ? "deflated" : "stored"),
1111            (do_compress ? ((int)((1 - ze->csize/(float)ze->usize) * 100)) : 0));
1112
1113   return 0;
1114 }
1115
1116 int create_central_header(int fd){
1117   ub1 header[46];
1118   ub1 end_header[22];
1119   int start_offset;
1120   int dir_size;
1121   int total_in = 0, total_out = 22;
1122
1123   zipentry *ze;
1124
1125   /* magic number */
1126   header[0] = 'P';
1127   header[1] = 'K';
1128   header[2] = 1;
1129   header[3] = 2;
1130   /* version made by */
1131   header[4] = 10;
1132   header[5] = 0;
1133   /* version needed to extract */
1134   header[6] = 10;
1135   header[7] = 0;
1136   /* bit flag */
1137   header[8] = 0;
1138   header[9] = 0;
1139   /* compression method */
1140   header[10] = 0;
1141   header[11] = 0;
1142   /* file mod time */
1143   header[12] = 0;
1144   header[13] = 0;
1145   /* file mod date */
1146   header[14] = 0;
1147   header[15] = 0;
1148   /* crc 32 */
1149   header[16] = 0;
1150   header[17] = 0;
1151   header[18] = 0;
1152   header[19] = 0;
1153   /* compressed size */
1154   header[20] = 0;
1155   header[21] = 0;
1156   header[22] = 0;
1157   header[23] = 0;
1158   /* uncompressed size */
1159   header[24] = 0;
1160   header[25] = 0;
1161   header[26] = 0;
1162   header[27] = 0;
1163   /* filename length */
1164   header[28] = 0;
1165   header[29] = 0;
1166   /* extra field length */
1167   header[30] = 0;
1168   header[31] = 0;
1169   /* file comment length */
1170   header[32] = 0;
1171   header[33] = 0;
1172   /* disk number start */
1173   header[34] = 0;
1174   header[35] = 0;
1175   /* internal file attribs */
1176   header[36] = 0;
1177   header[37] = 0;
1178   /* external file attribs */
1179   header[38] = 0;
1180   header[39] = 0;
1181   header[40] = 0;
1182   header[41] = 0;
1183   /* relative offset of local header */
1184   header[42] = 0;
1185   header[43] = 0;
1186   header[44] = 0;
1187   header[45] = 0;
1188
1189   start_offset = lseek(fd, 0, SEEK_CUR);
1190
1191   for(ze = ziptail; ze != NULL; ze = ze->next_entry){
1192
1193     total_in += ze->usize;
1194     total_out += ze->csize + 76 + strlen(ze->filename) * 2;
1195
1196     if(ze->compressed){
1197       PACK_UB2(header, CEN_COMP, 8);
1198     } else {
1199       PACK_UB2(header, CEN_COMP, 0);
1200     }
1201
1202     PACK_UB2(header, CEN_MODTIME, ze->mod_time);
1203     PACK_UB2(header, CEN_MODDATE, ze->mod_date);
1204     PACK_UB4(header, CEN_CRC, ze->crc);
1205     PACK_UB4(header, CEN_CSIZE, ze->csize);
1206     PACK_UB4(header, CEN_USIZE, ze->usize);
1207     PACK_UB2(header, CEN_FNLEN, strlen(ze->filename));
1208     PACK_UB4(header, CEN_OFFSET, ze->offset);
1209
1210     write(fd, header, 46);
1211
1212     write(fd, ze->filename, strlen(ze->filename));
1213   }
1214
1215   dir_size = lseek(fd, 0, SEEK_CUR) - start_offset;
1216
1217   /* magic number */
1218   end_header[0] = 0x50;
1219   end_header[1] = 0x4b;
1220   end_header[2] = 0x05;
1221   end_header[3] = 0x06;
1222   /* number of this disk */
1223   end_header[4] = 0;
1224   end_header[5] = 0;
1225   /* number of disk w/ start of central header */
1226   end_header[6] = 0;
1227   end_header[7] = 0;
1228   /* total number of entries in central dir on this disk*/
1229   PACK_UB2(end_header, 8, number_of_entries);
1230   /* total number of entries in central dir*/
1231   PACK_UB2(end_header, 10, number_of_entries);
1232   /* size of central dir. */
1233   PACK_UB4(end_header, 12, dir_size);
1234   /* offset of start of central dir */
1235   PACK_UB4(end_header, 16, start_offset);
1236   /* zipfile comment length */
1237   end_header[20] = 0;
1238   end_header[21] = 0;
1239
1240   write(fd, end_header, 22);
1241
1242   if(verbose)
1243     printf("Total:\n------\n(in = %d) (out = %d) (%s %d%%)\n",
1244            total_in,
1245            total_out,
1246            (do_compress ? "deflated" : "stored"),
1247            (int)((1 - (total_out / (float)total_in)) * 100)
1248            );
1249
1250   return 0;
1251 }
1252
1253 int extract_jar(int fd, char **files, int file_num){
1254   int rdamt;
1255   int out_a, in_a;
1256   ub4 signature;
1257   ub4 csize;
1258   ub4 crc;
1259   ub2 fnlen;
1260   ub2 eflen;
1261   ub2 flags;
1262   ub2 method;
1263   ub1 *filename = NULL;
1264   int filename_len = 0;
1265   ub4 rd_buff[RDSZ];
1266   pb_file pbf;
1267   ub1 scratch[16];
1268   zipentry ze;
1269   int f_fd;
1270   int dir;
1271   int handle;
1272   int j;
1273
1274   init_inflation();
1275
1276   pb_init(&pbf, fd);
1277
1278   for(;;){
1279     f_fd = 0;
1280     crc = 0;
1281     ze.crc = 0;
1282
1283     dir = FALSE; /* by default, the file isn't a dir */
1284     handle = TRUE; /* by default we'll extract/create the file */
1285
1286     if((rdamt = pb_read(&pbf, scratch, 4)) != 4){
1287       perror("read");
1288       break;
1289     }
1290
1291     signature = UNPACK_UB4(scratch, 0);
1292
1293 #ifdef DEBUG
1294     printf("signature is %x\n", signature);
1295 #endif
1296     if(signature == 0x08074b50){
1297 #ifdef DEBUG
1298       printf("skipping data descriptor\n");
1299 #endif
1300       pb_read(&pbf, scratch, 12);
1301       continue;
1302     } else if(signature == 0x02014b50){
1303 #ifdef DEBUG
1304       printf("Central header reached.. we're all done!\n");
1305 #endif
1306       break;
1307     }else if(signature != 0x04034b50){
1308       printf("Ick! %#x\n", signature);
1309       break;
1310     }
1311
1312     if((rdamt = pb_read(&pbf, (file_header + 4), 26)) != 26){
1313       perror("read");
1314       break;
1315     }
1316
1317     csize = UNPACK_UB4(file_header, LOC_CSIZE);
1318 #ifdef DEBUG
1319     printf("Compressed size is %u\n", csize);
1320 #endif
1321
1322     fnlen = UNPACK_UB2(file_header, LOC_FNLEN);
1323 #ifdef DEBUG
1324     printf("Filename length is %hu\n", fnlen);
1325 #endif
1326
1327     eflen = UNPACK_UB2(file_header, LOC_EFLEN);
1328 #ifdef DEBUG
1329     printf("Extra field length is %hu\n", eflen);
1330 #endif
1331
1332     flags = UNPACK_UB2(file_header, LOC_EXTRA);
1333 #ifdef DEBUG
1334     printf("Flags are %#hx\n", flags);
1335 #endif
1336
1337     method = UNPACK_UB2(file_header, LOC_COMP);
1338 #ifdef DEBUG
1339     printf("Compression method is %#hx\n", method);
1340 #endif
1341
1342     /* if there isn't a data descriptor */
1343     if(!(flags & 0x0008)){
1344       crc = UNPACK_UB4(file_header, LOC_CRC);
1345 #ifdef DEBUG
1346       printf("CRC is %x\n", crc);
1347 #endif
1348     }
1349
1350     if(filename_len < fnlen + 1){
1351       if(filename != NULL)
1352         free(filename);
1353
1354       filename = malloc(sizeof(ub1) * (fnlen + 1));
1355       filename_len = fnlen + 1;
1356     }
1357
1358     pb_read(&pbf, filename, fnlen);
1359     filename[fnlen] = '\0';
1360
1361 #ifdef DEBUG
1362     printf("filename is %s\n", filename);
1363 #endif
1364
1365     if(file_num > 0){
1366       handle = FALSE;
1367
1368       for(j = 0; j < file_num; j++)
1369         if(strcmp(files[j], (const char *)filename) == 0){
1370           handle = TRUE;
1371           break;
1372         }
1373     }
1374
1375     if(!handle)
1376       f_fd = -1;
1377
1378     /* OK, there is some directory information in the file.  Nothing to do
1379        but ensure the directory(s) exist, and create them if they don't.
1380        What a pain! */
1381     if(strchr((const char *)filename, '/') != NULL && handle){
1382       /* Loop through all the directories in the path, (everything w/ a '/') */
1383       const ub1 *start = filename;
1384       char *tmp_buff;
1385       struct stat sbuf;
1386
1387       tmp_buff = malloc(sizeof(char) * strlen((const char *)filename));
1388
1389       for(;;){
1390         const ub1 *idx = (const unsigned char *)strchr((const char *)start, '/');
1391
1392         if(idx == NULL)
1393           break;
1394         else if(idx == start){
1395           start++;
1396           continue;
1397         }
1398         start = idx + 1;
1399
1400         strncpy(tmp_buff, (const char *)filename, (idx - filename));
1401         tmp_buff[(idx - filename)] = '\0';
1402
1403 #ifdef DEBUG
1404         printf("checking the existance of %s\n", tmp_buff);
1405 #endif
1406
1407         if(stat(tmp_buff, &sbuf) < 0){
1408           if(errno != ENOENT){
1409             perror("stat");
1410             exit(1);
1411           }
1412
1413         } else if(S_ISDIR(sbuf.st_mode)){
1414 #ifdef DEBUG
1415           printf("Directory exists\n");
1416 #endif
1417           continue;
1418         }else {
1419           fprintf(stderr, "Hmmm.. %s exists but isn't a directory!\n",
1420                   tmp_buff);
1421           exit(1);
1422         }
1423
1424 #ifdef DEBUG
1425         printf("Making directory..\n");
1426 #endif
1427         if(mkdir(tmp_buff, 0755) < 0){
1428           perror("mkdir");
1429           exit(1);
1430         }
1431         if(verbose && handle)
1432           printf("%10s: %s/\n", "created", tmp_buff);
1433
1434       }
1435
1436       /* only a directory */
1437       if(strlen((const char *)start) == 0)
1438         dir = TRUE;
1439
1440 #ifdef DEBUG
1441       printf("Leftovers are \"%s\" (%d)\n", start, strlen((const char *)start));
1442 #endif
1443
1444       /* If the entry was just a directory, don't write to file, etc */
1445       if(strlen((const char *)start) == 0)
1446         f_fd = -1;
1447
1448       free(tmp_buff);
1449     }
1450
1451     if(f_fd != -1 && handle){
1452       f_fd = open((const char *)filename,
1453                   O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
1454
1455       if(f_fd < 0){
1456         fprintf(stderr, "Error extracting JAR archive!\n");
1457         perror((const char *)filename);
1458         exit(1);
1459       }
1460     }
1461
1462     if(method != 8 && flags & 0x0008){
1463       fprintf(stderr, "Error in JAR file! (not compressed but data desc.)\n");
1464       exit(1);
1465     }
1466
1467     if(method == 8 || flags & 0x0008){
1468       if(seekable)
1469         lseek(fd, eflen, SEEK_CUR);
1470       else
1471         consume(&pbf, eflen);
1472
1473       inflate_file(&pbf, f_fd, &ze);
1474     } else {
1475
1476 #ifdef DEBUG
1477       printf("writing stored data.. (%d bytes)\n", csize);
1478 #endif
1479
1480       out_a = 0;
1481       in_a = csize;
1482
1483       ze.crc = crc32(ze.crc, NULL, 0); /* initialize the crc */
1484
1485       while(out_a < (int)csize){
1486         rdamt = (in_a > RDSZ ? RDSZ : in_a);
1487         if(pb_read(&pbf, rd_buff, rdamt) != rdamt){
1488           perror("read");
1489           exit(1);
1490         }
1491
1492         ze.crc = crc32(ze.crc, (Bytef*)rd_buff, rdamt);
1493
1494         if(f_fd >= 0)
1495           write(f_fd, rd_buff, rdamt);
1496
1497         out_a += rdamt;
1498         in_a -= rdamt;
1499
1500 #ifdef DEBUG
1501         printf("%d bytes written\n", out_a);
1502 #endif
1503       }
1504
1505       if(seekable)
1506         lseek(fd, eflen, SEEK_CUR);
1507       else
1508         consume(&pbf, eflen);
1509     }
1510
1511     /* if there is a data descriptor left, compare the CRC */
1512     if(flags & 0x0008){
1513
1514       if(pb_read(&pbf, scratch, 16) != 16){
1515         perror("read");
1516         exit(1);
1517       }
1518
1519       signature = UNPACK_UB4(scratch, 0);
1520
1521       if(signature != 0x08074b50){
1522         fprintf(stderr, "Error! Missing data descriptor!\n");
1523         exit(1);
1524       }
1525
1526       crc = UNPACK_UB4(scratch, 4);
1527
1528     }
1529
1530     if(crc != ze.crc){
1531       fprintf(stderr, "Error! CRCs do not match! Got %x, expected %x\n",
1532               ze.crc, crc);
1533       exit(1);
1534     }
1535
1536     close(f_fd);
1537
1538     if(verbose && dir == FALSE && handle)
1539       printf("%10s: %s\n",
1540              (method == 8 ? "inflated" : "extracted"),
1541              filename);
1542   }
1543
1544   return 0;
1545 }
1546
1547 int list_jar(int fd, char **files, int file_num){
1548   ub4 signature;
1549   ub4 csize;
1550   ub4 usize;
1551   ub4 mdate;
1552   ub4 tmp;
1553   ub2 fnlen;
1554   ub2 eflen;
1555   ub2 clen;
1556   ub2 flags;
1557   ub2 method;
1558   ub2 cen_size;
1559   ub1 *filename = NULL;
1560   ub1 scratch[16];
1561   ub1 cen_header[46];
1562   int filename_len = 0;
1563   off_t size;
1564   int i, j;
1565   time_t tdate;
1566   struct tm *s_tm;
1567   char ascii_date[30];
1568   zipentry ze;
1569
1570 #ifdef DEBUG
1571   printf("Listing jar file, looking for %d files\n", file_num);
1572 #endif
1573
1574   /* This should be the start of the central-header-end section */
1575   if(seekable){
1576     if(lseek(fd, -22, SEEK_END) == (off_t)-1){
1577       perror("lseek");
1578       exit(1);
1579     }
1580
1581     if(read(fd, &tmp, sizeof(ub4)) != 4){
1582       perror("read");
1583       exit(1);
1584     }
1585
1586 #ifdef WORDS_BIGENDIAN
1587     tmp = L2BI(tmp);
1588 #endif
1589
1590     if(tmp != 0x06054b50){
1591       fprintf(stderr, "Error in JAR file format. zip-style comment?\n");
1592       exit(1);
1593     }
1594
1595     if(lseek(fd, 6, SEEK_CUR) == (off_t)-1){
1596       perror("lseek");
1597       exit(1);
1598     }
1599
1600     if(read(fd, &cen_size, 2) != 2){
1601       perror("read");
1602       exit(1);
1603     }
1604
1605 #ifdef WORDS_BIGENDIAN
1606     cen_size = L2BS(cen_size);
1607 #endif
1608
1609     /*   printf("%hu entries in central header\n", cen_size); */
1610
1611     if(lseek(fd, 4, SEEK_CUR) == (off_t)-1){
1612       perror("lseek");
1613       exit(1);
1614     }
1615
1616     if(read(fd, &tmp, 4) != 4){
1617       perror("read");
1618       exit(1);
1619     }
1620
1621 #ifdef WORDS_BIGENDIAN
1622     tmp = L2BI(tmp);
1623 #endif
1624
1625     /*   printf("Central header offset = %d\n", tmp); */
1626
1627     if(lseek(fd, tmp, SEEK_SET) != (int)tmp){
1628       perror("lseek");
1629       exit(1);
1630     }
1631
1632     /* Loop through the entries in the central header */
1633     for(i = 0; i < cen_size; i++){
1634
1635       if(read(fd, &cen_header, 46) != 46){
1636         perror("read");
1637         exit(1);
1638       }
1639
1640       signature = UNPACK_UB4(cen_header, 0);
1641       if(signature != 0x02014b50){
1642         fprintf(stderr, "Error in JAR file! Cannot locate central header!\n");
1643         exit(1);
1644       }
1645
1646       usize = UNPACK_UB4(cen_header, CEN_USIZE);
1647       fnlen = UNPACK_UB2(cen_header, CEN_FNLEN);
1648       eflen = UNPACK_UB2(cen_header, CEN_EFLEN);
1649       clen = UNPACK_UB2(cen_header, CEN_COMLEN);
1650
1651       /* If we're providing verbose output, we need to make an ASCII
1652        * formatted version of the date. */
1653       if(verbose){
1654         mdate = UNPACK_UB4(cen_header, CEN_MODTIME);
1655         tdate = dos2unixtime(mdate);
1656         s_tm = localtime(&tdate);
1657         strftime(ascii_date, 30, "%a %b %d %H:%M:%S %Z %Y", s_tm);
1658       }
1659
1660       if(filename_len < fnlen + 1){
1661         if(filename != NULL)
1662           free(filename);
1663
1664         filename = malloc(sizeof(ub1) * (fnlen + 1));
1665         filename_len = fnlen + 1;
1666       }
1667
1668       if(read(fd, filename, fnlen) != fnlen){
1669         perror("read");
1670         exit(1);
1671       }
1672       filename[fnlen] = '\0';
1673
1674       /* if the user specified a list of files on the command line,
1675          we'll only display those, otherwise we'll display everything */
1676       if(file_num > 0){
1677         for(j = 0; j < file_num; j++)
1678           if(strcmp(files[j], (const char *)filename) == 0){
1679             if(verbose)
1680               printf("%6d %s %s\n", usize, ascii_date, filename);
1681             else
1682               printf("%s\n", filename);
1683             break;
1684           }
1685       } else {
1686         if(verbose)
1687           printf("%6d %s %s\n", usize, ascii_date, filename);
1688         else
1689           printf("%s\n", filename);
1690       }
1691
1692       size = eflen + clen;
1693       if(size > 0){
1694         if(lseek(fd, size, SEEK_CUR) == (off_t)-1){
1695           perror("lseek");
1696           exit(1);
1697         }
1698       }
1699     }
1700   } else {
1701     /* the file isn't seekable.. evil! */
1702     pb_file pbf;
1703
1704     pb_init(&pbf, fd);
1705
1706     init_inflation();
1707
1708     for(;;){
1709       if(pb_read(&pbf, scratch, 4) != 4){
1710         perror("read");
1711         break;
1712       }
1713
1714       signature = UNPACK_UB4(scratch, 0);
1715
1716 #ifdef DEBUG
1717       printf("signature is %x\n", signature);
1718 #endif
1719
1720       if(signature == 0x08074b50){
1721 #ifdef DEBUG
1722         printf("skipping data descriptor\n");
1723 #endif
1724         pb_read(&pbf, scratch, 12);
1725         continue;
1726       } else if(signature == 0x02014b50){
1727 #ifdef DEBUG
1728         printf("Central header reached.. we're all done!\n");
1729 #endif
1730         break;
1731       }else if(signature != 0x04034b50){
1732 #ifdef DEBUG
1733         printf("Ick! %#x\n", signature);
1734 #endif
1735         break;
1736       }
1737
1738       if(pb_read(&pbf, (file_header + 4), 26) != 26){
1739         perror("read");
1740         break;
1741       }
1742
1743       csize = UNPACK_UB4(file_header, LOC_CSIZE);
1744 #ifdef DEBUG
1745       printf("Compressed size is %u\n", csize);
1746 #endif
1747
1748       fnlen = UNPACK_UB2(file_header, LOC_FNLEN);
1749 #ifdef DEBUG
1750       printf("Filename length is %hu\n", fnlen);
1751 #endif
1752
1753       eflen = UNPACK_UB2(file_header, LOC_EFLEN);
1754 #ifdef DEBUG
1755       printf("Extra field length is %hu\n", eflen);
1756 #endif
1757
1758       method = UNPACK_UB2(file_header, LOC_COMP);
1759 #ifdef DEBUG
1760       printf("Compression method is %#hx\n", method);
1761 #endif
1762
1763       flags = UNPACK_UB2(file_header, LOC_EXTRA);
1764 #ifdef DEBUG
1765       printf("Flags are %#hx\n", flags);
1766 #endif
1767
1768       usize = UNPACK_UB4(file_header, LOC_USIZE);
1769
1770       /* If we're providing verbose output, we need to make an ASCII
1771        * formatted version of the date. */
1772       if(verbose){
1773         mdate = UNPACK_UB4(file_header, LOC_MODTIME);
1774         tdate = dos2unixtime(mdate);
1775         s_tm = localtime(&tdate);
1776         strftime(ascii_date, 30, "%a %b %d %H:%M:%S %Z %Y", s_tm);
1777       }
1778
1779       if(filename_len < fnlen + 1){
1780         if(filename != NULL)
1781           free(filename);
1782
1783         filename = malloc(sizeof(ub1) * (fnlen + 1));
1784         filename_len = fnlen + 1;
1785       }
1786
1787       pb_read(&pbf, filename, fnlen);
1788       filename[fnlen] = '\0';
1789
1790       /* the header is at the end.  In a JAR file, this means that the data
1791          happens to be compressed.  We have no choice but to inflate the
1792          data */
1793       if(flags & 0x0008){
1794
1795         size = eflen;
1796
1797         if(size > 0)
1798           consume(&pbf, size);
1799
1800         if(method == 8){
1801 #ifdef DEBUG
1802           printf("inflating %s\n", filename);
1803 #endif
1804           inflate_file(&pbf, -1, &ze);
1805
1806           usize = ze.usize;
1807         } else
1808           printf("We're shit outta luck!\n");
1809
1810       } else {
1811         size = csize + (eflen > 0 ? eflen : 0);
1812
1813
1814 #ifdef DEBUG
1815         printf("Skipping %ld bytes\n", (long)size);
1816 #endif
1817
1818         consume(&pbf, size);
1819       }
1820       /* print out the listing */
1821       if(file_num > 0){
1822         for(j = 0; j < file_num; j++)
1823           if(strcmp(files[j], (const char *)filename) == 0){
1824             if(verbose)
1825               printf("%6d %s %s\n", usize, ascii_date, filename);
1826             else
1827               printf("%s\n", filename);
1828             break;
1829           }
1830       } else {
1831         if(verbose)
1832           printf("%6d %s %s\n", usize, ascii_date, filename);
1833         else
1834           printf("%s\n", filename);
1835       }
1836     }
1837   }
1838   return 0;
1839 }
1840
1841 int consume(pb_file *pbf, int amt){
1842   int tc = 0; /* total amount consumed */
1843   ub1 buff[RDSZ];
1844   int rdamt;
1845
1846 #ifdef DEBUG
1847   printf("Consuming %d bytes\n", amt);
1848 #endif
1849
1850   while(tc < amt){
1851     rdamt = pb_read(pbf, buff, ((amt - tc) < RDSZ ? (amt - tc) : RDSZ));
1852 #ifdef DEBUG
1853     printf("got %d bytes\n", rdamt);
1854 #endif
1855     tc += rdamt;
1856   }
1857
1858 #ifdef DEBUG
1859   printf("%d bytes consumed\n", tc);
1860 #endif
1861
1862   return 0;
1863 }
1864
1865 void usage(const char *filename){
1866   fprintf(stderr, "Try `%s --help' for more information.\n", filename);
1867   exit (1);
1868 }
1869
1870 void version ()
1871 {
1872   printf("jar (%s) %s\n\n", PACKAGE, VERSION);
1873   printf("Copyright 1999, 2000, 2001  Bryan Burns\n");
1874   printf("Copyright 2002 Free Software Foundation\n");
1875   printf("\
1876 This is free software; see the source for copying conditions.  There is NO\n\
1877 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
1878   exit (0);
1879 }
1880
1881 void help(const char *filename)
1882 {
1883   printf("\
1884 Usage: %s {ctxuV}[vfm0ME@] [jar-file] [manifest-file] [-C dir] files ...\n\
1885 \n\
1886 Store many files together in a single `jar' file.\n\
1887 \n\
1888   -c              create new archive\n\
1889   -t              list table of contents for archive\n\
1890   -x              extract named (or all) files from archive\n\
1891   -u              update existing archive\n\
1892 ", filename);
1893   printf("\n\
1894   -@              read names from stdin\n\
1895   -0              store only; use no ZIP compression\n\
1896   -C DIR FILE     change to the specified directory and include\n\
1897                   the following file\n\
1898   -E              don't include the files found in a directory\n\
1899   -f FILE         specify archive file name\n\
1900   --help          print this help, then exit\n\
1901   -m FILE         include manifest information from specified manifest file\n\
1902   -M              Do not create a manifest file for the entries\n\
1903   -v              generate verbose output on standard output\n\
1904   -V, --version   display version information\n\
1905 ");
1906   printf("\n\
1907 If any file is a directory then it is processed recursively.\n\
1908 The manifest file name and the archive file name needs to be specified\n\
1909 in the same order the 'm' and 'f' flags are specified.\n\
1910 \n\
1911 Example 1: to archive two class files into an archive called classes.jar: \n\
1912      jar cvf classes.jar Foo.class Bar.class \n\
1913 Example 2: use an existing manifest file 'mymanifest' and archive all the\n\
1914      files in the foo/ directory into 'classes.jar': \n\
1915      jar cvfm classes.jar mymanifest -C foo/ .\n\
1916 ");
1917
1918   exit(0);
1919 }
1920
1921 static char *
1922 jt_strdup(s)
1923      char *s;
1924 {
1925   char *result = (char*)malloc(strlen(s) + 1);
1926   if (result == (char*)0)
1927     return (char*)0;
1928   strcpy(result, s);
1929   return result;
1930 }
1931
1932 /* Convert "tar-style" first argument to a form expected by getopt.
1933    This idea and the code comes from GNU tar.  This can allocate a new
1934    argument vector.  This might leak some memory, but we don't care.  */
1935 static void
1936 expand_options (int *argcp, char ***argvp)
1937 {
1938   int argc = *argcp;
1939   char **argv = *argvp;
1940
1941   /* Accept arguments with a leading "-" (eg "-cvf"), but don't do expansion
1942      if a long argument (like "--help") is detected. */
1943   if (argc > 1 && argv[1][1] != '-')
1944     {
1945       char buf[3];
1946       char **new_argv;
1947       int new_argc;
1948       int args_to_expand;
1949       char *p;
1950       char **in, **out;
1951
1952       buf[0] = '-';
1953       buf[2] = '\0';
1954
1955       args_to_expand = strlen (argv[1]);
1956       if (argv[1][0] == '-')
1957         --args_to_expand;
1958
1959       new_argc = argc - 1 + args_to_expand;
1960       new_argv = (char **) malloc (new_argc * sizeof (char *));
1961       in = argv;
1962       out = new_argv;
1963
1964       *out++ = *in++;
1965       p = *in++;
1966       if (*p == '-')
1967         p++;
1968       while (*p != '\0')
1969         {
1970           char *opt;
1971           buf[1] = *p;
1972           *out++ = jt_strdup (buf);
1973           /* If the option takes an argument, move the next argument
1974              to just after this option.  */
1975           opt = strchr (OPTION_STRING, *p);
1976           if (opt && opt[1] == ':')
1977             {
1978               if (in < argv + argc)
1979                 *out++ = *in++;
1980               else
1981                 {
1982                   fprintf(stderr, "%s: option `%s' requires an argument.\n",
1983                           argv[0], buf);
1984                   usage(argv[0]);
1985                 }
1986             }
1987           ++p;
1988         }
1989
1990       /* Copy remaining options.  */
1991       while (in < argv + argc)
1992         *out++ = *in++;
1993
1994       *argcp = new_argc;
1995       *argvp = new_argv;
1996     }
1997 }