OSDN Git Service

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