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>
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
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.
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
73 * compress.c: Include stdlib.h and compress.h.
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.
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>
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
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
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
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
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
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
170 Revision 1.9 1999/04/21 09:55:16 burnsbr
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
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
188 Revision 1.3 1999/04/20 05:08:54 burnsbr
206 #include <sys/stat.h>
207 #include <sys/types.h>
209 #ifdef HAVE_SYS_PARAM_H
210 #include <sys/param.h>
214 #define MAXPATHLEN 1024
228 #ifdef TM_IN_SYS_TIME
229 #include <sys/time.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)
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);
267 void usage(const char*);
268 void help(const char *);
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 */
287 ub1 data_descriptor
[16];
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
){
326 int action
= ACTION_NONE
;
332 /* These are used to collect file names and `-C' options for the
333 second pass through the command line. */
342 number_of_entries
= 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) {
355 new_argv
[new_argc
++] = (char *) "-C";
356 /* ... fall through ... */
358 /* File name or unparsed option, due to RETURN_IN_ORDER. */
359 new_argv
[new_argc
++] = optarg
;
362 action
= ACTION_CREATE
;
365 action
= ACTION_LIST
;
368 action
= ACTION_EXTRACT
;
371 action
= ACTION_UPDATE
;
396 /* The following options aren't supported by the original jar tool. */
398 use_explicit_list_only
= TRUE
;
401 read_names_from_stdin
= TRUE
;
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");
419 if(action
== ACTION_UPDATE
){
420 fprintf(stderr
, "%s: `-u' mode unimplemented.\n", argv
[0]);
424 /* Verify unsupported combinations and warn of the use of non
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");
436 /* create the jarfile */
437 if(action
== ACTION_CREATE
){
439 jarfd
= open(jarfile
, O_CREAT
| O_BINARY
| O_WRONLY
| O_TRUNC
, 0666);
442 fprintf(stderr
, "Error opening %s for writing!\n", jarfile
);
447 /* We assume that the file is seekable */
452 jarfd
= STDOUT_FILENO
; /* jarfd is stdout otherwise */
454 /* standard out is not seekable */
457 /* don't want our output to be part of the jar file.. figured this one
458 out the hard way.. =P */
461 } else if(action
== ACTION_LIST
|| action
== ACTION_EXTRACT
){
464 jarfd
= open(jarfile
, O_RDONLY
| O_BINARY
);
467 fprintf(stderr
, "Error opening %s for reading!\n", jarfile
);
474 jarfd
= STDIN_FILENO
; /* jarfd is standard in */
476 /* we assume that the stream isn't seekable for safety */
481 if(action
== ACTION_CREATE
|| action
== ACTION_UPDATE
){
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
);
497 /* Add the META-INF/ directory and the manifest */
498 if(manifest
&& mfile
)
499 make_manifest(jarfd
, mfile
);
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
|| !file_to_add
) {
511 fprintf(stderr
, "Error: missing argument for -C.\n");
514 if (add_to_jar(jarfd
, dir_to_change
, file_to_add
)) {
516 "Error adding %s (in directory %s) to jar archive!\n",
517 file_to_add
, dir_to_change
);
521 if(add_to_jar(jarfd
, NULL
, arg
)){
522 fprintf(stderr
, "Error adding %s to jar archive!\n", arg
);
527 /* de-initialize the compression DS */
531 create_central_header(jarfd
);
533 if (close(jarfd
) != 0) {
534 fprintf(stderr
, "Error closing jar archive!\n");
536 } else if(action
== ACTION_LIST
){
537 list_jar(jarfd
, &new_argv
[0], new_argc
);
538 } else if(action
== ACTION_EXTRACT
){
539 extract_jar(jarfd
, &new_argv
[0], new_argc
);
545 static int args_current_g
;
546 static char **args_g
;
549 init_args(args
, current
)
553 if(!read_names_from_stdin
)
556 args_current_g
= current
;
563 static int reached_end
= 0;
570 if (!args_g
[args_current_g
])
575 return args_g
[args_current_g
++];
579 /* Read the name from stdin. Delimiters are '\n' and
580 '\r'. Reading EOF indicates that we don't have anymore file
581 names characters to read. */
586 /* Get rid of '\n' and '\r' first. */
589 int c
= getc (stdin
);
590 if (c
== '\n' || c
== '\r')
603 int c
= getc (stdin
);
604 /* Exit when we get a delimiter or don't have any characters
606 if (c
== '\n'|| c
== '\r'|| c
== EOF
)
608 s
[pos
++] = (char) c
;
614 return jt_strdup (s
);
622 /* packing file header */
624 file_header
[0] = 0x50;
625 file_header
[1] = 0x4b;
626 file_header
[2] = 0x03;
627 file_header
[3] = 0x04;
628 /* version number (Unix 1.0)*/
631 /* bit flag (normal deflation)*/
632 file_header
[6] = 0x00;
634 file_header
[7] = 0x00;
635 /* do_compression method (deflation) */
639 /* last mod file time (MS-DOS format) */
642 /* last mod file date (MS-DOS format) */
650 /* compressed size */
655 /* uncompressed size */
660 /* filename length */
663 /* extra field length */
667 /* Initialize the compression DS */
668 PACK_UB4(data_descriptor
, 0, 0x08074b50);
672 void add_entry(struct zipentry
*ze
){
678 ziplist
->next_entry
= ze
;
685 int make_manifest(int jfd
, const char *mf_name
){
687 int nlen
; /* length of file name */
688 int mod_time
; /* file modification time */
691 nlen
= 9; /* trust me on this one */
693 memset((file_header
+ 12), '\0', 16); /*clear mod time, crc, size fields*/
695 current_time
= time(NULL
);
696 if(current_time
== (time_t)-1){
701 mod_time
= unix2dostime(¤t_time
);
703 PACK_UB2(file_header
, LOC_EXTRA
, 0);
704 PACK_UB2(file_header
, LOC_COMP
, 0);
705 PACK_UB2(file_header
, LOC_FNLEN
, nlen
);
706 PACK_UB4(file_header
, LOC_MODTIME
, mod_time
);
709 printf("adding: META-INF/ (in=0) (out=0) (stored 0%%)\n");
711 ze
= (zipentry
*)malloc(sizeof(zipentry
));
717 memset(ze
, 0, sizeof(zipentry
)); /* clear all the fields*/
718 ze
->filename
= (char*)malloc((nlen
+ 1) * sizeof(char) + 1);
719 strcpy(ze
->filename
, "META-INF/");
720 ze
->filename
[nlen
] = '\0';
722 ze
->offset
= lseek(jfd
, 0, SEEK_CUR
);
723 ze
->mod_time
= (ub2
)(mod_time
& 0x0000ffff);
724 ze
->mod_date
= (ub2
)((mod_time
& 0xffff0000) >> 16);
725 ze
->compressed
= FALSE
;
729 write(jfd
, file_header
, 30);
730 write(jfd
, "META-INF/", nlen
);
732 /* if the user didn't specify an external manifest file... */
734 int mf_len
= 37 + strlen(VERSION
);
737 if((mf
= (char *) malloc(mf_len
+ 1))) {
740 sprintf(mf
, "Manifest-Version: 1.0\nCreated-By: %s\n\n", VERSION
);
742 crc
= crc32(0L, Z_NULL
, 0);
744 crc
= crc32(crc
, (const unsigned char *)mf
, mf_len
);
746 nlen
= 20; /* once again, trust me */
748 PACK_UB2(file_header
, LOC_EXTRA
, 0);
749 PACK_UB2(file_header
, LOC_COMP
, 0);
750 PACK_UB2(file_header
, LOC_FNLEN
, nlen
);
751 PACK_UB4(file_header
, LOC_USIZE
, mf_len
);
753 memcpy((file_header
+ LOC_CSIZE
), (file_header
+ LOC_USIZE
), 4);
755 PACK_UB4(file_header
, LOC_CRC
, crc
);
758 printf("adding: META-INF/MANIFEST.MF (in=56) (out=56) (stored 0%%)\n");
760 ze
= (zipentry
*)malloc(sizeof(zipentry
));
766 memset(ze
, 0, sizeof(zipentry
)); /* clear all the fields*/
767 ze
->filename
= (char*)malloc((nlen
+ 1) * sizeof(char) + 1);
768 strcpy(ze
->filename
, "META-INF/MANIFEST.MF");
769 ze
->filename
[nlen
] = '\0';
771 ze
->offset
= lseek(jfd
, 0, SEEK_CUR
);
772 ze
->mod_time
= (ub2
)(mod_time
& 0x0000ffff);
773 ze
->mod_date
= (ub2
)((mod_time
& 0xffff0000) >> 16);
776 ze
->usize
= ze
->csize
;
777 ze
->compressed
= FALSE
;
781 write(jfd
, file_header
, 30);
782 write(jfd
, "META-INF/MANIFEST.MF", nlen
);
783 write(jfd
, mf
, mf_len
);
787 printf("malloc errror\n");
794 stat(mf_name
, &statbuf
);
796 if(!S_ISREG(statbuf
.st_mode
)){
797 fprintf(stderr
, "Invalid manifest file specified.\n");
801 mfd
= open(mf_name
, O_RDONLY
| O_BINARY
);
804 fprintf(stderr
, "Error opening %s.\n", mf_name
);
808 if(add_file_to_jar(jfd
, mfd
, "META-INF/MANIFEST.MF", &statbuf
)){
809 perror("error writing to jar");
818 int add_to_jar(int fd
, const char *new_dir
, const char *file
){
824 char old_dir
[MAXPATHLEN
];
826 /* This is a quick compatibility fix -- Simon Weijgers <simon@weijgers.com>
828 * "normal" jar : org/apache/java/io/LogRecord.class
829 * fastjar : ./org/apache/java/io/LogRecord.class
830 * Fastjar's preservation of the ./'s makes the jarfile unusuable for use
831 * with both kaffe-1.0b4 and JDK.
833 while (*file
=='.' && *(file
+1)=='/')
836 /* If new_dir isn't null, we need to change to that directory. However,
837 we also need to return to the old directory when we're done. See below.*/
839 if (getcwd(old_dir
, MAXPATHLEN
) == NULL
) {
843 if(chdir(new_dir
) == -1){
849 if(jarfile
&& !strcmp(file
, jarfile
)){
851 printf("skipping: %s\n", file
);
852 return 0; /* we don't want to add ourselves.. */
855 stat_return
= stat(file
, &statbuf
);
857 if(stat_return
== -1){
860 } else if(S_ISDIR(statbuf
.st_mode
)){
864 unsigned long mod_time
;
873 nlen
= strlen(file
) + 256;
874 fullname
= (char*)malloc(nlen
* sizeof(char));
875 memset(fullname
, 0, (nlen
* sizeof(char)));
877 if(fullname
== NULL
){
878 fprintf(stderr
, "Filename is NULL!\n");
882 strcpy(fullname
, file
);
885 if(fullname
[nlen
- 1] != '/'){
886 fullname
[nlen
] = '/';
887 t_ptr
= (fullname
+ nlen
+ 1);
889 t_ptr
= (fullname
+ nlen
);
892 memset((file_header
+ 12), '\0', 16); /*clear mod time, crc, size fields*/
894 nlen
= (t_ptr
- fullname
);
896 mod_time
= unix2dostime(&statbuf
.st_mtime
);
898 PACK_UB2(file_header
, LOC_EXTRA
, 0);
899 PACK_UB2(file_header
, LOC_COMP
, 0);
900 PACK_UB2(file_header
, LOC_FNLEN
, nlen
);
901 PACK_UB4(file_header
, LOC_MODTIME
, mod_time
);
904 printf("adding: %s (in=%d) (out=%d) (stored 0%%)\n", fullname
, 0, 0);
906 ze
= (zipentry
*)malloc(sizeof(zipentry
));
912 memset(ze
, 0, sizeof(zipentry
)); /* clear all the fields*/
913 ze
->filename
= (char*)malloc((nlen
+ 1) * sizeof(char) + 1);
914 strcpy(ze
->filename
, fullname
);
915 ze
->filename
[nlen
] = '\0';
917 ze
->offset
= lseek(fd
, 0, SEEK_CUR
);
918 ze
->mod_time
= (ub2
)(mod_time
& 0x0000ffff);
919 ze
->mod_date
= (ub2
)((mod_time
& 0xffff0000) >> 16);
920 ze
->compressed
= FALSE
;
924 write(fd
, file_header
, 30);
925 write(fd
, fullname
, nlen
);
927 while(!use_explicit_list_only
&& (de
= readdir(dir
)) != NULL
){
928 if(de
->d_name
[0] == '.')
930 if(jarfile
&& !strcmp(de
->d_name
, jarfile
)){
931 /* we don't want to add ourselves. Believe me */
933 printf("skipping: %s\n", de
->d_name
);
937 strcpy(t_ptr
, de
->d_name
);
939 if(add_to_jar(fd
, NULL
, fullname
)){
940 fprintf(stderr
, "Error adding file to jar!\n");
948 } else if(S_ISREG(statbuf
.st_mode
)){
951 add_fd
= open(file
, O_RDONLY
| O_BINARY
);
953 fprintf(stderr
, "Error opening %s.\n", file
);
957 if(add_file_to_jar(fd
, add_fd
, file
, &statbuf
)){
958 fprintf(stderr
, "Error adding file to jar!\n");
963 fprintf(stderr
, "Illegal file specified: %s\n", file
);
966 /* If (and only if!) new_dir != NULL, we switched directories, so
967 we have to switch back to the old directory. */
968 if (new_dir
!= NULL
) {
969 if (chdir(old_dir
) == -1) {
978 int add_file_to_jar(int jfd
, int ffd
, const char *fname
, struct stat
*statbuf
){
980 unsigned short file_name_length
;
981 unsigned long mod_time
;
988 mod_time
= unix2dostime(&(statbuf
->st_mtime
));
989 file_name_length
= strlen(fname
);
991 if(!seekable
&& !do_compress
){
992 crc
= crc32(0L, Z_NULL
, 0);
994 while((rdamt
= read(ffd
, rd_buff
, RDSZ
)) != 0)
995 crc
= crc32(crc
, rd_buff
, rdamt
);
997 lseek(ffd
, 0, SEEK_SET
);
1000 /* data descriptor */
1001 if(!seekable
&& do_compress
){
1002 PACK_UB2(file_header
, LOC_EXTRA
, 8);
1004 PACK_UB2(file_header
, LOC_EXTRA
, 0);
1008 PACK_UB2(file_header
, LOC_COMP
, 8);
1010 PACK_UB2(file_header
, LOC_COMP
, 0);
1013 PACK_UB4(file_header
, LOC_MODTIME
, mod_time
);
1014 PACK_UB2(file_header
, LOC_FNLEN
, file_name_length
);
1016 if(!seekable
&& !do_compress
){
1017 PACK_UB4(file_header
, LOC_CRC
, crc
);
1018 PACK_UB4(file_header
, LOC_USIZE
, statbuf
->st_size
);
1019 PACK_UB4(file_header
, LOC_CSIZE
, statbuf
->st_size
);
1021 memset((file_header
+ LOC_CRC
), '\0', 12); /* clear crc/usize/csize */
1023 ze
= (zipentry
*)malloc(sizeof(zipentry
));
1029 memset(ze
, 0, sizeof(zipentry
)); /* clear all the fields*/
1030 ze
->filename
= (char*)malloc((file_name_length
+ 1) * sizeof(char));
1031 strcpy(ze
->filename
, fname
);
1033 ze
->mod_time
= (ub2
)(mod_time
& 0x0000ffff);
1034 ze
->mod_date
= (ub2
)((mod_time
& 0xffff0000) >> 16);
1036 if(!seekable
&& !do_compress
)
1039 ze
->csize
= statbuf
->st_size
;
1040 ze
->usize
= ze
->csize
;
1041 ze
->offset
= lseek(jfd
, 0, SEEK_CUR
);
1043 ze
->compressed
= TRUE
;
1045 ze
->compressed
= FALSE
;
1049 /* Write the local header */
1050 write(jfd
, file_header
, 30);
1052 /* write the file name to the zip file */
1053 write(jfd
, fname
, file_name_length
);
1057 printf("adding: %s ", fname
);
1062 /* compress the file */
1063 compress_file(ffd
, jfd
, ze
);
1065 /* Write the contents of the file (uncompressed) to the zip file */
1066 /* calculate the CRC as we go along */
1067 ze
->crc
= crc32(0L, Z_NULL
, 0);
1069 while((rdamt
= read(ffd
, rd_buff
, RDSZ
)) != 0){
1070 ze
->crc
= crc32(ze
->crc
, rd_buff
, rdamt
);
1071 if(write(jfd
, rd_buff
, rdamt
) != rdamt
){
1079 /* write out data descriptor */
1080 PACK_UB4(data_descriptor
, 4, ze
->crc
);
1081 PACK_UB4(data_descriptor
, 8, ze
->csize
);
1082 PACK_UB4(data_descriptor
, 12, ze
->usize
);
1084 /* we need to seek back and fill the header */
1086 offset
= (ze
->csize
+ strlen(ze
->filename
) + 16);
1088 if(lseek(jfd
, -offset
, SEEK_CUR
) == (off_t
)-1){
1093 if(write(jfd
, (data_descriptor
+ 4), 12) != 12){
1100 if(lseek(jfd
, offset
, SEEK_CUR
) == (off_t
)-1){
1104 } else if(do_compress
){
1105 /* Sun's jar tool will only allow a data descriptor if the entry is
1106 compressed, but we'll save 16 bytes/entry if we only use it when
1107 we can't seek back on the file */
1109 if(write(jfd
, data_descriptor
, 16) != 16){
1116 printf("(in=%d) (out=%d) (%s %d%%)\n",
1117 (int)ze
->usize
, (int)ze
->csize
,
1118 (do_compress
? "deflated" : "stored"),
1119 (do_compress
? ((int)((1 - ze
->csize
/(float)ze
->usize
) * 100)) : 0));
1124 int create_central_header(int fd
){
1129 int total_in
= 0, total_out
= 22;
1138 /* version made by */
1141 /* version needed to extract */
1147 /* compression method */
1161 /* compressed size */
1166 /* uncompressed size */
1171 /* filename length */
1174 /* extra field length */
1177 /* file comment length */
1180 /* disk number start */
1183 /* internal file attribs */
1186 /* external file attribs */
1191 /* relative offset of local header */
1197 start_offset
= lseek(fd
, 0, SEEK_CUR
);
1199 for(ze
= ziptail
; ze
!= NULL
; ze
= ze
->next_entry
){
1201 total_in
+= ze
->usize
;
1202 total_out
+= ze
->csize
+ 76 + strlen(ze
->filename
) * 2;
1205 PACK_UB2(header
, CEN_COMP
, 8);
1207 PACK_UB2(header
, CEN_COMP
, 0);
1210 PACK_UB2(header
, CEN_MODTIME
, ze
->mod_time
);
1211 PACK_UB2(header
, CEN_MODDATE
, ze
->mod_date
);
1212 PACK_UB4(header
, CEN_CRC
, ze
->crc
);
1213 PACK_UB4(header
, CEN_CSIZE
, ze
->csize
);
1214 PACK_UB4(header
, CEN_USIZE
, ze
->usize
);
1215 PACK_UB2(header
, CEN_FNLEN
, strlen(ze
->filename
));
1216 PACK_UB4(header
, CEN_OFFSET
, ze
->offset
);
1218 write(fd
, header
, 46);
1220 write(fd
, ze
->filename
, strlen(ze
->filename
));
1223 dir_size
= lseek(fd
, 0, SEEK_CUR
) - start_offset
;
1226 end_header
[0] = 0x50;
1227 end_header
[1] = 0x4b;
1228 end_header
[2] = 0x05;
1229 end_header
[3] = 0x06;
1230 /* number of this disk */
1233 /* number of disk w/ start of central header */
1236 /* total number of entries in central dir on this disk*/
1237 PACK_UB2(end_header
, 8, number_of_entries
);
1238 /* total number of entries in central dir*/
1239 PACK_UB2(end_header
, 10, number_of_entries
);
1240 /* size of central dir. */
1241 PACK_UB4(end_header
, 12, dir_size
);
1242 /* offset of start of central dir */
1243 PACK_UB4(end_header
, 16, start_offset
);
1244 /* zipfile comment length */
1248 write(fd
, end_header
, 22);
1251 printf("Total:\n------\n(in = %d) (out = %d) (%s %d%%)\n",
1254 (do_compress
? "deflated" : "stored"),
1255 (int)((1 - (total_out
/ (float)total_in
)) * 100)
1261 int extract_jar(int fd
, char **files
, int file_num
){
1271 ub1
*filename
= NULL
;
1272 int filename_len
= 0;
1291 dir
= FALSE
; /* by default, the file isn't a dir */
1292 handle
= TRUE
; /* by default we'll extract/create the file */
1294 if((rdamt
= pb_read(&pbf
, scratch
, 4)) != 4){
1299 signature
= UNPACK_UB4(scratch
, 0);
1302 printf("signature is %x\n", signature
);
1304 if(signature
== 0x08074b50){
1306 printf("skipping data descriptor\n");
1308 pb_read(&pbf
, scratch
, 12);
1310 } else if(signature
== 0x02014b50){
1312 printf("Central header reached.. we're all done!\n");
1315 }else if(signature
!= 0x04034b50){
1316 printf("Ick! %#x\n", signature
);
1320 if((rdamt
= pb_read(&pbf
, (file_header
+ 4), 26)) != 26){
1325 csize
= UNPACK_UB4(file_header
, LOC_CSIZE
);
1327 printf("Compressed size is %u\n", csize
);
1330 fnlen
= UNPACK_UB2(file_header
, LOC_FNLEN
);
1332 printf("Filename length is %hu\n", fnlen
);
1335 eflen
= UNPACK_UB2(file_header
, LOC_EFLEN
);
1337 printf("Extra field length is %hu\n", eflen
);
1340 flags
= UNPACK_UB2(file_header
, LOC_EXTRA
);
1342 printf("Flags are %#hx\n", flags
);
1345 method
= UNPACK_UB2(file_header
, LOC_COMP
);
1347 printf("Compression method is %#hx\n", method
);
1350 /* if there isn't a data descriptor */
1351 if(!(flags
& 0x0008)){
1352 crc
= UNPACK_UB4(file_header
, LOC_CRC
);
1354 printf("CRC is %x\n", crc
);
1358 if(filename_len
< fnlen
+ 1){
1359 if(filename
!= NULL
)
1362 filename
= malloc(sizeof(ub1
) * (fnlen
+ 1));
1363 filename_len
= fnlen
+ 1;
1366 pb_read(&pbf
, filename
, fnlen
);
1367 filename
[fnlen
] = '\0';
1370 printf("filename is %s\n", filename
);
1376 for(j
= 0; j
< file_num
; j
++)
1377 if(strcmp(files
[j
], (const char *)filename
) == 0){
1386 /* OK, there is some directory information in the file. Nothing to do
1387 but ensure the directory(s) exist, and create them if they don't.
1389 if(strchr((const char *)filename
, '/') != NULL
&& handle
){
1390 /* Loop through all the directories in the path, (everything w/ a '/') */
1391 const ub1
*start
= filename
;
1395 tmp_buff
= malloc(sizeof(char) * strlen((const char *)filename
));
1398 const ub1
*idx
= (const unsigned char *)strchr((const char *)start
, '/');
1402 else if(idx
== start
){
1408 strncpy(tmp_buff
, (const char *)filename
, (idx
- filename
));
1409 tmp_buff
[(idx
- filename
)] = '\0';
1412 printf("checking the existance of %s\n", tmp_buff
);
1415 if(stat(tmp_buff
, &sbuf
) < 0){
1416 if(errno
!= ENOENT
){
1421 } else if(S_ISDIR(sbuf
.st_mode
)){
1423 printf("Directory exists\n");
1427 fprintf(stderr
, "Hmmm.. %s exists but isn't a directory!\n",
1433 printf("Making directory..\n");
1435 if(mkdir(tmp_buff
, 0755) < 0){
1439 if(verbose
&& handle
)
1440 printf("%10s: %s/\n", "created", tmp_buff
);
1444 /* only a directory */
1445 if(strlen((const char *)start
) == 0)
1449 printf("Leftovers are \"%s\" (%d)\n", start
, strlen((const char *)start
));
1452 /* If the entry was just a directory, don't write to file, etc */
1453 if(strlen((const char *)start
) == 0)
1459 if(f_fd
!= -1 && handle
){
1460 f_fd
= open((const char *)filename
,
1461 O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, 0644);
1464 fprintf(stderr
, "Error extracting JAR archive!\n");
1465 perror((const char *)filename
);
1470 if(method
!= 8 && flags
& 0x0008){
1471 fprintf(stderr
, "Error in JAR file! (not compressed but data desc.)\n");
1475 if(method
== 8 || flags
& 0x0008){
1476 consume(&pbf
, eflen
);
1478 inflate_file(&pbf
, f_fd
, &ze
);
1482 printf("writing stored data.. (%d bytes)\n", csize
);
1488 ze
.crc
= crc32(ze
.crc
, NULL
, 0); /* initialize the crc */
1490 while(out_a
< (int)csize
){
1491 rdamt
= (in_a
> RDSZ
? RDSZ
: in_a
);
1492 if(pb_read(&pbf
, rd_buff
, rdamt
) != rdamt
){
1497 ze
.crc
= crc32(ze
.crc
, (Bytef
*)rd_buff
, rdamt
);
1500 write(f_fd
, rd_buff
, rdamt
);
1506 printf("%d bytes written\n", out_a
);
1510 consume(&pbf
, eflen
);
1513 /* if there is a data descriptor left, compare the CRC */
1516 if(pb_read(&pbf
, scratch
, 16) != 16){
1521 signature
= UNPACK_UB4(scratch
, 0);
1523 if(signature
!= 0x08074b50){
1524 fprintf(stderr
, "Error! Missing data descriptor!\n");
1528 crc
= UNPACK_UB4(scratch
, 4);
1533 fprintf(stderr
, "Error! CRCs do not match! Got %x, expected %x\n",
1540 if(verbose
&& dir
== FALSE
&& handle
)
1541 printf("%10s: %s\n",
1542 (method
== 8 ? "inflated" : "extracted"),
1549 int list_jar(int fd
, char **files
, int file_num
){
1561 ub1
*filename
= NULL
;
1564 int filename_len
= 0;
1569 char ascii_date
[31];
1573 printf("Listing jar file, looking for %d files\n", file_num
);
1576 /* This should be the start of the central-header-end section */
1578 if(lseek(fd
, -22, SEEK_END
) == (off_t
)-1){
1583 if(read(fd
, &tmp
, sizeof(ub4
)) != 4){
1588 #ifdef WORDS_BIGENDIAN
1592 if(tmp
!= 0x06054b50){
1593 fprintf(stderr
, "Error in JAR file format. zip-style comment?\n");
1597 if(lseek(fd
, 6, SEEK_CUR
) == (off_t
)-1){
1602 if(read(fd
, &cen_size
, 2) != 2){
1607 #ifdef WORDS_BIGENDIAN
1608 cen_size
= L2BS(cen_size
);
1611 /* printf("%hu entries in central header\n", cen_size); */
1613 if(lseek(fd
, 4, SEEK_CUR
) == (off_t
)-1){
1618 if(read(fd
, &tmp
, 4) != 4){
1623 #ifdef WORDS_BIGENDIAN
1627 /* printf("Central header offset = %d\n", tmp); */
1629 if(lseek(fd
, tmp
, SEEK_SET
) != (int)tmp
){
1634 /* Loop through the entries in the central header */
1635 for(i
= 0; i
< cen_size
; i
++){
1637 if(read(fd
, &cen_header
, 46) != 46){
1642 signature
= UNPACK_UB4(cen_header
, 0);
1643 if(signature
!= 0x02014b50){
1644 fprintf(stderr
, "Error in JAR file! Cannot locate central header!\n");
1648 usize
= UNPACK_UB4(cen_header
, CEN_USIZE
);
1649 fnlen
= UNPACK_UB2(cen_header
, CEN_FNLEN
);
1650 eflen
= UNPACK_UB2(cen_header
, CEN_EFLEN
);
1651 clen
= UNPACK_UB2(cen_header
, CEN_COMLEN
);
1653 /* If we're providing verbose output, we need to make an ASCII
1654 * formatted version of the date. */
1656 mdate
= UNPACK_UB4(cen_header
, CEN_MODTIME
);
1657 tdate
= dos2unixtime(mdate
);
1658 s_tm
= localtime(&tdate
);
1659 strftime(ascii_date
, 30, "%a %b %d %H:%M:%S %Z %Y", s_tm
);
1660 ascii_date
[30] = '\0';
1663 if(filename_len
< fnlen
+ 1){
1664 if(filename
!= NULL
)
1667 filename
= malloc(sizeof(ub1
) * (fnlen
+ 1));
1668 filename_len
= fnlen
+ 1;
1671 if(read(fd
, filename
, fnlen
) != fnlen
){
1675 filename
[fnlen
] = '\0';
1677 /* if the user specified a list of files on the command line,
1678 we'll only display those, otherwise we'll display everything */
1680 for(j
= 0; j
< file_num
; j
++)
1681 if(strcmp(files
[j
], (const char *)filename
) == 0){
1683 printf("%6d %s %s\n", usize
, ascii_date
, filename
);
1685 printf("%s\n", filename
);
1690 printf("%6d %s %s\n", usize
, ascii_date
, filename
);
1692 printf("%s\n", filename
);
1695 size
= eflen
+ clen
;
1697 if(lseek(fd
, size
, SEEK_CUR
) == (off_t
)-1){
1704 /* the file isn't seekable.. evil! */
1712 if(pb_read(&pbf
, scratch
, 4) != 4){
1717 signature
= UNPACK_UB4(scratch
, 0);
1720 printf("signature is %x\n", signature
);
1723 if(signature
== 0x08074b50){
1725 printf("skipping data descriptor\n");
1727 pb_read(&pbf
, scratch
, 12);
1729 } else if(signature
== 0x02014b50){
1731 printf("Central header reached.. we're all done!\n");
1734 }else if(signature
!= 0x04034b50){
1736 printf("Ick! %#x\n", signature
);
1741 if(pb_read(&pbf
, (file_header
+ 4), 26) != 26){
1746 csize
= UNPACK_UB4(file_header
, LOC_CSIZE
);
1748 printf("Compressed size is %u\n", csize
);
1751 fnlen
= UNPACK_UB2(file_header
, LOC_FNLEN
);
1753 printf("Filename length is %hu\n", fnlen
);
1756 eflen
= UNPACK_UB2(file_header
, LOC_EFLEN
);
1758 printf("Extra field length is %hu\n", eflen
);
1761 method
= UNPACK_UB2(file_header
, LOC_COMP
);
1763 printf("Compression method is %#hx\n", method
);
1766 flags
= UNPACK_UB2(file_header
, LOC_EXTRA
);
1768 printf("Flags are %#hx\n", flags
);
1771 usize
= UNPACK_UB4(file_header
, LOC_USIZE
);
1773 /* If we're providing verbose output, we need to make an ASCII
1774 * formatted version of the date. */
1776 mdate
= UNPACK_UB4(file_header
, LOC_MODTIME
);
1777 tdate
= dos2unixtime(mdate
);
1778 s_tm
= localtime(&tdate
);
1779 strftime(ascii_date
, 30, "%a %b %d %H:%M:%S %Z %Y", s_tm
);
1782 if(filename_len
< fnlen
+ 1){
1783 if(filename
!= NULL
)
1786 filename
= malloc(sizeof(ub1
) * (fnlen
+ 1));
1787 ascii_date
[30] = '\0';
1788 filename_len
= fnlen
+ 1;
1791 pb_read(&pbf
, filename
, fnlen
);
1792 filename
[fnlen
] = '\0';
1794 /* the header is at the end. In a JAR file, this means that the data
1795 happens to be compressed. We have no choice but to inflate the
1802 consume(&pbf
, size
);
1806 printf("inflating %s\n", filename
);
1808 inflate_file(&pbf
, -1, &ze
);
1812 printf("We're shit outta luck!\n");
1815 size
= csize
+ (eflen
> 0 ? eflen
: 0);
1819 printf("Skipping %ld bytes\n", (long)size
);
1822 consume(&pbf
, size
);
1824 /* print out the listing */
1826 for(j
= 0; j
< file_num
; j
++)
1827 if(strcmp(files
[j
], (const char *)filename
) == 0){
1829 printf("%6d %s %s\n", usize
, ascii_date
, filename
);
1831 printf("%s\n", filename
);
1836 printf("%6d %s %s\n", usize
, ascii_date
, filename
);
1838 printf("%s\n", filename
);
1845 int consume(pb_file
*pbf
, int amt
){
1846 int tc
= 0; /* total amount consumed */
1851 printf("Consuming %d bytes\n", amt
);
1855 if (amt
<= (int)pbf
->buff_amt
)
1856 pb_read(pbf
, buff
, amt
);
1858 lseek(pbf
->fd
, amt
- pbf
->buff_amt
, SEEK_CUR
);
1859 pb_read(pbf
, buff
, pbf
->buff_amt
); /* clear pbf */
1863 rdamt
= pb_read(pbf
, buff
, ((amt
- tc
) < RDSZ
? (amt
- tc
) : RDSZ
));
1865 printf("got %d bytes\n", rdamt
);
1871 printf("%d bytes consumed\n", amt
);
1877 void usage(const char *filename
){
1878 fprintf(stderr
, "Try `%s --help' for more information.\n", filename
);
1884 printf("jar (%s) %s\n\n", PACKAGE
, VERSION
);
1885 printf("Copyright 1999, 2000, 2001 Bryan Burns\n");
1886 printf("Copyright 2002 Free Software Foundation\n");
1888 This is free software; see the source for copying conditions. There is NO\n\
1889 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
1893 void help(const char *filename
)
1896 Usage: %s {ctxuV}[vfm0ME@] [jar-file] [manifest-file] [-C dir] files ...\n\
1898 Store many files together in a single `jar' file.\n\
1900 -c create new archive\n\
1901 -t list table of contents for archive\n\
1902 -x extract named (or all) files from archive\n\
1903 -u update existing archive\n\
1906 -@ read names from stdin\n\
1907 -0 store only; use no ZIP compression\n\
1908 -C DIR FILE change to the specified directory and include\n\
1909 the following file\n\
1910 -E don't include the files found in a directory\n\
1911 -f FILE specify archive file name\n\
1912 --help print this help, then exit\n\
1913 -m FILE include manifest information from specified manifest file\n\
1914 -M Do not create a manifest file for the entries\n\
1915 -v generate verbose output on standard output\n\
1916 -V, --version display version information\n\
1919 If any file is a directory then it is processed recursively.\n\
1920 The manifest file name and the archive file name needs to be specified\n\
1921 in the same order the 'm' and 'f' flags are specified.\n\
1923 Example 1: to archive two class files into an archive called classes.jar: \n\
1924 jar cvf classes.jar Foo.class Bar.class \n\
1925 Example 2: use an existing manifest file 'mymanifest' and archive all the\n\
1926 files in the foo/ directory into 'classes.jar': \n\
1927 jar cvfm classes.jar mymanifest -C foo/ .\n\
1937 char *result
= (char*)malloc(strlen(s
) + 1);
1938 if (result
== (char*)0)
1944 /* Convert "tar-style" first argument to a form expected by getopt.
1945 This idea and the code comes from GNU tar. This can allocate a new
1946 argument vector. This might leak some memory, but we don't care. */
1948 expand_options (int *argcp
, char ***argvp
)
1951 char **argv
= *argvp
;
1953 /* Accept arguments with a leading "-" (eg "-cvf"), but don't do expansion
1954 if a long argument (like "--help") is detected. */
1955 if (argc
> 1 && argv
[1][1] != '-')
1967 args_to_expand
= strlen (argv
[1]);
1968 if (argv
[1][0] == '-')
1971 new_argc
= argc
- 1 + args_to_expand
;
1972 new_argv
= (char **) malloc (new_argc
* sizeof (char *));
1984 *out
++ = jt_strdup (buf
);
1985 /* If the option takes an argument, move the next argument
1986 to just after this option. */
1987 opt
= strchr (OPTION_STRING
, *p
);
1988 if (opt
&& opt
[1] == ':')
1990 if (in
< argv
+ argc
)
1994 fprintf(stderr
, "%s: option `%s' requires an argument.\n",
2002 /* Copy remaining options. */
2003 while (in
< argv
+ argc
)