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