add-volupdate-counter-20051015
[openafs.git] / src / volser / restorevol.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * Read a vos dump and recreate the tree.
12  *
13  * restorevol [-file <dump file>]
14  *            [-dir <restore dir>]
15  *            [-extension <name extension>]
16  *            [-mountpoint <mount point root>]
17  *            [-umask <mode mask>]
18  *
19  * 1. The dump file will be restored within the current or that specified with -dir.
20  * 2. Within this dir, a subdir is created. It's name is the RW volume name
21  *    that was dumped. An extension can be appended to this directory name
22  *    with -extension.
23  * 3. All mountpoints will appear as symbolic links to the volume. The
24  *    pathname to the volume will be either that in -mountpoint, or -dir.
25  *    Symbolic links remain untouched.
26  * 4. You can change your umask during the restore with -umask. Otherwise, it
27  *    uses your current umask. Mode bits for directories are 0777 (then
28  *    AND'ed with the umask). Mode bits for files are the owner mode bits
29  *    duplicated accross group and user (then AND'ed with the umask).
30  * 5. For restores of full dumps, if a directory says it has a file and 
31  *    the file is not found, then a symbolic link "AFSFile-<#>" will 
32  *    appear in that restored tree. Restores of incremental dumps remove 
33  *    all these files at the end (expensive because it is a tree search).  
34  * 6. If a file or directory was found in the dump but found not to be 
35  *    connected to the hierarchical tree, then the file or directory 
36  *    will be connected at the root of the tree as "__ORPHANEDIR__.<#>" 
37  *    or "__ORPHANFILE__.<#>".  
38  * 7. ACLs are not restored.
39  *
40  */
41
42 #include <afsconfig.h>
43 #include <afs/param.h>
44
45 RCSID
46     ("$Header$");
47
48 #include <afs/afsint.h>
49 #include <afs/nfs.h>
50 #include <lock.h>
51 #include <afs/ihandle.h>
52 #include <afs/vnode.h>
53 #include <afs/volume.h>
54 #include "volint.h"
55 #include "dump.h"
56 #include <afs/cmd.h>
57
58 #include <sys/param.h>
59 #include <sys/types.h>
60 #include <sys/uio.h>
61 #include <stdio.h>
62 #include <errno.h>
63 #include <netinet/in.h>
64 #include <sys/stat.h>
65 #include <fcntl.h>
66 #include <dirent.h>
67
68 #ifdef HAVE_STRING_H
69 #include <string.h>
70 #else
71 #ifdef HAVE_STRINGS_H
72 #include <strings.h>
73 #endif
74 #endif
75
76
77 char rootdir[MAXPATHLEN];
78 char mntroot[MAXPATHLEN];
79 #define ADIR  "AFSDir-"
80 #define AFILE "AFSFile-"
81 #define ODIR  "__ORPHANEDIR__."
82 #define OFILE "__ORPHANFILE__."
83
84 int inc_dump = 0;
85 FILE *dumpfile;
86
87 afs_int32
88 readvalue(size)
89 {
90     afs_int32 value, s;
91     int code;
92     char *ptr;
93
94     value = 0;
95     ptr = (char *)&value;
96
97     s = sizeof(value) - size;
98     if (size < 0) {
99         fprintf(stderr, "Too much data in afs_int32\n");
100         return 0;
101     }
102
103     code = fread(&ptr[s], 1, size, dumpfile);
104     if (code != size)
105         fprintf(stderr, "Code = %d; Errno = %d\n", code, errno);
106
107     return (value);
108 }
109
110 char
111 readchar()
112 {
113     char value;
114     int code;
115     char *ptr;
116
117     value = '\0';
118     code = fread(&value, 1, 1, dumpfile);
119     if (code != 1)
120         fprintf(stderr, "Code = %d; Errno = %d\n", code, errno);
121
122     return (value);
123 }
124
125 #define BUFSIZE 16384
126 char buf[BUFSIZE];
127
128 char
129 readdata(buffer, size)
130      char *buffer;
131      afs_sfsize_t size;
132 {
133     int code;
134     afs_int32 s;
135
136     if (!buffer) {
137         while (size > 0) {
138             s = (afs_int32) ((size > BUFSIZE) ? BUFSIZE : size);
139             code = fread(buf, 1, s, dumpfile);
140             if (code != s)
141                 fprintf(stderr, "Code = %d; Errno = %d\n", code, errno);
142             size -= s;
143         }
144     } else {
145         code = fread(buffer, 1, size, dumpfile);
146         if (code != size) {
147             if (code < 0)
148                 fprintf(stderr, "Code = %d; Errno = %d\n", code, errno);
149             else
150                 fprintf(stderr, "Read %d bytes out of %lld\n", code, (afs_uintmax_t)size);
151         }
152         if ((code >= 0) && (code < BUFSIZE))
153             buffer[size] = 0;   /* Add null char at end */
154     }
155 }
156
157 afs_int32
158 ReadDumpHeader(dh)
159      struct DumpHeader *dh;     /* Defined in dump.h */
160 {
161     int code, i, done;
162     char tag, c;
163     afs_int32 magic;
164
165 /*  memset(&dh, 0, sizeof(dh)); */
166
167     magic = ntohl(readvalue(4));
168     dh->version = ntohl(readvalue(4));
169
170     done = 0;
171     while (!done) {
172         tag = readchar();
173         switch (tag) {
174         case 'v':
175             dh->volumeId = ntohl(readvalue(4));
176             break;
177
178         case 'n':
179             for (i = 0, c = 'a'; c != '\0'; i++) {
180                 dh->volumeName[i] = c = readchar();
181             }
182             dh->volumeName[i] = c;
183             break;
184
185         case 't':
186             dh->nDumpTimes = ntohl(readvalue(2)) >> 1;
187             for (i = 0; i < dh->nDumpTimes; i++) {
188                 dh->dumpTimes[i].from = ntohl(readvalue(4));
189                 dh->dumpTimes[i].to = ntohl(readvalue(4));
190             }
191             break;
192
193         default:
194             done = 1;
195             break;
196         }
197     }
198
199     return ((afs_int32) tag);
200 }
201
202 struct volumeHeader {
203     afs_int32 volumeId;
204     char volumeName[100];
205     afs_int32 volType;
206     afs_int32 uniquifier;
207     afs_int32 parentVol;
208     afs_int32 cloneId;
209     afs_int32 maxQuota;
210     afs_int32 minQuota;
211     afs_int32 diskUsed;
212     afs_int32 fileCount;
213     afs_int32 accountNumber;
214     afs_int32 owner;
215     afs_int32 creationDate;
216     afs_int32 accessDate;
217     afs_int32 updateDate;
218     afs_int32 expirationDate;
219     afs_int32 backupDate;
220     afs_int32 dayUseDate;
221     afs_int32 dayUse;
222     afs_int32 weekCount;
223     afs_int32 weekUse[100];     /* weekCount of these */
224     char motd[1024];
225     int inService;
226     int blessed;
227     char message[1024];
228     afs_int32 volUpdateCounter;
229 };
230
231 afs_int32
232 ReadVolumeHeader(count)
233      afs_int32 count;
234 {
235     struct volumeHeader vh;
236     int code, i, done, entries;
237     char tag, c;
238
239 /*  memset(&vh, 0, sizeof(vh)); */
240
241     done = 0;
242     while (!done) {
243         tag = readchar();
244         switch (tag) {
245         case 'i':
246             vh.volumeId = ntohl(readvalue(4));
247             break;
248
249         case 'v':
250             ntohl(readvalue(4));        /* version stamp - ignore */
251             break;
252
253         case 'n':
254             for (i = 0, c = 'a'; c != '\0'; i++) {
255                 vh.volumeName[i] = c = readchar();
256             }
257             vh.volumeName[i] = c;
258             break;
259
260         case 's':
261             vh.inService = ntohl(readvalue(1));
262             break;
263
264         case 'b':
265             vh.blessed = ntohl(readvalue(1));
266             break;
267
268         case 'u':
269             vh.uniquifier = ntohl(readvalue(4));
270             break;
271
272         case 't':
273             vh.volType = ntohl(readvalue(1));
274             break;
275
276         case 'p':
277             vh.parentVol = ntohl(readvalue(4));
278             break;
279
280         case 'c':
281             vh.cloneId = ntohl(readvalue(4));
282             break;
283
284         case 'q':
285             vh.maxQuota = ntohl(readvalue(4));
286             break;
287
288         case 'm':
289             vh.minQuota = ntohl(readvalue(4));
290             break;
291
292         case 'd':
293             vh.diskUsed = ntohl(readvalue(4));
294             break;
295
296         case 'f':
297             vh.fileCount = ntohl(readvalue(4));
298             break;
299
300         case 'a':
301             vh.accountNumber = ntohl(readvalue(4));
302             break;
303
304         case 'o':
305             vh.owner = ntohl(readvalue(4));
306             break;
307
308         case 'C':
309             vh.creationDate = ntohl(readvalue(4));
310             break;
311
312         case 'A':
313             vh.accessDate = ntohl(readvalue(4));
314             break;
315
316         case 'U':
317             vh.updateDate = ntohl(readvalue(4));
318             break;
319
320         case 'E':
321             vh.expirationDate = ntohl(readvalue(4));
322             break;
323
324         case 'B':
325             vh.backupDate = ntohl(readvalue(4));
326             break;
327
328         case 'O':
329             for (i = 0, c = 'a'; c != '\0'; i++) {
330                 vh.message[i] = c = readchar();
331             }
332             vh.volumeName[i] = c;
333             break;
334
335         case 'W':
336             vh.weekCount = ntohl(readvalue(2));
337             for (i = 0; i < vh.weekCount; i++) {
338                 vh.weekUse[i] = ntohl(readvalue(4));
339             }
340             break;
341
342         case 'M':
343             for (i = 0, c = 'a'; c != '\0'; i++) {
344                 vh.motd[i] = c = readchar();
345             }
346             break;
347
348         case 'D':
349             vh.dayUseDate = ntohl(readvalue(4));
350             break;
351
352         case 'Z':
353             vh.dayUse = ntohl(readvalue(4));
354             break;
355         case 'V':
356             vh.volUpdateCounter = ntohl(readvalue(4));
357             break;
358
359         default:
360             done = 1;
361             break;
362         }
363     }
364
365     return ((afs_int32) tag);
366 }
367
368 struct vNode {
369     afs_int32 vnode;
370     afs_int32 uniquifier;
371     afs_int32 type;
372     afs_int32 linkCount;
373     afs_int32 dataVersion;
374     afs_int32 unixModTime;
375     afs_int32 servModTime;
376     afs_int32 author;
377     afs_int32 owner;
378     afs_int32 group;
379     afs_int32 modebits;
380     afs_int32 parent;
381     char acl[192];
382 #ifdef notdef
383     struct acl_accessList {
384         int size;               /*size of this access list in bytes, including MySize itself */
385         int version;            /*to deal with upward compatibility ; <= ACL_ACLVERSION */
386         int total;
387         int positive;           /* number of positive entries */
388         int negative;           /* number of minus entries */
389         struct acl_accessEntry {
390             int id;             /*internally-used ID of user or group */
391             int rights;         /*mask */
392         } entries[100];
393     } acl;
394 #endif
395     afs_sfsize_t dataSize;
396 };
397
398 #define MAXNAMELEN 256
399
400 afs_int32
401 ReadVNode(count)
402      afs_int32 count;
403 {
404     struct vNode vn;
405     int code, i, done, entries;
406     char tag, c;
407     char dirname[MAXNAMELEN], linkname[MAXNAMELEN], lname[MAXNAMELEN];
408     char parentdir[MAXNAMELEN], vflink[MAXNAMELEN];
409     char filename[MAXNAMELEN], fname[MAXNAMELEN];
410     int len;
411     afs_int32 vnode;
412     afs_int32 mode = 0;
413
414 /*  memset(&vn, 0, sizeof(vn)); */
415     vn.dataSize = 0;
416     vn.vnode = 0;
417     vn.parent = 0;
418     vn.type = 0;
419
420     vn.vnode = ntohl(readvalue(4));
421     vn.uniquifier = ntohl(readvalue(4));
422
423     done = 0;
424     while (!done) {
425         tag = readchar();
426         switch (tag) {
427         case 't':
428             vn.type = ntohl(readvalue(1));
429             break;
430
431         case 'l':
432             vn.linkCount = ntohl(readvalue(2));
433             break;
434
435         case 'v':
436             vn.dataVersion = ntohl(readvalue(4));
437             break;
438
439         case 'm':
440             vn.unixModTime = ntohl(readvalue(4));
441             break;
442
443         case 's':
444             vn.servModTime = ntohl(readvalue(4));
445             break;
446
447         case 'a':
448             vn.author = ntohl(readvalue(4));
449             break;
450
451         case 'o':
452             vn.owner = ntohl(readvalue(4));
453             break;
454
455         case 'g':
456             vn.group = ntohl(readvalue(4));
457             break;
458
459         case 'b':
460             vn.modebits = ntohl(readvalue(2));
461             break;
462
463         case 'p':
464             vn.parent = ntohl(readvalue(4));
465             break;
466
467         case 'A':
468             readdata(vn.acl, 192);      /* Skip ACL data */
469             break;
470
471 #ifdef AFS_LARGEFILE_ENV
472         case 'h':
473             {
474                 afs_uint32 hi, lo;
475                 hi = ntohl(readvalue(4));
476                 lo = ntohl(readvalue(4));
477                 FillInt64(vn.dataSize, hi, lo);
478             }
479             goto common_vnode;
480 #endif /* !AFS_LARGEFILE_ENV */
481
482         case 'f':
483             vn.dataSize = ntohl(readvalue(4));
484
485           common_vnode:
486             /* parentdir is the name of this dir's vnode-file-link
487              * or this file's parent vnode-file-link.
488              * "./AFSDir-<#>". It's a symbolic link to its real dir.
489              * The parent dir and symbolic link to it must exist.
490              */
491             vnode = ((vn.type == 2) ? vn.vnode : vn.parent);
492             if (vnode == 1)
493                 strncpy(parentdir, rootdir, sizeof parentdir);
494             else {
495                 afs_snprintf(parentdir, sizeof parentdir, "%s/%s%d", rootdir,
496                              ADIR, vnode);
497
498                 len = readlink(parentdir, linkname, MAXNAMELEN);
499                 if (len < 0) {
500                     /* parentdir does not exist. So create an orphan dir.
501                      * and then link the parentdir to the orphaned dir.
502                      */
503                     afs_snprintf(linkname, sizeof linkname, "%s/%s%d",
504                                  rootdir, ODIR, vnode);
505                     code = mkdir(linkname, 0777);
506                     if ((code < 0) && (errno != EEXIST)) {
507                         fprintf(stderr,
508                                 "Error creating directory %s  code=%d;%d\n",
509                                 linkname, code, errno);
510                     }
511
512                     /* Link the parentdir to it - now parentdir exists */
513                     afs_snprintf(linkname, sizeof linkname, "%s%d/", ODIR,
514                                  vnode);
515                     code = symlink(linkname, parentdir);
516                     if (code) {
517                         fprintf(stderr,
518                                 "Error creating symlink %s -> %s  code=%d;%d\n",
519                                 parentdir, linkname, code, errno);
520                     }
521                 }
522             }
523
524             if (vn.type == 2) {
525                  /*ITSADIR*/
526                     /* We read the directory entries. If the entry is a
527                      * directory, the subdir is created and the root dir
528                      * will contain a link to it. If its a file, we only
529                      * create a symlink in the dir to the file name.
530                      */
531                 char *buffer;
532                 unsigned short j;
533                 afs_int32 this_vn;
534                 char *this_name;
535
536                 struct DirEntry {
537                     char flag;
538                     char length;
539                     unsigned short next;
540                     struct MKFid {
541                         afs_int32 vnode;
542                         afs_int32 vunique;
543                     } fid;
544                     char name[20];
545                 };
546
547                 struct Pageheader {
548                     unsigned short pgcount;
549                     unsigned short tag;
550                     char freecount;
551                     char freebitmap[8];
552                     char padding[19];
553                 };
554
555                 struct DirHeader {
556                     struct Pageheader header;
557                     char alloMap[128];
558                     unsigned short hashTable[128];
559                 };
560
561                 struct Page0 {
562                     struct DirHeader header;
563                     struct DirEntry entry[1];
564                 } *page0;
565
566
567                 buffer = NULL;
568                 buffer = (char *)malloc(vn.dataSize);
569
570                 readdata(buffer, vn.dataSize);
571                 page0 = (struct Page0 *)buffer;
572
573                 /* Step through each bucket in the hash table, i,
574                  * and follow each element in the hash chain, j.
575                  * This gives us each entry of the dir.
576                  */
577                 for (i = 0; i < 128; i++) {
578                     for (j = ntohs(page0->header.hashTable[i]); j;
579                          j = ntohs(page0->entry[j].next)) {
580                         j -= 13;
581                         this_vn = ntohl(page0->entry[j].fid.vnode);
582                         this_name = page0->entry[j].name;
583
584                         if ((strcmp(this_name, ".") == 0)
585                             || (strcmp(this_name, "..") == 0))
586                             continue;   /* Skip these */
587
588                         /* For a directory entry, create it. Then create the
589                          * link (from the rootdir) to this directory.
590                          */
591                         if (this_vn & 1) {
592                              /*ADIRENTRY*/
593                                 /* dirname is the directory to create.
594                                  * vflink is what will link to it. 
595                                  */
596                                 afs_snprintf(dirname, sizeof dirname, "%s/%s",
597                                              parentdir, this_name);
598                             afs_snprintf(vflink, sizeof vflink, "%s/%s%d",
599                                          rootdir, ADIR, this_vn);
600
601                             /* The link and directory may already exist */
602                             len = readlink(vflink, linkname, MAXNAMELEN);
603                             if (len < 0) {
604                                 /* Doesn't already exist - so create the directory.
605                                  * umask will pare the mode bits down.
606                                  */
607                                 code = mkdir(dirname, 0777);
608                                 if ((code < 0) && (errno != EEXIST)) {
609                                     fprintf(stderr,
610                                             "Error creating directory %s  code=%d;%d\n",
611                                             dirname, code, errno);
612                                 }
613                             } else {
614                                 /* Does already exist - so move the directory.
615                                  * It was created originally as orphaned.
616                                  */
617                                 linkname[len - 1] = '\0';       /* remove '/' at end */
618                                 afs_snprintf(lname, sizeof lname, "%s/%s",
619                                              rootdir, linkname);
620                                 code = rename(lname, dirname);
621                                 if (code) {
622                                     fprintf(stderr,
623                                             "Error renaming %s to %s  code=%d;%d\n",
624                                             lname, dirname, code, errno);
625                                 }
626                             }
627
628                             /* Now create/update the link to the new/moved directory */
629                             if (vn.vnode == 1)
630                                 afs_snprintf(dirname, sizeof dirname, "%s/",
631                                              this_name);
632                             else
633                                 afs_snprintf(dirname, sizeof dirname,
634                                              "%s%d/%s/", ADIR, vn.vnode,
635                                              this_name);
636                             unlink(vflink);
637                             code = symlink(dirname, vflink);
638                             if (code) {
639                                 fprintf(stderr,
640                                         "Error creating symlink %s -> %s  code=%d;%d\n",
641                                         vflink, dirname, code, errno);
642                             }
643                         }
644                         /*ADIRENTRY*/
645                             /* For a file entry, we remember the name of the file
646                              * by creating a link within the directory. Restoring
647                              * the file will later remove the link.
648                              */
649                             else {
650                              /*AFILEENTRY*/ afs_snprintf(vflink,
651                                                          sizeof vflink,
652                                                          "%s/%s%d", parentdir,
653                                                          AFILE, this_vn);
654
655                             code = symlink(this_name, vflink);
656                             if ((code < 0) && (errno != EEXIST)) {
657                                 fprintf(stderr,
658                                         "Error creating symlink %s -> %s  code=%d;%d\n",
659                                         vflink, page0->entry[j].name, code,
660                                         errno);
661                             }
662                         }
663                      /*AFILEENTRY*/}
664                 }
665                 free(buffer);
666             }
667             /*ITSADIR*/
668             else if (vn.type == 1) {
669                  /*ITSAFILE*/
670                     /* A file vnode. So create it into the desired directory. A
671                      * link should exist in the directory naming the file.
672                      */
673                 int fid;
674                 int lfile;
675                 afs_sfsize_t size, s;
676
677                 /* Check if its vnode-file-link exists. If not,
678                  * then the file will be an orphaned file.
679                  */
680                 lfile = 1;
681                 afs_snprintf(filename, sizeof filename, "%s/%s%d", parentdir,
682                              AFILE, vn.vnode);
683                 len = readlink(filename, fname, MAXNAMELEN);
684                 if (len < 0) {
685                     afs_snprintf(filename, sizeof filename, "%s/%s%d",
686                                  rootdir, OFILE, vn.vnode);
687                     lfile = 0;  /* no longer a linked file; a direct path */
688                 }
689
690                 /* Create a mode for the file. Use the owner bits and
691                  * duplicate them across group and other. The umask
692                  * will remove what we don't want.
693                  */
694                 mode = (vn.modebits >> 6) & 0x7;
695                 mode |= (mode << 6) | (mode << 3);
696
697                 /* Write the file out */
698                 fid = open(filename, (O_CREAT | O_WRONLY | O_TRUNC), mode);
699                 size = vn.dataSize;
700                 while (size > 0) {
701                     s = (afs_int32) ((size > BUFSIZE) ? BUFSIZE : size);
702                     code = fread(buf, 1, s, dumpfile);
703                     if (code > 0) {
704                         (void)write(fid, buf, code);
705                         size -= code;
706                     }
707                     if (code != s) {
708                         if (code < 0)
709                             fprintf(stderr, "Code = %d; Errno = %d\n", code,
710                                     errno);
711                         else {
712                             char tmp[100];
713                             (void)afs_snprintf(tmp, sizeof tmp,
714                                                "Read %llu bytes out of %llu",
715                                                (afs_uintmax_t) (vn.dataSize -
716                                                                 size),
717                                                (afs_uintmax_t) vn.dataSize);
718                             fprintf(stderr, "%s\n", tmp);
719                         }
720                         break;
721                     }
722                 }
723                 close(fid);
724                 if (size != 0) {
725                     fprintf(stderr, "   File %s (%s) is incomplete\n",
726                             filename, fname);
727                 }
728
729                 /* Remove the link to the file */
730                 if (lfile) {
731                     unlink(filename);
732                 }
733             }
734             /*ITSAFILE*/
735             else if (vn.type == 3) {
736                  /*ITSASYMLINK*/
737                     /* A symlink vnode. So read it into the desired directory. This could
738                      * also be a mount point. If the volume is being restored to AFS, this
739                      * will become a mountpoint. If not, it becomes a symlink to no-where.
740                      */
741                 int fid;
742                 afs_int32 size, s;
743
744                 /* Check if its vnode-file-link exists and create pathname
745                  * of the symbolic link. If it doesn't exist,
746                  * then the link will be an orphaned link.
747                  */
748                 afs_snprintf(linkname, sizeof linkname, "%s/%s%d", parentdir,
749                              AFILE, vn.vnode);
750                 len = readlink(linkname, fname, MAXNAMELEN);
751                 if (len < 0) {
752                     afs_snprintf(filename, sizeof filename, "%s/%s%d",
753                                  rootdir, OFILE, vn.vnode);
754                 } else {
755                     fname[len] = '\0';
756                     afs_snprintf(filename, sizeof filename, "%s/%s",
757                                  parentdir, fname);
758                 }
759
760                 /* Read the link in, delete it, and then create it */
761                 readdata(buf, vn.dataSize);
762
763                 /* If a mountpoint, change its link path to mountroot */
764                 s = strlen(buf);
765                 if (((buf[0] == '%') || (buf[0] == '#'))
766                     && (buf[s - 1] == '.')) {
767                     /* This is a symbolic link */
768                     buf[s - 1] = 0;     /* Remove prefix '.' */
769                     strcpy(lname, &buf[1]);     /* Remove postfix '#' or '%' */
770                     strcpy(buf, mntroot);
771                     strcat(buf, lname);
772                 }
773
774                 unlink(filename);
775                 code = symlink(buf, filename);
776                 if (code) {
777                     fprintf(stderr,
778                             "Error creating symlink %s -> %s  code=%d;%d\n",
779                             filename, buf, code, errno);
780                 }
781
782                 /* Remove the symbolic link */
783                 unlink(linkname);
784             }
785             /*ITSASYMLINK*/
786             else {
787                 fprintf(stderr, "Unknown Vnode block\n");
788             }
789             break;
790
791         default:
792             done = 1;
793             break;
794         }
795     }
796     if (vn.type == 0)
797         inc_dump = 1;
798
799     return ((afs_int32) tag);
800 }
801
802 WorkerBee(as, arock)
803      struct cmd_syndesc *as;
804      char *arock;
805 {
806     int code = 0, c, len;
807     afs_int32 type, count, vcount;
808     DIR *dirP, *dirQ;
809     struct dirent *dirE, *dirF;
810     char fname[MAXNAMELEN], name[MAXNAMELEN], lname[MAXNAMELEN],
811         mname[MAXNAMELEN];
812     char thisdir[MAXPATHLEN], *t;
813     struct DumpHeader dh;       /* Defined in dump.h */
814 #if 0/*ndef HAVE_GETCWD*/       /* XXX enable when autoconf happens */
815     extern char *getwd();
816 #define getcwd(x,y) getwd(x)
817 #endif
818
819     if (as->parms[0].items) {   /* -file <dumpfile> */
820         dumpfile = fopen(as->parms[0].items->data, "r");
821         if (!dumpfile) {
822             fprintf(stderr, "Cannot open '%s'. Code = %d\n",
823                     as->parms[0].items->data, errno);
824             goto cleanup;
825         }
826     } else {
827         dumpfile = (FILE *) stdin;      /* use stdin */
828     }
829
830     /* Read the dump header. From it we get the volume name */
831     type = ntohl(readvalue(1));
832     if (type != 1) {
833         fprintf(stderr, "Expected DumpHeader\n");
834         code = -1;
835         goto cleanup;
836     }
837     type = ReadDumpHeader(&dh);
838
839     /* Get the root directory we restore to */
840     if (as->parms[1].items) {   /* -dir <rootdir> */
841         strcpy(rootdir, as->parms[1].items->data);
842     } else {
843         strcpy(rootdir, ".");
844     }
845     strcat(rootdir, "/");
846
847     /* Append the RW volume name to the root directory */
848     strcat(rootdir, dh.volumeName);
849     len = strlen(rootdir);
850     if (strcmp(".backup", rootdir + len - 7) == 0) {
851         rootdir[len - 7] = 0;
852     } else if (strcmp(".readonly", rootdir + len - 9) == 0) {
853         rootdir[len - 9] = 0;
854     }
855
856     /* Append the extension we asked for */
857     if (as->parms[2].items) {
858         strcat(rootdir, as->parms[2].items->data);      /* -extension <ext> */
859     }
860
861     /* The mountpoint root is either specifid in -mountpoint
862      * or -dir or the current working dir.
863      */
864     if ((as->parms[3].items) || (as->parms[1].items)) { /* -mountpoint  or -dir */
865         t = (char *)getcwd(thisdir, MAXPATHLEN);        /* remember current dir */
866         if (!t) {
867             fprintf(stderr,
868                     "Cannot get pathname of current working directory: %s\n",
869                     thisdir);
870             code = -1;
871             goto cleanup;
872         }
873         /* Change to the mount point dir */
874         code =
875             chdir((as->parms[3].items ? as->parms[3].items->data : as->
876                    parms[1].items->data));
877         if (code) {
878             fprintf(stderr, "Mount point directory not found: Error = %d\n",
879                     errno);
880             goto cleanup;
881         }
882         t = (char *)getcwd(mntroot, MAXPATHLEN);        /* get its full pathname */
883         if (!t) {
884             fprintf(stderr,
885                     "Cannot determine pathname of mount point root directory: %s\n",
886                     mntroot);
887             code = -1;
888             goto cleanup;
889         }
890         strcat(mntroot, "/");   /* append '/' to end of it */
891         code = chdir(thisdir);  /* return to original working dir */
892         if (code) {
893             fprintf(stderr, "Cannot find working directory: Error = %d\n",
894                     errno);
895             goto cleanup;
896         }
897     } else {                    /* use current directory */
898         t = (char *)getcwd(mntroot, MAXPATHLEN);        /* get full pathname of current dir */
899         if (!t) {
900             fprintf(stderr,
901                     "Cannot determine pathname of current working directory: %s\n",
902                     mntroot);
903             code = -1;
904             goto cleanup;
905         }
906     }
907     strcat(mntroot, "/");       /* append '/' to end of it */
908
909     /* Set the umask for the restore */
910     if (as->parms[4].items) {   /* -umask */
911         afs_int32 mask;
912         mask = strtol(as->parms[4].items->data, 0, 8);
913         fprintf(stderr, "Umask set to 0%03o\n", mask);
914         umask(mask);
915     }
916
917     fprintf(stderr, "Restoring volume dump of '%s' to directory '%s'.\n",
918             dh.volumeName, rootdir);
919     code = mkdir(rootdir, 0777);
920     if ((code < 0) && (errno != EEXIST)) {
921         fprintf(stderr, "Error creating directory %s  code=%d;%d\n", rootdir,
922                 code, errno);
923     }
924
925     for (count = 1; type == 2; count++) {
926         type = ReadVolumeHeader(count);
927         for (vcount = 1; type == 3; vcount++)
928             type = ReadVNode(vcount);
929     }
930
931     if (type != 4) {
932         fprintf(stderr, "Expected End-of-Dump\n");
933         code = -1;
934         goto cleanup;
935     }
936
937   cleanup:
938     /* For incremental restores, Follow each directory link and
939      * remove an "AFSFile" links.
940      */
941     if (inc_dump) {
942         fprintf(stderr, "An incremental dump.\n");
943         dirP = opendir(rootdir);
944         while (dirP && (dirE = readdir(dirP))) {
945             if (strncmp(dirE->d_name, ADIR, strlen(ADIR)) == 0) {
946                 afs_snprintf(name, sizeof name, "%s/%s", rootdir,
947                              dirE->d_name);
948                 dirQ = opendir(name);
949                 while (dirQ && (dirF = readdir(dirQ))) {
950                     if (strncmp(dirF->d_name, AFILE, strlen(AFILE)) == 0) {
951                         afs_snprintf(name, sizeof name, "%s/%s/%s", rootdir,
952                                      dirE->d_name, dirF->d_name);
953                         unlink(name);
954                     }
955                 }
956                 closedir(dirQ);
957             } else if (strncmp(dirE->d_name, AFILE, strlen(AFILE)) == 0) {
958                 afs_snprintf(name, sizeof name, "%s/%s", rootdir,
959                              dirE->d_name);
960                 unlink(name);
961             }
962         }
963         closedir(dirP);
964     }
965
966     /* Now go through and remove all the directory links */
967     dirP = opendir(rootdir);
968     while (dirP && (dirE = readdir(dirP))) {
969         if (strncmp(dirE->d_name, ADIR, strlen(ADIR)) == 0) {
970             afs_snprintf(name, sizeof name, "%s/%s", rootdir, dirE->d_name);
971             unlink(name);
972         }
973     }
974     closedir(dirP);
975
976     return (code);
977 }
978
979 main(argc, argv)
980      int argc;
981      char **argv;
982 {
983     struct cmd_syndesc *ts;
984     struct cmd_item *ti;
985
986     setlinebuf(stdout);
987
988     ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, "vldb check");
989     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "dump file");
990     cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "restore dir");
991     cmd_AddParm(ts, "-extension", CMD_SINGLE, CMD_OPTIONAL, "name extension");
992     cmd_AddParm(ts, "-mountpoint", CMD_SINGLE, CMD_OPTIONAL,
993                 "mount point root");
994     cmd_AddParm(ts, "-umask", CMD_SINGLE, CMD_OPTIONAL, "mode mask");
995
996     return cmd_Dispatch(argc, argv);
997 }