(FIXED_REGISTERS): Add Maverick registers.
[official-gcc.git] / fastjar / jartool.c
blobaacf765f21d69e5f3e75e6132012d290a67d53e6
1 /*
2 jartool.c - main functions for fastjar utility
3 Copyright (C) 2002 Free Software Foundation
4 Copyright (C) 1999, 2000, 2001 Bryan Burns
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.
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.
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.
22 Revision 1.10 2002/01/03 04:57:56 rodrigc
23 2001-01-02 Craig Rodrigues <rodrigc@gcc.gnu.org>
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.
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".
41 Revision 1.8 2001/08/29 01:35:31 apbianco
42 2001-08-28 Alexandre Petit-Bianco <apbianco@redhat.com>
44 * jartool.c (add_to_jar): Return 1 if `stat' initialy failed.
45 Fixes PR java/3949.
47 (http://gcc.gnu.org/ml/gcc-patches/2001-08/msg01641.html)
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.
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.
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.
65 Revision 1.4 2000/12/28 21:47:37 robertl
66 2000-12-28 Robert Lipe <robertl@sco.com>
68 * jartool.c (MAXPATHLEN): Provide if not defined.
70 Revision 1.3 2000/12/14 18:45:35 ghazi
71 Warning fixes:
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.
79 * compress.h (init_compression, end_compression, init_inflation,
80 end_inflation): Prototype void arguments.
82 * dostime.c (rcsid): Delete.
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.
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.
96 * pushback.c (rcsid): Delete.
98 Revision 1.2 2000/12/13 18:11:57 tromey
99 * jartool.c (extract_jar): Use strchr, not index.
101 Revision 1.1 2000/12/09 03:08:23 apbianco
102 2000-12-08 Alexandre Petit-Bianco <apbianco@cygnus.com>
104 * fastjar: Imported.
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.
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.
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.
120 Revision 1.2 1999/12/06 07:38:28 toast
121 fixed recursive archiving bug
123 Revision 1.1.1.1 1999/12/06 03:09:34 toast
124 initial checkin..
128 Revision 1.22 1999/10/12 19:45:13 burnsbr
129 adding patch to fix compat problem
131 Revision 1.21 1999/05/10 09:15:49 burnsbr
132 fixed manifest file version info
134 Revision 1.20 1999/05/10 08:53:16 burnsbr
135 *** empty log message ***
137 Revision 1.19 1999/05/10 08:30:39 burnsbr
138 added extract / listing code
140 Revision 1.18 1999/04/28 04:24:29 burnsbr
141 updated version
143 Revision 1.17 1999/04/28 04:21:23 burnsbr
144 added support for -C dir-changing flag.. Updated total compression display
146 Revision 1.16 1999/04/27 10:28:22 burnsbr
147 updated version string
149 Revision 1.15 1999/04/27 10:04:06 burnsbr
150 configure support
152 Revision 1.14 1999/04/27 08:56:14 burnsbr
153 added -V flag, better error messages
155 Revision 1.13 1999/04/26 02:35:21 burnsbr
156 changed all sorts of stuff.. compression now works 100%
158 Revision 1.12 1999/04/23 12:00:45 burnsbr
159 90% done with compression code
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..
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.
170 Revision 1.9 1999/04/21 09:55:16 burnsbr
171 pulled out printfs
173 Revision 1.8 1999/04/21 02:58:01 burnsbr
174 started manifest code
176 Revision 1.7 1999/04/20 23:15:28 burnsbr
177 added patch sent by John Bley <jbb6@acpub.duke.edu>
179 Revision 1.6 1999/04/20 08:56:02 burnsbr
180 added GPL comment
182 Revision 1.5 1999/04/20 08:16:09 burnsbr
183 fixed verbose flag, did some optimization
185 Revision 1.4 1999/04/20 05:09:59 burnsbr
186 added rcsid variable
188 Revision 1.3 1999/04/20 05:08:54 burnsbr
189 fixed Log statement
193 #include "config.h"
195 #include <zlib.h>
197 #ifdef HAVE_STDLIB_H
198 #include <stdlib.h>
199 #endif
201 #ifdef HAVE_UNISTD_H
202 #include <unistd.h>
203 #endif
205 #include <stdio.h>
206 #include <sys/stat.h>
207 #include <sys/types.h>
209 #ifdef HAVE_SYS_PARAM_H
210 #include <sys/param.h>
211 #endif
213 #ifndef MAXPATHLEN
214 #define MAXPATHLEN 1024
215 #endif
217 #ifdef HAVE_DIRENT_H
218 #include <dirent.h>
219 #endif
221 #ifdef HAVE_FCNTL_H
222 #include <fcntl.h>
223 #endif
225 #include <string.h>
226 #include <errno.h>
228 #ifdef TM_IN_SYS_TIME
229 #include <sys/time.h>
230 #else
231 #include <time.h>
232 #endif
234 #include <getopt.h>
236 #include "jartool.h"
237 #include "zipfile.h"
238 #include "dostime.h"
239 #include "pushback.h"
240 #include "compress.h"
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
248 #ifdef WORDS_BIGENDIAN
250 #define L2BI(l) ((l & 0xff000000) >> 24) | \
251 ((l & 0x00ff0000) >> 8) | \
252 ((l & 0x0000ff00) << 8) | \
253 ((l & 0x000000ff) << 24);
255 #define L2BS(l) ((l & 0xff00) >> 8) | ((l & 0x00ff) << 8);
257 #endif
259 #ifndef errno
260 extern int errno;
261 #endif
263 #ifndef O_BINARY
264 #define O_BINARY 0
265 #endif
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);
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);
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;
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;
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;
302 zipentry *ziplist; /* linked list of entries */
303 zipentry *ziptail; /* tail of the linked list */
305 int number_of_entries; /* number of entries in the linked list */
307 /* This is used to mark options with no short value. */
308 #define LONG_OPT(Num) ((Num) + 128)
310 #define OPT_HELP LONG_OPT (0)
312 /* This holds all options. */
313 #define OPTION_STRING "-ctxuvVf:m:C:0ME@"
315 static const struct option options[] =
317 { "help", no_argument, NULL, OPT_HELP },
318 { "version", no_argument, NULL, 'V' },
319 { NULL, no_argument, NULL, 0 }
322 int main(int argc, char **argv){
324 char *mfile = NULL;
326 int action = ACTION_NONE;
327 int manifest = TRUE;
328 int opt;
330 int jarfd = -1;
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;
337 do_compress = TRUE;
338 verbose = FALSE;
340 ziplist = NULL;
342 number_of_entries = 0;
344 if(argc < 2)
345 usage(argv[0]);
347 new_argc = 0;
348 new_argv = (char **) malloc (argc * sizeof (char *));
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;
392 case OPT_HELP:
393 help(argv[0]);
394 break;
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]);
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;
414 if(action == ACTION_NONE){
415 fprintf(stderr, "One of options -{ctxu} must be specified.\n");
416 usage(argv[0]);
419 if(action == ACTION_UPDATE){
420 fprintf(stderr, "%s: `-u' mode unimplemented.\n", argv[0]);
421 exit(1);
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]);
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);
441 if(jarfd < 0){
442 fprintf(stderr, "Error opening %s for writing!\n", jarfile);
443 perror(jarfile);
444 exit(1);
447 /* We assume that the file is seekable */
448 seekable = TRUE;
450 } else {
452 jarfd = STDOUT_FILENO; /* jarfd is stdout otherwise */
454 /* standard out is not seekable */
455 seekable = FALSE;
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;
461 } else if(action == ACTION_LIST || action == ACTION_EXTRACT){
463 if(jarfile){
464 jarfd = open(jarfile, O_RDONLY | O_BINARY);
466 if(jarfd < 0){
467 fprintf(stderr, "Error opening %s for reading!\n", jarfile);
468 perror(jarfile);
469 exit(1);
472 seekable = TRUE;
473 } else {
474 jarfd = STDIN_FILENO; /* jarfd is standard in */
476 /* we assume that the stream isn't seekable for safety */
477 seekable = FALSE;
481 if(action == ACTION_CREATE || action == ACTION_UPDATE){
482 const char *arg;
483 init_headers();
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);
493 if(do_compress)
494 init_compression();
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);
503 init_args (new_argv, 0);
504 /* now we add the files to the archive */
505 while ((arg = get_next_arg ())){
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);
516 } else {
517 if(add_to_jar(jarfd, NULL, arg)){
518 printf("Error adding %s to jar archive!\n", arg);
519 exit(1);
523 /* de-initialize the compression DS */
524 if(do_compress)
525 end_compression();
527 create_central_header(jarfd);
529 if (close(jarfd) != 0) {
530 fprintf(stderr, "Error closing jar archive!\n");
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);
538 exit(0);
541 static int args_current_g;
542 static char **args_g;
544 static void
545 init_args(args, current)
546 char **args;
547 int current;
549 if(!read_names_from_stdin)
551 args_g = args;
552 args_current_g = current;
556 static char *
557 get_next_arg ()
559 static int reached_end = 0;
561 if (reached_end)
562 return NULL;
564 if (args_g)
566 if (!args_g [args_current_g])
568 reached_end = 1;
569 return NULL;
571 return args_g [args_current_g++];
573 else
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. */
579 char s [MAXPATHLEN];
580 int pos = 0;
582 /* Get rid of '\n' and '\r' first. */
583 while (1)
585 int c = getc (stdin);
586 if (c == '\n' || c == '\r')
587 continue;
588 else
590 if (c == EOF)
591 return NULL;
592 ungetc (c, stdin);
593 break;
597 while (1)
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;
607 if (pos)
609 s [pos] = '\0';
610 return jt_strdup (s);
612 else
613 return NULL;
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;
630 file_header[7] = 0x00;
631 /* do_compression method (deflation) */
632 file_header[8] = 0;
633 file_header[9] = 0;
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;
663 /* Initialize the compression DS */
664 PACK_UB4(data_descriptor, 0, 0x08074b50);
668 void add_entry(struct zipentry *ze){
670 if(ziplist == NULL){
671 ziplist = ze;
672 ziptail = ziplist;
673 } else {
674 ziplist->next_entry = ze;
675 ziplist = ze;
678 number_of_entries++;
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;
687 nlen = 9; /* trust me on this one */
689 memset((file_header + 12), '\0', 16); /*clear mod time, crc, size fields*/
691 current_time = time(NULL);
692 if(current_time == (time_t)-1){
693 perror("time");
694 exit(1);
697 mod_time = unix2dostime(&current_time);
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);
704 if(verbose)
705 printf("adding: META-INF/ (in=0) (out=0) (stored 0%%)\n");
707 ze = (zipentry*)malloc(sizeof(zipentry));
708 if(ze == NULL){
709 perror("malloc");
710 exit(1);
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';
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;
723 add_entry(ze);
725 write(jfd, file_header, 30);
726 write(jfd, "META-INF/", nlen);
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;
733 if((mf = (char *) malloc(mf_len + 1))) {
734 uLong crc;
736 sprintf(mf, "Manifest-Version: 1.0\nCreated-By: %s\n\n", VERSION);
738 crc = crc32(0L, Z_NULL, 0);
740 crc = crc32(crc, (const unsigned char *)mf, mf_len);
742 nlen = 20; /* once again, trust me */
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);
749 memcpy((file_header + LOC_CSIZE), (file_header + LOC_USIZE), 4);
751 PACK_UB4(file_header, LOC_CRC, crc);
753 if(verbose)
754 printf("adding: META-INF/MANIFEST.MF (in=56) (out=56) (stored 0%%)\n");
756 ze = (zipentry*)malloc(sizeof(zipentry));
757 if(ze == NULL){
758 perror("malloc");
759 exit(1);
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';
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;
775 add_entry(ze);
777 write(jfd, file_header, 30);
778 write(jfd, "META-INF/MANIFEST.MF", nlen);
779 write(jfd, mf, mf_len);
780 free(mf);
782 else {
783 printf("malloc errror\n");
784 exit(-1);
786 } else {
787 int mfd;
788 struct stat statbuf;
790 stat(mf_name, &statbuf);
792 if(!S_ISREG(statbuf.st_mode)){
793 fprintf(stderr, "Invalid manifest file specified.\n");
794 exit(1);
797 mfd = open(mf_name, O_RDONLY | O_BINARY);
799 if(mfd < 0){
800 fprintf(stderr, "Error opening %s.\n", mf_name);
801 exit(1);
804 if(add_file_to_jar(jfd, mfd, "META-INF/MANIFEST.MF", &statbuf)){
805 perror("error writing to jar");
806 exit(1);
811 return 0;
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;
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.
829 while (*file=='.' && *(file+1)=='/')
830 file+=2;
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);
837 if(chdir(new_dir) == -1){
838 perror(new_dir);
839 return 1;
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.. */
849 stat_return = stat(file, &statbuf);
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;
860 dir = opendir(file);
862 if(dir == NULL){
863 perror("opendir");
864 return 1;
867 nlen = strlen(file) + 256;
868 fullname = (char*)malloc(nlen * sizeof(char));
869 memset(fullname, 0, (nlen * sizeof(char)));
871 if(fullname == NULL){
872 fprintf(stderr, "Filename is NULL!\n");
873 return 1;
876 strcpy(fullname, file);
877 nlen = strlen(file);
879 if(fullname[nlen - 1] != '/'){
880 fullname[nlen] = '/';
881 t_ptr = (fullname + nlen + 1);
882 } else
883 t_ptr = (fullname + nlen);
886 memset((file_header + 12), '\0', 16); /*clear mod time, crc, size fields*/
888 nlen = (t_ptr - fullname);
890 mod_time = unix2dostime(&statbuf.st_mtime);
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);
897 if(verbose)
898 printf("adding: %s (in=%d) (out=%d) (stored 0%%)\n", fullname, 0, 0);
900 ze = (zipentry*)malloc(sizeof(zipentry));
901 if(ze == NULL){
902 perror("malloc");
903 exit(1);
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';
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;
916 add_entry(ze);
918 write(fd, file_header, 30);
919 write(fd, fullname, nlen);
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;
931 strcpy(t_ptr, de->d_name);
933 if(add_to_jar(fd, NULL, fullname)){
934 fprintf(stderr, "Error adding file to jar!\n");
935 return 1;
939 free(fullname);
940 closedir(dir);
942 } else if(S_ISREG(statbuf.st_mode)){
943 int add_fd;
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;
951 if(add_file_to_jar(fd, add_fd, file, &statbuf)){
952 fprintf(stderr, "Error adding file to jar!\n");
953 return 1;
956 } else {
957 fprintf(stderr, "Illegal file specified: %s\n", file);
960 if(old_dir != NULL){
961 if(chdir(old_dir))
962 perror(old_dir);
964 free(old_dir);
967 return 0;
970 int add_file_to_jar(int jfd, int ffd, const char *fname, struct stat *statbuf){
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;
980 mod_time = unix2dostime(&(statbuf->st_mtime));
981 file_name_length = strlen(fname);
983 if(!seekable && !do_compress){
984 crc = crc32(0L, Z_NULL, 0);
986 while((rdamt = read(ffd, rd_buff, RDSZ)) != 0)
987 crc = crc32(crc, rd_buff, rdamt);
989 lseek(ffd, 0, SEEK_SET);
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);
999 if(do_compress){
1000 PACK_UB2(file_header, LOC_COMP, 8);
1001 } else {
1002 PACK_UB2(file_header, LOC_COMP, 0);
1005 PACK_UB4(file_header, LOC_MODTIME, mod_time);
1006 PACK_UB2(file_header, LOC_FNLEN, file_name_length);
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 */
1015 ze = (zipentry*)malloc(sizeof(zipentry));
1016 if(ze == NULL){
1017 perror("malloc");
1018 exit(1);
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);
1025 ze->mod_time = (ub2)(mod_time & 0x0000ffff);
1026 ze->mod_date = (ub2)((mod_time & 0xffff0000) >> 16);
1028 if(!seekable && !do_compress)
1029 ze->crc = crc;
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;
1039 add_entry(ze);
1041 /* Write the local header */
1042 write(jfd, file_header, 30);
1044 /* write the file name to the zip file */
1045 write(jfd, fname, file_name_length);
1048 if(verbose){
1049 printf("adding: %s ", fname);
1050 fflush(stdout);
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);
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;
1069 close(ffd);
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);
1076 /* we need to seek back and fill the header */
1077 if(seekable){
1078 offset = (ze->csize + strlen(ze->filename) + 16);
1080 if(lseek(jfd, -offset, SEEK_CUR) == (off_t)-1){
1081 perror("lseek");
1082 exit(1);
1085 if(write(jfd, (data_descriptor + 4), 12) != 12){
1086 perror("write");
1087 return 0;
1090 offset -= 12;
1092 if(lseek(jfd, offset, SEEK_CUR) == (off_t)-1){
1093 perror("lseek");
1094 exit(1);
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 */
1101 if(write(jfd, data_descriptor, 16) != 16){
1102 perror("write");
1103 return 0;
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));
1113 return 0;
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;
1123 zipentry *ze;
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;
1189 start_offset = lseek(fd, 0, SEEK_CUR);
1191 for(ze = ziptail; ze != NULL; ze = ze->next_entry){
1193 total_in += ze->usize;
1194 total_out += ze->csize + 76 + strlen(ze->filename) * 2;
1196 if(ze->compressed){
1197 PACK_UB2(header, CEN_COMP, 8);
1198 } else {
1199 PACK_UB2(header, CEN_COMP, 0);
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);
1210 write(fd, header, 46);
1212 write(fd, ze->filename, strlen(ze->filename));
1215 dir_size = lseek(fd, 0, SEEK_CUR) - start_offset;
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;
1240 write(fd, end_header, 22);
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)
1250 return 0;
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;
1274 init_inflation();
1276 pb_init(&pbf, fd);
1278 for(;;){
1279 f_fd = 0;
1280 crc = 0;
1281 ze.crc = 0;
1283 dir = FALSE; /* by default, the file isn't a dir */
1284 handle = TRUE; /* by default we'll extract/create the file */
1286 if((rdamt = pb_read(&pbf, scratch, 4)) != 4){
1287 perror("read");
1288 break;
1291 signature = UNPACK_UB4(scratch, 0);
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;
1312 if((rdamt = pb_read(&pbf, (file_header + 4), 26)) != 26){
1313 perror("read");
1314 break;
1317 csize = UNPACK_UB4(file_header, LOC_CSIZE);
1318 #ifdef DEBUG
1319 printf("Compressed size is %u\n", csize);
1320 #endif
1322 fnlen = UNPACK_UB2(file_header, LOC_FNLEN);
1323 #ifdef DEBUG
1324 printf("Filename length is %hu\n", fnlen);
1325 #endif
1327 eflen = UNPACK_UB2(file_header, LOC_EFLEN);
1328 #ifdef DEBUG
1329 printf("Extra field length is %hu\n", eflen);
1330 #endif
1332 flags = UNPACK_UB2(file_header, LOC_EXTRA);
1333 #ifdef DEBUG
1334 printf("Flags are %#hx\n", flags);
1335 #endif
1337 method = UNPACK_UB2(file_header, LOC_COMP);
1338 #ifdef DEBUG
1339 printf("Compression method is %#hx\n", method);
1340 #endif
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
1350 if(filename_len < fnlen + 1){
1351 if(filename != NULL)
1352 free(filename);
1354 filename = malloc(sizeof(ub1) * (fnlen + 1));
1355 filename_len = fnlen + 1;
1358 pb_read(&pbf, filename, fnlen);
1359 filename[fnlen] = '\0';
1361 #ifdef DEBUG
1362 printf("filename is %s\n", filename);
1363 #endif
1365 if(file_num > 0){
1366 handle = FALSE;
1368 for(j = 0; j < file_num; j++)
1369 if(strcmp(files[j], (const char *)filename) == 0){
1370 handle = TRUE;
1371 break;
1375 if(!handle)
1376 f_fd = -1;
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;
1387 tmp_buff = malloc(sizeof(char) * strlen((const char *)filename));
1389 for(;;){
1390 const ub1 *idx = (const unsigned char *)strchr((const char *)start, '/');
1392 if(idx == NULL)
1393 break;
1394 else if(idx == start){
1395 start++;
1396 continue;
1398 start = idx + 1;
1400 strncpy(tmp_buff, (const char *)filename, (idx - filename));
1401 tmp_buff[(idx - filename)] = '\0';
1403 #ifdef DEBUG
1404 printf("checking the existance of %s\n", tmp_buff);
1405 #endif
1407 if(stat(tmp_buff, &sbuf) < 0){
1408 if(errno != ENOENT){
1409 perror("stat");
1410 exit(1);
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);
1424 #ifdef DEBUG
1425 printf("Making directory..\n");
1426 #endif
1427 if(mkdir(tmp_buff, 0755) < 0){
1428 perror("mkdir");
1429 exit(1);
1431 if(verbose && handle)
1432 printf("%10s: %s/\n", "created", tmp_buff);
1436 /* only a directory */
1437 if(strlen((const char *)start) == 0)
1438 dir = TRUE;
1440 #ifdef DEBUG
1441 printf("Leftovers are \"%s\" (%d)\n", start, strlen((const char *)start));
1442 #endif
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;
1448 free(tmp_buff);
1451 if(f_fd != -1 && handle){
1452 f_fd = open((const char *)filename,
1453 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
1455 if(f_fd < 0){
1456 fprintf(stderr, "Error extracting JAR archive!\n");
1457 perror((const char *)filename);
1458 exit(1);
1462 if(method != 8 && flags & 0x0008){
1463 fprintf(stderr, "Error in JAR file! (not compressed but data desc.)\n");
1464 exit(1);
1467 if(method == 8 || flags & 0x0008){
1468 consume(&pbf, eflen);
1470 inflate_file(&pbf, f_fd, &ze);
1471 } else {
1473 #ifdef DEBUG
1474 printf("writing stored data.. (%d bytes)\n", csize);
1475 #endif
1477 out_a = 0;
1478 in_a = csize;
1480 ze.crc = crc32(ze.crc, NULL, 0); /* initialize the crc */
1482 while(out_a < (int)csize){
1483 rdamt = (in_a > RDSZ ? RDSZ : in_a);
1484 if(pb_read(&pbf, rd_buff, rdamt) != rdamt){
1485 perror("read");
1486 exit(1);
1489 ze.crc = crc32(ze.crc, (Bytef*)rd_buff, rdamt);
1491 if(f_fd >= 0)
1492 write(f_fd, rd_buff, rdamt);
1494 out_a += rdamt;
1495 in_a -= rdamt;
1497 #ifdef DEBUG
1498 printf("%d bytes written\n", out_a);
1499 #endif
1502 consume(&pbf, eflen);
1505 /* if there is a data descriptor left, compare the CRC */
1506 if(flags & 0x0008){
1508 if(pb_read(&pbf, scratch, 16) != 16){
1509 perror("read");
1510 exit(1);
1513 signature = UNPACK_UB4(scratch, 0);
1515 if(signature != 0x08074b50){
1516 fprintf(stderr, "Error! Missing data descriptor!\n");
1517 exit(1);
1520 crc = UNPACK_UB4(scratch, 4);
1524 if(crc != ze.crc){
1525 fprintf(stderr, "Error! CRCs do not match! Got %x, expected %x\n",
1526 ze.crc, crc);
1527 exit(1);
1530 close(f_fd);
1532 if(verbose && dir == FALSE && handle)
1533 printf("%10s: %s\n",
1534 (method == 8 ? "inflated" : "extracted"),
1535 filename);
1538 return 0;
1541 int list_jar(int fd, char **files, int file_num){
1542 ub4 signature;
1543 ub4 csize;
1544 ub4 usize;
1545 ub4 mdate;
1546 ub4 tmp;
1547 ub2 fnlen;
1548 ub2 eflen;
1549 ub2 clen;
1550 ub2 flags;
1551 ub2 method;
1552 ub2 cen_size;
1553 ub1 *filename = NULL;
1554 ub1 scratch[16];
1555 ub1 cen_header[46];
1556 int filename_len = 0;
1557 off_t size;
1558 int i, j;
1559 time_t tdate;
1560 struct tm *s_tm;
1561 char ascii_date[31];
1562 zipentry ze;
1564 #ifdef DEBUG
1565 printf("Listing jar file, looking for %d files\n", file_num);
1566 #endif
1568 /* This should be the start of the central-header-end section */
1569 if(seekable){
1570 if(lseek(fd, -22, SEEK_END) == (off_t)-1){
1571 perror("lseek");
1572 exit(1);
1575 if(read(fd, &tmp, sizeof(ub4)) != 4){
1576 perror("read");
1577 exit(1);
1580 #ifdef WORDS_BIGENDIAN
1581 tmp = L2BI(tmp);
1582 #endif
1584 if(tmp != 0x06054b50){
1585 fprintf(stderr, "Error in JAR file format. zip-style comment?\n");
1586 exit(1);
1589 if(lseek(fd, 6, SEEK_CUR) == (off_t)-1){
1590 perror("lseek");
1591 exit(1);
1594 if(read(fd, &cen_size, 2) != 2){
1595 perror("read");
1596 exit(1);
1599 #ifdef WORDS_BIGENDIAN
1600 cen_size = L2BS(cen_size);
1601 #endif
1603 /* printf("%hu entries in central header\n", cen_size); */
1605 if(lseek(fd, 4, SEEK_CUR) == (off_t)-1){
1606 perror("lseek");
1607 exit(1);
1610 if(read(fd, &tmp, 4) != 4){
1611 perror("read");
1612 exit(1);
1615 #ifdef WORDS_BIGENDIAN
1616 tmp = L2BI(tmp);
1617 #endif
1619 /* printf("Central header offset = %d\n", tmp); */
1621 if(lseek(fd, tmp, SEEK_SET) != (int)tmp){
1622 perror("lseek");
1623 exit(1);
1626 /* Loop through the entries in the central header */
1627 for(i = 0; i < cen_size; i++){
1629 if(read(fd, &cen_header, 46) != 46){
1630 perror("read");
1631 exit(1);
1634 signature = UNPACK_UB4(cen_header, 0);
1635 if(signature != 0x02014b50){
1636 fprintf(stderr, "Error in JAR file! Cannot locate central header!\n");
1637 exit(1);
1640 usize = UNPACK_UB4(cen_header, CEN_USIZE);
1641 fnlen = UNPACK_UB2(cen_header, CEN_FNLEN);
1642 eflen = UNPACK_UB2(cen_header, CEN_EFLEN);
1643 clen = UNPACK_UB2(cen_header, CEN_COMLEN);
1645 /* If we're providing verbose output, we need to make an ASCII
1646 * formatted version of the date. */
1647 if(verbose){
1648 mdate = UNPACK_UB4(cen_header, CEN_MODTIME);
1649 tdate = dos2unixtime(mdate);
1650 s_tm = localtime(&tdate);
1651 strftime(ascii_date, 30, "%a %b %d %H:%M:%S %Z %Y", s_tm);
1652 ascii_date[30] = '\0';
1655 if(filename_len < fnlen + 1){
1656 if(filename != NULL)
1657 free(filename);
1659 filename = malloc(sizeof(ub1) * (fnlen + 1));
1660 filename_len = fnlen + 1;
1663 if(read(fd, filename, fnlen) != fnlen){
1664 perror("read");
1665 exit(1);
1667 filename[fnlen] = '\0';
1669 /* if the user specified a list of files on the command line,
1670 we'll only display those, otherwise we'll display everything */
1671 if(file_num > 0){
1672 for(j = 0; j < file_num; j++)
1673 if(strcmp(files[j], (const char *)filename) == 0){
1674 if(verbose)
1675 printf("%6d %s %s\n", usize, ascii_date, filename);
1676 else
1677 printf("%s\n", filename);
1678 break;
1680 } else {
1681 if(verbose)
1682 printf("%6d %s %s\n", usize, ascii_date, filename);
1683 else
1684 printf("%s\n", filename);
1687 size = eflen + clen;
1688 if(size > 0){
1689 if(lseek(fd, size, SEEK_CUR) == (off_t)-1){
1690 perror("lseek");
1691 exit(1);
1695 } else {
1696 /* the file isn't seekable.. evil! */
1697 pb_file pbf;
1699 pb_init(&pbf, fd);
1701 init_inflation();
1703 for(;;){
1704 if(pb_read(&pbf, scratch, 4) != 4){
1705 perror("read");
1706 break;
1709 signature = UNPACK_UB4(scratch, 0);
1711 #ifdef DEBUG
1712 printf("signature is %x\n", signature);
1713 #endif
1715 if(signature == 0x08074b50){
1716 #ifdef DEBUG
1717 printf("skipping data descriptor\n");
1718 #endif
1719 pb_read(&pbf, scratch, 12);
1720 continue;
1721 } else if(signature == 0x02014b50){
1722 #ifdef DEBUG
1723 printf("Central header reached.. we're all done!\n");
1724 #endif
1725 break;
1726 }else if(signature != 0x04034b50){
1727 #ifdef DEBUG
1728 printf("Ick! %#x\n", signature);
1729 #endif
1730 break;
1733 if(pb_read(&pbf, (file_header + 4), 26) != 26){
1734 perror("read");
1735 break;
1738 csize = UNPACK_UB4(file_header, LOC_CSIZE);
1739 #ifdef DEBUG
1740 printf("Compressed size is %u\n", csize);
1741 #endif
1743 fnlen = UNPACK_UB2(file_header, LOC_FNLEN);
1744 #ifdef DEBUG
1745 printf("Filename length is %hu\n", fnlen);
1746 #endif
1748 eflen = UNPACK_UB2(file_header, LOC_EFLEN);
1749 #ifdef DEBUG
1750 printf("Extra field length is %hu\n", eflen);
1751 #endif
1753 method = UNPACK_UB2(file_header, LOC_COMP);
1754 #ifdef DEBUG
1755 printf("Compression method is %#hx\n", method);
1756 #endif
1758 flags = UNPACK_UB2(file_header, LOC_EXTRA);
1759 #ifdef DEBUG
1760 printf("Flags are %#hx\n", flags);
1761 #endif
1763 usize = UNPACK_UB4(file_header, LOC_USIZE);
1765 /* If we're providing verbose output, we need to make an ASCII
1766 * formatted version of the date. */
1767 if(verbose){
1768 mdate = UNPACK_UB4(file_header, LOC_MODTIME);
1769 tdate = dos2unixtime(mdate);
1770 s_tm = localtime(&tdate);
1771 strftime(ascii_date, 30, "%a %b %d %H:%M:%S %Z %Y", s_tm);
1774 if(filename_len < fnlen + 1){
1775 if(filename != NULL)
1776 free(filename);
1778 filename = malloc(sizeof(ub1) * (fnlen + 1));
1779 ascii_date[30] = '\0';
1780 filename_len = fnlen + 1;
1783 pb_read(&pbf, filename, fnlen);
1784 filename[fnlen] = '\0';
1786 /* the header is at the end. In a JAR file, this means that the data
1787 happens to be compressed. We have no choice but to inflate the
1788 data */
1789 if(flags & 0x0008){
1791 size = eflen;
1793 if(size > 0)
1794 consume(&pbf, size);
1796 if(method == 8){
1797 #ifdef DEBUG
1798 printf("inflating %s\n", filename);
1799 #endif
1800 inflate_file(&pbf, -1, &ze);
1802 usize = ze.usize;
1803 } else
1804 printf("We're shit outta luck!\n");
1806 } else {
1807 size = csize + (eflen > 0 ? eflen : 0);
1810 #ifdef DEBUG
1811 printf("Skipping %ld bytes\n", (long)size);
1812 #endif
1814 consume(&pbf, size);
1816 /* print out the listing */
1817 if(file_num > 0){
1818 for(j = 0; j < file_num; j++)
1819 if(strcmp(files[j], (const char *)filename) == 0){
1820 if(verbose)
1821 printf("%6d %s %s\n", usize, ascii_date, filename);
1822 else
1823 printf("%s\n", filename);
1824 break;
1826 } else {
1827 if(verbose)
1828 printf("%6d %s %s\n", usize, ascii_date, filename);
1829 else
1830 printf("%s\n", filename);
1834 return 0;
1837 int consume(pb_file *pbf, int amt){
1838 int tc = 0; /* total amount consumed */
1839 ub1 buff[RDSZ];
1840 int rdamt;
1842 #ifdef DEBUG
1843 printf("Consuming %d bytes\n", amt);
1844 #endif
1846 if (seekable){
1847 if (amt <= (int)pbf->buff_amt)
1848 pb_read(pbf, buff, amt);
1849 else {
1850 lseek(pbf->fd, amt - pbf->buff_amt, SEEK_CUR);
1851 pb_read(pbf, buff, pbf->buff_amt); /* clear pbf */
1853 } else
1854 while(tc < amt){
1855 rdamt = pb_read(pbf, buff, ((amt - tc) < RDSZ ? (amt - tc) : RDSZ));
1856 #ifdef DEBUG
1857 printf("got %d bytes\n", rdamt);
1858 #endif
1859 tc += rdamt;
1862 #ifdef DEBUG
1863 printf("%d bytes consumed\n", amt);
1864 #endif
1866 return 0;
1869 void usage(const char *filename){
1870 fprintf(stderr, "Try `%s --help' for more information.\n", filename);
1871 exit (1);
1874 void version ()
1876 printf("jar (%s) %s\n\n", PACKAGE, VERSION);
1877 printf("Copyright 1999, 2000, 2001 Bryan Burns\n");
1878 printf("Copyright 2002 Free Software Foundation\n");
1879 printf("\
1880 This is free software; see the source for copying conditions. There is NO\n\
1881 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
1882 exit (0);
1885 void help(const char *filename)
1887 printf("\
1888 Usage: %s {ctxuV}[vfm0ME@] [jar-file] [manifest-file] [-C dir] files ...\n\
1890 Store many files together in a single `jar' file.\n\
1892 -c create new archive\n\
1893 -t list table of contents for archive\n\
1894 -x extract named (or all) files from archive\n\
1895 -u update existing archive\n\
1896 ", filename);
1897 printf("\n\
1898 -@ read names from stdin\n\
1899 -0 store only; use no ZIP compression\n\
1900 -C DIR FILE change to the specified directory and include\n\
1901 the following file\n\
1902 -E don't include the files found in a directory\n\
1903 -f FILE specify archive file name\n\
1904 --help print this help, then exit\n\
1905 -m FILE include manifest information from specified manifest file\n\
1906 -M Do not create a manifest file for the entries\n\
1907 -v generate verbose output on standard output\n\
1908 -V, --version display version information\n\
1910 printf("\n\
1911 If any file is a directory then it is processed recursively.\n\
1912 The manifest file name and the archive file name needs to be specified\n\
1913 in the same order the 'm' and 'f' flags are specified.\n\
1915 Example 1: to archive two class files into an archive called classes.jar: \n\
1916 jar cvf classes.jar Foo.class Bar.class \n\
1917 Example 2: use an existing manifest file 'mymanifest' and archive all the\n\
1918 files in the foo/ directory into 'classes.jar': \n\
1919 jar cvfm classes.jar mymanifest -C foo/ .\n\
1922 exit(0);
1925 static char *
1926 jt_strdup(s)
1927 char *s;
1929 char *result = (char*)malloc(strlen(s) + 1);
1930 if (result == (char*)0)
1931 return (char*)0;
1932 strcpy(result, s);
1933 return result;
1936 /* Convert "tar-style" first argument to a form expected by getopt.
1937 This idea and the code comes from GNU tar. This can allocate a new
1938 argument vector. This might leak some memory, but we don't care. */
1939 static void
1940 expand_options (int *argcp, char ***argvp)
1942 int argc = *argcp;
1943 char **argv = *argvp;
1945 /* Accept arguments with a leading "-" (eg "-cvf"), but don't do expansion
1946 if a long argument (like "--help") is detected. */
1947 if (argc > 1 && argv[1][1] != '-')
1949 char buf[3];
1950 char **new_argv;
1951 int new_argc;
1952 int args_to_expand;
1953 char *p;
1954 char **in, **out;
1956 buf[0] = '-';
1957 buf[2] = '\0';
1959 args_to_expand = strlen (argv[1]);
1960 if (argv[1][0] == '-')
1961 --args_to_expand;
1963 new_argc = argc - 1 + args_to_expand;
1964 new_argv = (char **) malloc (new_argc * sizeof (char *));
1965 in = argv;
1966 out = new_argv;
1968 *out++ = *in++;
1969 p = *in++;
1970 if (*p == '-')
1971 p++;
1972 while (*p != '\0')
1974 char *opt;
1975 buf[1] = *p;
1976 *out++ = jt_strdup (buf);
1977 /* If the option takes an argument, move the next argument
1978 to just after this option. */
1979 opt = strchr (OPTION_STRING, *p);
1980 if (opt && opt[1] == ':')
1982 if (in < argv + argc)
1983 *out++ = *in++;
1984 else
1986 fprintf(stderr, "%s: option `%s' requires an argument.\n",
1987 argv[0], buf);
1988 usage(argv[0]);
1991 ++p;
1994 /* Copy remaining options. */
1995 while (in < argv + argc)
1996 *out++ = *in++;
1998 *argcp = new_argc;
1999 *argvp = new_argv;