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