9b252039cf39f97c1c213c80db67d522cf2cfdd0
[openafs.git] / src / tools / afsdump_extract.c
1 /*
2  * CMUCS AFStools
3  * dumpscan - routines for scanning and manipulating AFS volume dumps
4  *
5  * Copyright (c) 1998 Carnegie Mellon University
6  * All Rights Reserved.
7  *
8  * Permission to use, copy, modify and distribute this software and its
9  * documentation is hereby granted, provided that both the copyright
10  * notice and this permission notice appear in all copies of the
11  * software, derivative works or modified versions, and any portions
12  * thereof, and that both notices appear in supporting documentation.
13  *
14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
16  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17  *
18  * Carnegie Mellon requests users of this software to return to
19  *
20  *  Software Distribution Coordinator  or  Software_Distribution@CS.CMU.EDU
21  *  School of Computer Science
22  *  Carnegie Mellon University
23  *  Pittsburgh PA 15213-3890
24  *
25  * any improvements or extensions that they make and grant Carnegie Mellon
26  * the rights to redistribute these changes.
27  */
28
29 /* afsdump_extract.c - Extract files from an AFS dump */
30
31 #include <afsconfig.h>
32 #include <afs/param.h>
33
34 #include <sys/fcntl.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <stdlib.h>
38 #include <stdarg.h>
39 #include <string.h>
40
41 #include <afs/com_err.h>
42 #include <afs/cellconfig.h>
43 #include <afs/vlserver.h>
44 #include <afs/volser.h>
45 #include <rx/rxkad.h>
46
47 #include "dumpscan.h"
48 #include "dumpscan_errs.h"
49 #include "xf_errs.h"
50
51 #define COPYBUFSIZE (256*1024)
52
53 extern int optind;
54 extern char *optarg;
55
56 char *argv0;
57 static char **file_names;
58 static int *file_vnums, name_count, vnum_count;
59
60 static char *input_path, *target;
61 static int quiet, verbose, error_count, dirs_done, extract_all;
62 static int nomode, use_realpath, use_vnum;
63 static int do_acls, do_headers;
64
65 static path_hashinfo phi;
66 static dump_parser dp;
67
68 /* Print a usage message and exit */
69 static void
70 usage(int status, char *msg)
71 {
72     if (msg)
73         fprintf(stderr, "%s: %s\n", argv0, msg);
74     fprintf(stderr, "Usage: %s [options] dumpfile [dest [files...]]\n",
75             argv0);
76     fprintf(stderr, "  -A     Save ACL's\n");
77     fprintf(stderr, "  -H     Save headers\n");
78     fprintf(stderr, "  -h     Print this help message\n");
79     fprintf(stderr, "  -i     Use vnode numbers\n");
80     fprintf(stderr, "  -n     Don't actually create files\n");
81     fprintf(stderr, "  -p     Use real pathnames internally\n");
82     fprintf(stderr, "  -q     Quiet mode (don't print errors)\n");
83     fprintf(stderr, "  -v     Verbose mode\n");
84     fprintf(stderr, "The destination directory defaults to .\n");
85     fprintf(stderr, "Files may be vnode numbers or volume-relative paths;\n");
86     fprintf(stderr, "If vnode numbers are used, files will be extracted\n");
87     fprintf(stderr,
88             "a name generated from the vnode number and uniqifier.\n");
89     fprintf(stderr, "If paths are used, -p is implied and files will be\n");
90     fprintf(stderr, "into correctly-named files.\n");
91     exit(status);
92 }
93
94
95 /* Parse the command-line options */
96 static void
97 parse_options(int argc, char **argv)
98 {
99     int c, i, i_name, i_vnum;
100
101     /* Set the program name */
102     if ((argv0 = strrchr(argv[0], '/')))
103         argv0++;
104     else
105         argv0 = argv[0];
106
107     /* Initialize options */
108     input_path = 0;
109     quiet = verbose = nomode = 0;
110     use_realpath = use_vnum = do_acls = do_headers = extract_all = 0;
111
112     /* Initialize other stuff */
113     error_count = 0;
114
115     /* Parse the options */
116     while ((c = getopt(argc, argv, "AHhinpqv")) != EOF) {
117         switch (c) {
118         case 'A':
119             do_acls = 1;
120             continue;
121         case 'H':
122             do_headers = 1;
123             continue;
124         case 'i':
125             use_vnum = 1;
126             continue;
127         case 'n':
128             nomode = 1;
129             continue;
130         case 'p':
131             use_realpath = 1;
132             continue;
133         case 'q':
134             quiet = 1;
135             continue;
136         case 'v':
137             verbose = 1;
138             continue;
139         case 'h':
140             usage(0, 0);
141         default:
142             usage(1, "Invalid option!");
143         }
144     }
145
146     if (quiet && verbose)
147         usage(1, "Can't specify both -q and -v");
148
149     /* Parse non-option arguments */
150     if (argc - optind < 1)
151         usage(1, "Dumpfile name required!");
152     input_path = argv[optind];
153
154     if (argc - optind < 2)
155         target = ".";
156     target = argv[optind + 1];
157
158     vnum_count = name_count = 0;
159     if (argc - optind < 3)
160         extract_all = 1;
161     else {
162         argv += optind + 2;
163         argc -= optind + 2;
164         for (i = 0; i < argc; i++) {
165             if (argv[i][0] == '/')
166                 name_count++;
167             else
168                 vnum_count++;
169         }
170         file_names = (char **)malloc(name_count + sizeof(char *));
171         file_vnums = (afs_int32 *) malloc(vnum_count + sizeof(afs_uint32));
172         if (name_count)
173             use_realpath = 1;
174
175         i_name = i_vnum = 0;
176         for (i = 0; i < argc; i++) {
177             if (argv[i][0] == '/')
178                 file_names[i_name++] = argv[i];
179             else
180                 file_vnums[i_vnum++] = strtol(argv[i], 0, 0);
181         }
182     }
183 }
184
185
186 static int
187 mkdirp(char *path)
188 {
189     char *x = path, slash;
190     struct stat statbuf;
191
192     for (;;) {
193         while (*x && *x != '/')
194             x++;
195         slash = *x;
196         *x = 0;
197
198         if (stat(path, &statbuf)) {
199             if (errno == ENOENT) {
200                 if (verbose)
201                     printf("> mkdir %s\n", path);
202                 if (!mkdir(path, 0755))
203                     errno = 0;
204             }
205         }
206         if (!slash)
207             break;
208         *x++ = '/';
209         if (errno)
210             return errno;
211     }
212
213     return 0;
214 }
215
216
217 static char *
218 modestr(int mode)
219 {
220     static char str[10];
221     int i;
222
223     strcpy(str, "rwxrwxrwx");
224     for (i = 0; i < 9; i++) {
225         if (!(mode & (1 << i)))
226             str[8 - i] = '-';
227     }
228     if (mode & 01000)
229         str[8] = (str[8] == '-') ? 'T' : 't';
230     if (mode & 02000)
231         str[5] = (str[5] == '-') ? 'S' : 's';
232     if (mode & 04000)
233         str[2] = (str[2] == '-') ? 'S' : 's';
234     return str;
235 }
236
237
238 static char *month[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
239     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
240 };
241 static char *
242 datestr(time_t date)
243 {
244     static char str[13];
245     time_t clock = time(0);
246     struct tm *now, *then;
247     int diff;
248
249     now = localtime(&clock);
250     then = localtime(&date);
251
252     diff = now->tm_mon - then->tm_mon;
253     if (then->tm_year == now->tm_year - 1)
254         diff += 12;
255     if (then->tm_year == now->tm_year + 1)
256         diff -= 12;
257
258     if (diff < 5 || diff > 5)
259         sprintf(str, "%3s %2d  %4d", month[then->tm_mon], then->tm_mday,
260                 then->tm_year + 1900);
261     else
262         sprintf(str, "%3s %2d %2d:%2d", month[then->tm_mon], then->tm_mday,
263                 then->tm_hour, then->tm_min);
264     return str;
265 }
266
267
268 /* Should we use this vnode?
269  * Return 0 if no, non-0 if yes
270  */
271 static int
272 usevnode(XFILE * X, afs_uint32 vnum, char *vnodepath)
273 {
274     int vl, vpl, r, i;
275
276     /* Special case */
277     if (extract_all || !strcmp(vnodepath, "/"))
278         return 1;
279
280     for (i = 0; i < vnum_count; i++)
281         if (vnum == file_vnums[i])
282             return 2;
283
284     vl = strlen(vnodepath);
285 /*fprintf(stderr, "++ checking %s\n", vnodepath);*/
286     for (i = 0; i < name_count; i++) {
287         vpl = strlen(file_names[i]);
288 /*  fprintf(stderr, "   %s\n", file_names[i]);*/
289
290         if (vl > vpl) {
291             r = !strncmp(file_names[i], vnodepath, vpl)
292                 && vnodepath[vpl] == '/';
293         } else if (vl < vpl) {
294             r = !strncmp(file_names[i], vnodepath, vl)
295                 && file_names[i][vl] == '/';
296         } else {
297             r = !strcmp(file_names[i], vnodepath);
298         }
299         if (r)
300             return 1;
301     }
302     return 0;
303 }
304
305
306 static int
307 copyfile(XFILE * in, XFILE * out, int size)
308 {
309     static char buf[COPYBUFSIZE];
310     int nr, r;
311
312     while (size) {
313         nr = (size > COPYBUFSIZE) ? COPYBUFSIZE : size;
314         if ((r = xfread(in, buf, nr)))
315             return r;
316         if ((r = xfwrite(out, buf, nr)))
317             return r;
318         size -= nr;
319     }
320     return 0;
321 }
322
323
324 /* A callback to count and print errors */
325 static afs_uint32
326 my_error_cb(afs_uint32 code, int fatal, void *ref, char *msg, ...)
327 {
328     va_list alist;
329
330     error_count++;
331     if (!quiet) {
332         va_start(alist, msg);
333         afs_com_err_va(argv0, code, msg, alist);
334         va_end(alist);
335     }
336     return 0;
337 }
338
339
340 static afs_uint32
341 dumphdr_cb(afs_dump_header * hdr, XFILE * X, void *refcon)
342 {
343     return 0;
344 }
345
346
347 static afs_uint32
348 volhdr_cb(afs_vol_header * hdr, XFILE * X, void *refcon)
349 {
350     return 0;
351 }
352
353
354 static afs_uint32
355 directory_cb(afs_vnode * v, XFILE * X, void *refcon)
356 {
357     char *vnodepath;
358     int r, use = 0;
359
360     /* Should we even use this? */
361     if (!use_vnum) {
362         if ((r = Path_Build(X, &phi, v->vnode, &vnodepath, !use_realpath)))
363             return r;
364         if (!(use = usevnode(X, v->vnode, vnodepath))) {
365             free(vnodepath);
366             return 0;
367         }
368     }
369
370     /* Print it out */
371     if (verbose) {
372         if (use_vnum)
373             printf("d%s %3d %-11d %11d %s #%d:%d\n", modestr(v->mode),
374                    v->nlinks, v->owner, v->size, datestr(v->server_date),
375                    v->vnode, v->vuniq);
376         else
377             printf("d%s %3d %-11d %11d %s %s\n", modestr(v->mode), v->nlinks,
378                    v->owner, v->size, datestr(v->server_date), vnodepath);
379     } else if (!quiet && !use_vnum)
380         printf("%s\n", vnodepath);
381
382     /* Make the directory, if needed */
383     if (!nomode && !use_vnum && use != 2) {
384         if (strcmp(vnodepath, "/")
385             && (r = mkdirp(vnodepath + 1))) {
386             free(vnodepath);
387             return r;
388         }
389         if (do_acls) {
390             /* XXX do ACL's later */
391         }
392     }
393     if (!use_vnum)
394         free(vnodepath);
395     return 0;
396 }
397
398
399 static afs_uint32
400 file_cb(afs_vnode * v, XFILE * X, void *refcon)
401 {
402     char *vnodepath, vnpx[30];
403     dt_uint64 where;
404     XFILE OX;
405     int r, use = 0;
406
407     if (!dirs_done) {
408         dirs_done = 1;
409         if (verbose)
410             printf("* Extracting files...\n");
411     }
412
413     /* Should we even use this? */
414     if (!use_vnum) {
415         if ((r = Path_Build(X, &phi, v->vnode, &vnodepath, !use_realpath)))
416             return r;
417         if (!(use = usevnode(X, v->vnode, vnodepath))) {
418             free(vnodepath);
419             return 0;
420         }
421         if (use == 2) {
422             free(vnodepath);
423             sprintf(vnpx, "#%d:%d", v->vnode, v->vuniq);
424             vnodepath = vnpx;
425         }
426     } else {
427         sprintf(vnpx, "#%d:%d", v->vnode, v->vuniq);
428         vnodepath = vnpx;
429     }
430
431     /* Print it out */
432     if (verbose) {
433         printf("-%s %3d %-11d %11d %s %s\n", modestr(v->mode), v->nlinks,
434                v->owner, v->size, datestr(v->server_date), vnodepath);
435     } else if (!quiet) {
436         printf("%s\n", vnodepath);
437     }
438
439     if (!nomode) {
440         if ((r = xftell(X, &where))
441             || (r = xfseek(X, &v->d_offset))
442             || (r =
443                 xfopen_path(&OX, O_RDWR | O_CREAT | O_TRUNC, vnodepath + 1,
444                             0644))) {
445             if (!use_vnum)
446                 free(vnodepath);
447             return r;
448         }
449         r = copyfile(X, &OX, v->size);
450         xfclose(&OX);
451         xfseek(X, &where);
452     } else
453         r = 0;
454
455     if (!use_vnum && use != 2)
456         free(vnodepath);
457     return r;
458 }
459
460
461 static afs_uint32
462 symlink_cb(afs_vnode * v, XFILE * X, void *refcon)
463 {
464     char *vnodepath, *linktarget, vnpx[30];
465     dt_uint64 where;
466     int r, use = 0;
467
468     if (!dirs_done) {
469         dirs_done = 1;
470         if (verbose)
471             printf("* Extracting files...\n");
472     }
473
474     /* Should we even use this? */
475     if (!use_vnum) {
476         if ((r = Path_Build(X, &phi, v->vnode, &vnodepath, !use_realpath)))
477             return r;
478         if (!(use = usevnode(X, v->vnode, vnodepath))) {
479             free(vnodepath);
480             return 0;
481         }
482         if (use == 2) {
483             free(vnodepath);
484             sprintf(vnpx, "#%d:%d", v->vnode, v->vuniq);
485             vnodepath = vnpx;
486         }
487     } else {
488         sprintf(vnpx, "#%d:%d", v->vnode, v->vuniq);
489         vnodepath = vnpx;
490     }
491
492     if (!(linktarget = (char *)malloc(v->size + 1))) {
493         if (!use_vnum && use != 2)
494             free(vnodepath);
495         return DSERR_MEM;
496     }
497     if ((r = xftell(X, &where))
498         || (r = xfseek(X, &v->d_offset))
499         || (r = xfread(X, linktarget, v->size))) {
500         if (!use_vnum && use != 2)
501             free(vnodepath);
502         free(linktarget);
503         return r;
504     }
505     xfseek(X, &where);
506     linktarget[v->size] = 0;
507
508     /* Print it out */
509     if (verbose)
510         printf("l%s %3d %-11d %11d %s %s -> %s\n", modestr(v->mode),
511                v->nlinks, v->owner, v->size, datestr(v->server_date),
512                vnodepath, linktarget);
513     else if (!quiet)
514         printf("%s\n", vnodepath);
515
516     r = 0;
517     if (!nomode) {
518         if (symlink(linktarget, vnodepath + 1))
519             r = errno;
520     }
521
522     free(linktarget);
523     if (!use_vnum && use != 2)
524         free(vnodepath);
525     return r;
526 }
527
528
529 static afs_uint32
530 lose_cb(afs_vnode * v, XFILE * F, void *refcon)
531 {
532     if (!dirs_done) {
533         dirs_done = 1;
534         if (verbose)
535             printf("* Extracting files...\n");
536     }
537
538     return 0;
539 }
540
541
542 /* Main program */
543 int
544 main(int argc, char **argv)
545 {
546     XFILE input_file;
547     afs_uint32 r;
548
549     parse_options(argc, argv);
550     initialize_acfg_error_table();
551     initialize_AVds_error_table();
552     initialize_rxk_error_table();
553     initialize_u_error_table();
554     initialize_vl_error_table();
555     initialize_vols_error_table();
556     initialize_xFil_error_table();
557     r = xfopen(&input_file, O_RDONLY, input_path);
558     if (r) {
559         afs_com_err(argv0, r, "opening %s", input_path);
560         exit(2);
561     }
562
563     memset(&dp, 0, sizeof(dp));
564     dp.cb_error = my_error_cb;
565     if (input_file.is_seekable)
566         dp.flags |= DSFLAG_SEEK;
567     dirs_done = 0;
568
569     if (!use_vnum) {
570         dt_uint64 where;
571
572         memset(&phi, 0, sizeof(phi));
573         phi.p = &dp;
574
575         if (verbose)
576             printf("* Building pathname info...\n");
577         if ((r = xftell(&input_file, &where))
578             || (r = Path_PreScan(&input_file, &phi, 1))
579             || (r = xfseek(&input_file, &where))) {
580             afs_com_err(argv0, r, "- path initialization failed");
581             xfclose(&input_file);
582             exit(1);
583         }
584     }
585
586     dp.cb_vnode_dir = directory_cb;
587     dp.cb_vnode_file = file_cb;
588     dp.cb_vnode_link = symlink_cb;
589     dp.cb_vnode_empty = lose_cb;
590     dp.cb_vnode_wierd = lose_cb;
591     if (do_headers) {
592         dp.cb_dumphdr = dumphdr_cb;
593         dp.cb_volhdr = volhdr_cb;
594     }
595
596     if (!nomode) {
597         mkdir(target, 0755);
598         if (chdir(target)) {
599             fprintf(stderr, "chdir %s failed: %s\n", target, strerror(errno));
600             exit(1);
601         }
602     }
603     r = ParseDumpFile(&input_file, &dp);
604
605     if (verbose && error_count)
606         fprintf(stderr, "*** %d errors\n", error_count);
607     if (r && !quiet)
608         fprintf(stderr, "*** FAILED: %s\n", afs_error_message(r));
609     exit(0);
610 }