![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pax.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin / pax / shipping|
Return to pax.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / pax / shipping |
1.1 root 1: /* $Source: /newbits/usr/bin/pax/shipping/RCS/pax.c,v $
2: *
3: * $Revision: 1.2 $
4: *
5: * DESCRIPTION
6: *
7: * Pax is the archiver described in IEEE P1003.2. It is an archiver
8: * which understands both tar and cpio archives and has a new interface.
9: *
10: * SYNOPSIS
11: *
12: * pax -[cimopuvy] [-f archive] [-s replstr] [-t device] [pattern...]
13: * pax -r [-cimopuvy] [-f archive] [-s replstr] [-t device] [pattern...]
14: * pax -w [-adimuvy] [-b blocking] [-f archive] [-s replstr]...]
15: * [-t device][-x format][pathname...]
16: * pax -r -w [-ilmopuvy][-s replstr][pathname...] directory
17: *
18: * DESCRIPTION
19: *
20: * PAX - POSIX conforming tar and cpio archive handler. This
21: * program implements POSIX conformant versions of tar, cpio and pax
22: * archive handlers for UNIX. These handlers have defined befined
23: * by the IEEE P1003.2 commitee.
24: *
25: * COMPILATION
26: *
27: * A number of different compile time configuration options are
28: * available, please see the Makefile and config.h for more details.
29: *
30: * AUTHOR
31: *
32: * Mark H. Colburn, NAPS International ([email protected])
33: *
34: *
35: * Sponsored by The USENIX Association for public distribution.
36: *
37: * Copyright (c) 1989 Mark H. Colburn.
38: * All rights reserved.
39: *
40: * Redistribution and use in source and binary forms are permitted
41: * provided that the above copyright notice is duplicated in all such
42: * forms and that any documentation, advertising materials, and other
43: * materials related to such distribution and use acknowledge that the
44: * software was developed * by Mark H. Colburn and sponsored by The
45: * USENIX Association.
46: *
47: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
48: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
49: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
50: *
51: * $Log: pax.c,v $
52: * Revision 1.2 92/06/11 07:51:11 bin
53: * vlad: added recognition of ustar AND tar
54: *
55: * Revision 1.1 91/02/05 11:58:29 bin
56: * Initial revision
57: *
58: * Revision 1.2 89/02/12 10:05:17 mark
59: * 1.2 release fixes
60: *
61: * Revision 1.1 88/12/23 18:02:23 mark
62: * Initial revision
63: *
64: */
65:
66: #ifndef lint
67: static char *ident = "$Id: pax.c,v 1.2 92/06/11 07:51:11 bin Exp Locker: bin $";
68: static char *copyright = "Copyright (c) 1989 Mark H. Colburn.\nAll rights reserved.\n";
69: #endif /* ! lint */
70:
71:
72: /* Headers */
73:
74: #define NO_EXTERN
75: #include "pax.h"
76:
77:
78: /* Globally Available Identifiers */
79:
80: char *ar_file; /* File containing name of archive */
81: char *bufend; /* End of data within archive buffer */
82: char *bufstart; /* Archive buffer */
83: char *bufidx; /* Archive buffer index */
84: char *myname; /* name of executable (argv[0]) */
85: char **n_argv; /* Argv used by name routines */
86: int n_argc; /* Argc used by name routines */
87: int archivefd; /* Archive file descriptor */
88: int blocking; /* Size of each block, in records */
89: int gid; /* Group ID */
90: int head_standard; /* true if archive is POSIX format */
91: int ar_interface; /* defines interface we are using */
92: int ar_format; /* defines current archve format */
93: int mask; /* File creation mask */
94: int ttyf; /* For interactive queries */
95: int uid; /* User ID */
96: int names_from_stdin; /* names for files are from stdin */
97: OFFSET total; /* Total number of bytes transferred */
98: short f_access_time; /* Reset access times of input files */
99: short areof; /* End of input volume reached */
100: short f_dir_create; /* Create missing directories */
101: short f_append; /* Add named files to end of archive */
102: short f_create; /* create a new archive */
103: short f_extract; /* Extract named files from archive */
104: short f_follow_links; /* follow symbolic links */
105: short f_interactive; /* Interactivly extract files */
106: short f_linksleft; /* Report on unresolved links */
107: short f_list; /* List files on the archive */
108: short f_modified; /* Don't restore modification times */
109: short f_verbose; /* Turn on verbose mode */
110: short f_link; /* link files where possible */
111: short f_owner; /* extract files as the user */
112: short f_pass; /* pass files between directories */
113: short f_disposition; /* ask for file disposition */
114: short f_reverse_match; /* Reverse sense of pattern match */
115: short f_mtime; /* Retain file modification time */
116: short f_unconditional; /* Copy unconditionally */
117: time_t now = 0; /* Current time */
118: uint arvolume; /* Volume number */
119: uint blocksize = BLOCKSIZE; /* Archive block size */
120: FILE *msgfile; /* message outpu file stdout/stderr */
121: Replstr *rplhead = (Replstr *)NULL; /* head of replstr list */
122: Replstr *rpltail; /* pointer to tail of replstr list */
123:
124:
125: /* Function Prototypes */
126:
127: #if __STDC__
128:
129: static void usage(void);
130: static OFFSET pax_optsize(char *);
131:
132: #else /* !__STDC__ */
133:
134: static void usage();
135: static OFFSET pax_optsize();
136:
137: #endif /* __STDC__ */
138:
139:
140: /* main - main routine for handling all archive formats.
141: *
142: * DESCRIPTION
143: *
144: * Set up globals and call the proper interface as specified by the user.
145: *
146: * PARAMETERS
147: *
148: * int argc - count of user supplied arguments
149: * char **argv - user supplied arguments
150: *
151: * RETURNS
152: *
153: * Returns an exit code of 0 to the parent process.
154: */
155:
156: #if __STDC__
157:
158: int main(int argc, char **argv)
159:
160: #else
161:
162: int main(argc, argv)
163: int argc;
164: char **argv;
165:
166: #endif
167: {
168: /* strip the pathname off of the name of the executable */
169: if ((myname = strrchr(argv[0], '/')) != (char *)NULL) {
170: myname++;
171: } else {
172: myname = argv[0];
173: }
174:
175: /* set upt for collecting other command line arguments */
176: name_init(argc, argv);
177:
178: /* get all our necessary information */
179: mask = umask(0);
180: uid = getuid();
181: gid = getgid();
182: now = time((time_t *) 0);
183:
184: /* open terminal for interactive queries */
185: ttyf = open_tty();
186:
187: if (strcmp(myname, "ustar")==0 || strcmp(myname, "tar")==0) {
188: do_tar(argc, argv);
189: } else if (strcmp(myname, "cpio")==0) {
190: do_cpio(argc, argv);
191: } else {
192: do_pax(argc, argv);
193: }
194: exit(0);
195: /* NOTREACHED */
196: }
197:
198:
199: /* do_pax - provide a PAX conformant user interface for archive handling
200: *
201: * DESCRIPTION
202: *
203: * Process the command line parameters given, doing some minimal sanity
204: * checking, and then launch the specified archiving functions.
205: *
206: * PARAMETERS
207: *
208: * int ac - A count of arguments in av. Should be passed argc
209: * from main
210: * char **av - A pointer to an argument list. Should be passed
211: * argv from main
212: *
213: * RETURNS
214: *
215: * Normally returns 0. If an error occurs, -1 is returned
216: * and state is set to reflect the error.
217: *
218: */
219:
220: #if __STDC__
221:
222: int do_pax(int ac, char **av)
223:
224: #else
225:
226: int do_pax(ac, av)
227: int ac; /* argument counter */
228: char **av; /* arguments */
229:
230: #endif
231: {
232: int c;
233: char *dirname;
234: Stat st;
235:
236: /* default input/output file for PAX is STDIN/STDOUT */
237: ar_file = "-";
238:
239: /*
240: * set up the flags to reflect the default pax inteface. Unfortunately
241: * the pax interface has several options which are completely opposite
242: * of the ustar and/or cpio interfaces...
243: */
244: f_unconditional = 1;
245: f_mtime = 1;
246: f_dir_create = 1;
247: f_list = 1;
248: blocksize = 0;
249: blocking = 0;
250: ar_interface = PAX;
251: ar_format = TAR; /* default interface if none given for -w */
252: msgfile=stdout;
253:
254: while ((c = getopt(ac, av, "ab:cdf:ilmoprs:t:uvwx:y")) != EOF) {
255: switch (c) {
256: case 'a':
257: f_append = 1;
258: f_list = 0;
259: break;
260: case 'b':
261: if ((blocksize = pax_optsize(optarg)) == 0) {
262: fatal("Bad block size");
263: }
264: break;
265: case 'c':
266: f_reverse_match = 1;
267: break;
268: case 'd':
269: f_dir_create = 0;
270: break;
271: case 'f':
272: if (blocksize == 0) {
273: blocking = 1;
274: blocksize = 1 * BLOCKSIZE;
275: }
276: ar_file = optarg;
277: break;
278: case 'i':
279: f_interactive = 1;
280: break;
281: case 'l':
282: f_link = 1;
283: break;
284: case 'm':
285: f_mtime = 0;
286: break;
287: case 'o':
288: f_owner = 1;
289: break;
290: case 'p':
291: f_access_time = 1;
292: break;
293: case 'r':
294: if (f_create) {
295: f_create = 0;
296: f_pass = 1;
297: } else {
298: f_list = 0;
299: f_extract = 1;
300: }
301: msgfile=stderr;
302: break;
303: case 's':
304: add_replstr(optarg);
305: break;
306: case 't':
307: if (blocksize == 0) {
308: blocking = 1;
309: blocksize = 10 * BLOCKSIZE;
310: }
311: ar_file = optarg;
312: break;
313: case 'u':
314: f_unconditional = 1;
315: break;
316: case 'v':
317: f_verbose = 1;
318: break;
319: case 'w':
320: if (f_extract) {
321: f_extract = 0;
322: f_pass = 1;
323: } else {
324: f_list = 0;
325: f_create = 1;
326: }
327: msgfile=stderr;
328: break;
329: case 'x':
330: if (strcmp(optarg, "ustar") == 0) {
331: ar_format = TAR;
332: } else if (strcmp(optarg, "cpio") == 0) {
333: ar_format = CPIO;
334: } else {
335: usage();
336: }
337: break;
338: case 'y':
339: f_disposition = 1;
340: break;
341: default:
342: usage();
343: }
344: }
345:
346: if (blocksize == 0) {
347: blocking = 1;
348: blocksize = blocking * BLOCKSIZE;
349: }
350: buf_allocate((OFFSET) blocksize);
351:
352: if (f_extract || f_list) {
353: open_archive(AR_READ);
354: get_archive_type();
355: read_archive();
356: } else if (f_create) {
357: if (optind >= n_argc) {
358: names_from_stdin++; /* args from stdin */
359: }
360: open_archive(AR_WRITE);
361: create_archive();
362: } else if (f_append) {
363: open_archive(AR_APPEND);
364: get_archive_type();
365: append_archive();
366: } else if (f_pass && optind < n_argc) {
367: dirname = n_argv[--n_argc];
368: if (LSTAT(dirname, &st) < 0) {
369: fatal(strerror());
370: }
371: if ((st.sb_mode & S_IFMT) != S_IFDIR) {
372: fatal("Not a directory");
373: }
374: if (optind >= n_argc) {
375: names_from_stdin++; /* args from stdin */
376: }
377: pass(dirname);
378: } else {
379: usage();
380: }
381:
382: return (0);
383: }
384:
385:
386: /* get_archive_type - determine input archive type from archive header
387: *
388: * DESCRIPTION
389: *
390: * reads the first block of the archive and determines the archive
391: * type from the data. If the archive type cannot be determined,
392: * processing stops, and a 1 is returned to the caller. If verbose
393: * mode is on, then the archive type will be printed on the standard
394: * error device as it is determined.
395: *
396: * FIXME
397: *
398: * be able to understand TAR and CPIO magic numbers
399: */
400:
401: #if __STDC__
402:
403: void get_archive_type(void)
404:
405: #else
406:
407: void get_archive_type()
408:
409: #endif
410: {
411: if (ar_read() != 0) {
412: fatal("Unable to determine archive type.");
413: }
414: if (strncmp(bufstart, "070707", 6) == 0) {
415: ar_format = CPIO;
416: if (f_verbose) {
417: fputs("CPIO format archive\n", stderr);
418: }
419: } else if (strncmp(&bufstart[257], "ustar", 5) == 0) {
420: ar_format = TAR;
421: if (f_verbose) {
422: fputs("USTAR format archive\n", stderr);
423: }
424: } else {
425: ar_format = TAR;
426: if (f_verbose) {
427: fputs("TAR(v7) format archive\n", stderr);
428: }
429: }
430: }
431:
432:
433: /* pax_optsize - interpret a size argument
434: *
435: * DESCRIPTION
436: *
437: * Recognizes suffixes for blocks (512-bytes), k-bytes and megabytes.
438: * Also handles simple expressions containing '+' for addition.
439: *
440: * PARAMETERS
441: *
442: * char *str - A pointer to the string to interpret
443: *
444: * RETURNS
445: *
446: * Normally returns the value represented by the expression in the
447: * the string.
448: *
449: * ERRORS
450: *
451: * If the string cannot be interpretted, the program will fail, since
452: * the buffering will be incorrect.
453: *
454: */
455:
456: #if __STDC__
457:
458: static OFFSET pax_optsize(char *str)
459:
460: #else
461:
462: static OFFSET pax_optsize(str)
463: char *str; /* pointer to string to interpret */
464:
465: #endif
466: {
467: char *idx;
468: OFFSET number; /* temporary storage for current number */
469: OFFSET result; /* cumulative total to be returned to caller */
470:
471: result = 0;
472: idx = str;
473: for (;;) {
474: number = 0;
475: while (*idx >= '0' && *idx <= '9')
476: number = number * 10 + *idx++ - '0';
477: switch (*idx++) {
478: case 'b':
479: result += number * 512L;
480: continue;
481: case 'k':
482: result += number * 1024L;
483: continue;
484: case 'm':
485: result += number * 1024L * 1024L;
486: continue;
487: case '+':
488: result += number;
489: continue;
490: case '\0':
491: result += number;
492: break;
493: default:
494: break;
495: }
496: break;
497: }
498: if (*--idx) {
499: fatal("Unrecognizable value");
500: }
501: return (result);
502: }
503:
504:
505: /* usage - print a helpful message and exit
506: *
507: * DESCRIPTION
508: *
509: * Usage prints out the usage message for the PAX interface and then
510: * exits with a non-zero termination status. This is used when a user
511: * has provided non-existant or incompatible command line arguments.
512: *
513: * RETURNS
514: *
515: * Returns an exit status of 1 to the parent process.
516: *
517: */
518:
519: #if __STDC__
520:
521: static void usage(void)
522:
523: #else
524:
525: static void usage()
526:
527: #endif
528: {
529: fprintf(stderr, "Usage: %s -[cimopuvy] [-f archive] [-s replstr] [-t device] [pattern...]\n",
530: myname);
531: fprintf(stderr, " %s -r [-cimopuvy] [-f archive] [-s replstr] [-t device] [pattern...]\n",
532: myname);
533: fprintf(stderr, " %s -w [-adimuvy] [-b blocking] [-f archive] [-s replstr]\n [-t device] [-x format] [pathname...]\n",
534: myname);
535: fprintf(stderr, " %s -r -w [-ilmopuvy] [-s replstr] [pathname...] directory\n",
536: myname);
537: exit(1);
538: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.