vlserver: Tidy header includes
[openafs.git] / src / vlserver / cnvldb.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 #include <afsconfig.h>
11 #include <afs/param.h>
12 #include <afs/stds.h>
13
14 #include <roken.h>
15
16 #include <sys/file.h>
17
18 #include <afs/venus.h>
19 #include <afs/cmd.h>
20 #include <afs/afsutil.h>
21 #include <afs/fileutil.h>
22
23 #include "vlserver.h"
24 #include "cnvldb.h"             /* CHANGEME! */
25
26 #define BADSERVERID     255     /* XXX */
27
28
29 static char pn[] = "cnvldb";
30 static char tempname[] = "XXnewvldb";
31 static int MaxServers[3] = { 30, 254, 254 };    /* max server # permitted in this version */
32
33 static afs_int32 Conv4to3(afs_uint32 addr);
34
35 static void convert_vlentry(int, int, int, struct vlheader_1 *,
36                             struct vlheader_1 *, struct vlentry_1 *);
37 static void rewrite_header(int, int, void *);
38 static void readheader(int fd, int version, void *addr);
39 static int readentry(int fd, int version, void *addr);
40 static void printentry(int version, void *addr);
41
42 static char tspace[1024];       /* chdir can't handle anything bigger, anyway */
43
44 void read_mhentries(afs_uint32 mh_addr, int oldfd);
45 void convert_mhentries(int oldfd, int newfd, struct vlheader_2 *header, int fromver, int tover);
46
47 static int convert_header(int ofd, int fd, int fromv, int tov, void *fromaddr,
48                           void *toaddr);
49
50 /* return a static pointer to a buffer */
51 static char *
52 Parent(const char *apath)
53 {
54     char *tp;
55     strcpy(tspace, apath);
56     tp = strrchr(tspace, '/');
57     if (tp) {
58         *tp = 0;
59     } else
60         strcpy(tspace, ".");
61     return tspace;
62 }
63
64 int oldpos = 0;
65 int fromvers = 0, tovers = 0, showversion = 0;
66 afs_uint32 mhaddr;
67 afs_int32 dbsize;
68 const char *pathname = NULL;
69 const char *dbPath;
70
71 static int
72 handleit(struct cmd_syndesc *as, void *arock)
73 {
74     int w, old, new, rc, dump = 0, fromv = 0;
75     char ubik[80];              /* space for some ubik header */
76     union {
77         struct vlheader_1 header1;
78         struct vlheader_2 header2;
79         struct vlheader_3 header3;
80     } oldheader, newheader;     /* large enough for either */
81
82     union {
83         struct vlentry_1 entry1;
84         struct vlentry_2 entry2;
85         struct vlentry_3 entry3;
86         char mhinfo_block[VL_ADDREXTBLK_SIZE];
87     } xvlentry;
88
89     pathname = (as->parms[2].items ? as->parms[2].items->data : dbPath);        /* -name */
90     showversion = (as->parms[3].items ? 1 : 0); /* -showversion */
91     dump = (as->parms[4].items ? 1 : 0);        /* -dumpvldb */
92     fromvers = (as->parms[1].items ? atoi(as->parms[1].items->data) : 0);       /* -fromversion */
93     tovers = (as->parms[0].items ? atoi(as->parms[0].items->data) : 0); /* -toversion */
94
95     /* should stat() the old vldb, get its size, and see if there's */
96     /* room for another.  It might be in AFS, so check the quota, too */
97     old = open(pathname, O_RDONLY);
98     if (old < 0) {
99         perror(pn);
100         exit(-1);
101     }
102
103     /* Read the version */
104     lseek(old, 64, L_SET);
105     read(old, &fromv, sizeof(int));
106     fromv = ntohl(fromv);
107     if ((fromv < 1) || (fromv > 4)) {
108         fprintf(stderr, "%s", pn);
109         fprintf(stderr, ": Unrecognized VLDB version %d.\n", fromv);
110         exit(-1);
111     }
112
113     /* Sequentially read the database converting the entries as we go */
114     lseek(old, 0, L_SET);
115     read(old, ubik, 64);
116     readheader(old, fromv, &oldheader);
117     if (fromv == 1) {
118         dbsize = ntohl(oldheader.header1.vital_header.eofPtr);
119         fromv = ntohl(oldheader.header1.vital_header.vldbversion);
120         mhaddr = 0;
121     } else if (fromv == 2) {
122         dbsize = ntohl(oldheader.header2.vital_header.eofPtr);
123         fromv = ntohl(oldheader.header2.vital_header.vldbversion);
124         mhaddr = 0;
125     } else {
126         int pos;
127
128         dbsize = ntohl(oldheader.header3.vital_header.eofPtr);
129         fromv = ntohl(oldheader.header3.vital_header.vldbversion);
130         mhaddr = ntohl(oldheader.header3.SIT);
131
132         /* Read the multihomed extent blocks in */
133         pos = oldpos;
134         read_mhentries(mhaddr, old);
135
136         /* Position back to this after header */
137         lseek(old, pos + 64, L_SET);
138         oldpos = pos;
139     }
140
141     if (showversion || dump) {
142         if (showversion)
143             fprintf(stdout, "%s has a version of %d\n", pathname, fromv);
144         if (dump) {
145             while (oldpos < dbsize) {
146                 rc = readentry(old, fromv, &xvlentry);
147                 if ((rc == 0) || (rc == EOF))
148                     break;
149                 printentry(fromv, &xvlentry);
150             }
151         }
152         exit(0);
153     }
154
155     if (!fromvers) {            /* not set */
156         fromvers = fromv;
157     } else if (fromvers != fromv) {
158         fprintf(stdout,
159                 "%s has a version of %d while the -fromversion specified was %d - aborting\n",
160                 pathname, fromv, fromvers);
161         exit(0);
162     }
163
164     if ((fromvers < 1) || (fromvers > 4)) {
165         fprintf(stderr, "%s", pn);
166         fprintf(stderr, ": VLDB version %d is not supported.\n", fromvers);
167         fprintf(stderr, "%s", pn);
168         fprintf(stderr, ": Only versions 1-4 are currently supported.\n");
169         exit(-1);
170     }
171
172     if (!tovers)
173         tovers = fromvers + 1;
174
175     if (tovers < 1 || tovers > 4) {
176         fprintf(stderr, "%s", pn);
177         fprintf(stderr, ": VLDB version %d is not supported.\n", tovers);
178         fprintf(stderr, "%s", pn);
179         fprintf(stderr, ": Only versions 1 - 4 are currently supported.\n");
180         exit(-1);
181     }
182
183     if (mhaddr && (tovers < 3)) {
184         fprintf(stderr, "%s", pn);
185         fprintf(stderr, ": Cannot convert. VLDB contains multihome info.\n");
186         exit(-1);
187     }
188
189     /* OK! let's get down to business... */
190
191     if (chdir(Parent(pathname))) {
192         perror(pn);
193         exit(-1);
194     }
195
196     new = open(tempname, O_WRONLY | O_CREAT | O_TRUNC, 0600);
197     if (new < 0) {
198         perror(pn);
199         exit(-1);
200     }
201
202     /* Write the UBIK data */
203     w = write(new, ubik, 64);
204     if (w != 64) {
205         printf("Write of ubik header failed %d; error %u\n", w, errno);
206         exit(1);
207     }
208
209     /* Because we know that all the vldb entries are the same size and type we
210      * can just read them sequentially, fiddle with the fields, and write
211      * them out again.  If we invent a vldb format that has different
212      * types of entries, then we're going to have to invent new logic for
213      * converting the vldb-- we'll probably have to chase down the various
214      * linked lists in turn, doing lseeks and the like.
215      */
216
217     convert_header(old, new, fromvers, tovers, &oldheader, &newheader);
218     while (oldpos < dbsize) {
219         rc = readentry(old, fromvers, &xvlentry);
220         if ((rc == 0) || (rc == EOF))
221             break;
222         convert_vlentry(new, fromvers, tovers,
223                         (struct vlheader_1 *)&oldheader,
224                         (struct vlheader_1 *)&newheader,
225                         (struct vlentry_1 *)&xvlentry);
226     }
227
228     /* We have now finished sequentially reading and writing the database.
229      * Now randomly offset into database and update multihome entries.
230      */
231     convert_mhentries(old, new, (struct vlheader_2 *)&newheader,
232                       fromvers, tovers);
233     rewrite_header(new, tovers, &newheader);
234
235     close(old);
236     if (fsync(new)) {
237         perror(pn);
238         exit(-1);
239     }
240     close(new);
241
242     renamefile(tempname, pathname);
243     sleep(5);
244     exit(0);
245 }
246
247
248 static void
249 readheader(int fd, int version, void *addr)
250 {
251     int hdrsize, size = 0;
252
253     oldpos = 0;
254     if (version == 1)
255         hdrsize = sizeof(struct vlheader_1);
256     else
257         hdrsize = sizeof(struct vlheader_2);
258
259     size = read(fd, addr, hdrsize);
260     if (size > 0)
261         oldpos += size;
262
263     return;
264 }
265
266 static int
267 readentry(int fd, int version, void *addr)
268 {
269     int rc, rc1;
270     struct vlentry_3 *vl3p = (struct vlentry_3 *)addr;
271     int toread;
272     char *caddr = (char *)addr;
273
274     toread =
275         ((version ==
276           1) ? sizeof(struct vlentry_1) : sizeof(struct vlentry_2));
277     rc = read(fd, addr, toread);
278     if (rc != toread)
279         printf("Partial read of vlentry at pos %u: %d\n", oldpos, rc);
280     if (rc > 0)
281         oldpos += rc;
282
283     /* Read a mhblock entry if there is one */
284     if ((rc > 0) && (vl3p->flags == VLCONTBLOCK)) {
285         if (!mhaddr)            /* Remember first mh block */
286             mhaddr = oldpos - rc;
287
288         rc1 = read(fd, &caddr[rc], VL_ADDREXTBLK_SIZE - rc);
289         if (rc1 != VL_ADDREXTBLK_SIZE - rc)
290             printf("Partial read of mhblock at pos %u: %d\n", oldpos + rc,
291                    rc1);
292         if (rc1 > 0) {
293             oldpos += rc1;
294             rc += rc1;
295         }
296     }
297
298     return rc;
299 }
300
301 static void
302 printentry(int version, void *addr)
303 {
304     struct vlentry_2 *vl2p = (struct vlentry_2 *)addr;
305     struct vlentry_3 *vl3p = (struct vlentry_3 *)addr;
306     int i;
307
308     /* Don't print anything if the entry is a mh info block */
309     if (vl3p->flags == VLCONTBLOCK) {
310         return;
311     }
312
313     if (version == 1 || version == 2) {
314         printf("%s\t%5d [%10d:%10d:%10d]%8X%8d\n", vl2p->name, vl2p->spares3,
315                vl2p->volumeId[0], vl2p->volumeId[1], vl2p->volumeId[2],
316                vl2p->flags, vl2p->LockAfsId);
317         printf("\t%8d%8d%8d [%7d%7d%7d]%7d [%4d%4d%4d%4d][%4d%4d%4d%4d]\n",
318                vl2p->LockTimestamp, vl2p->cloneId, vl2p->spares0,
319                vl2p->nextIdHash[0], vl2p->nextIdHash[1], vl2p->nextIdHash[2],
320                vl2p->nextNameHash, vl2p->serverNumber[0],
321                vl2p->serverNumber[1], vl2p->serverNumber[2],
322                vl2p->serverNumber[3], vl2p->serverPartition[0],
323                vl2p->serverPartition[1], vl2p->serverPartition[2],
324                vl2p->serverPartition[3]);
325         printf("\t[%4d%4d%4d%4d]\n", vl2p->serverFlags[0],
326                vl2p->serverFlags[1], vl2p->serverFlags[2],
327                vl2p->serverFlags[3]);
328     } else {                    /* if (version >= 3) */
329
330         if (vl3p->flags == VLFREE)
331             return;
332         printf("%s\tPos=%" AFS_SIZET_FMT " NextIdHash=[%d:%d:%d] NextNameHash=%d\n",
333                vl3p->name, (oldpos - sizeof(struct vlentry_3)),
334                vl3p->nextIdHash[0], vl3p->nextIdHash[1], vl3p->nextIdHash[2],
335                vl3p->nextNameHash);
336         printf("\tRW=%u RO=%u BK=%u CL=%u flags=0x%X lockBy=%d lockTime=%u\n",
337                vl3p->volumeId[0], vl3p->volumeId[1], vl3p->volumeId[2],
338                vl3p->cloneId, vl3p->flags, vl3p->LockAfsId,
339                vl3p->LockTimestamp);
340         for (i = 0; i < OMAXNSERVERS; i++) {
341             if ((vl3p->serverNumber[i] & 0xff) != 0xff) {
342                 printf("\tServer=%d Partition=%d flags=%X\n",
343                        vl3p->serverNumber[i], vl3p->serverPartition[i],
344                        vl3p->serverFlags[i]);
345             }
346         }
347     }
348     return;
349 }
350
351 int readmhentries = 0;
352 struct extentaddr *base[VL_MAX_ADDREXTBLKS];
353
354 /* Read the multihome extent blocks in. Check if they are good by
355  * verifying their address is not pass the EOF and the flags are good.
356  * If it's not good, then don't read the block in.
357  */
358 void
359 read_mhentries(afs_uint32 mh_addr, int oldfd)
360 {
361     afs_uint32 sit, a;
362     afs_int32 code;
363     int j;
364
365     if (readmhentries)
366         return;
367     readmhentries = 1;
368
369     /* Initialize base pointers */
370     for (j = 0; j < VL_MAX_ADDREXTBLKS; j++)
371         base[j] = 0;
372
373     if (!mh_addr)
374         return;
375
376     /* Check if the first extent block is beyond eof. If
377      * it is, it's not real.
378      */
379     if (mh_addr > dbsize - VL_ADDREXTBLK_SIZE)
380         return;
381
382     /* Now read the first mh extent block */
383     code = lseek(oldfd, mh_addr + 64, L_SET);
384     if (code < 0) {
385         perror("seek MH block");
386         exit(1);
387     }
388     base[0] = (struct extentaddr *)malloc(VL_ADDREXTBLK_SIZE);
389     if (!base[0]) {
390         perror("malloc1");
391         exit(1);
392     }
393     code = read(oldfd, (char *)base[0], VL_ADDREXTBLK_SIZE);
394     if (code != VL_ADDREXTBLK_SIZE) {
395         perror("read MH block");
396         free(base[0]);
397         base[0] = 0;
398         exit(1);
399     }
400
401     /* Verify that this block is the right one */
402     if (ntohl(base[0]->ex_flags) != VLCONTBLOCK) {      /* check if flag is correct */
403         free(base[0]);
404         base[0] = 0;
405         return;
406     }
407
408     /* The first block contains pointers to the other extent blocks.
409      * Check to see if the pointers are good and read them in if they are.
410      */
411     a = mh_addr;
412     for (j = 1; j < VL_MAX_ADDREXTBLKS; j++) {
413         if (!base[0]->ex_contaddrs[j])
414             continue;
415
416         sit = ntohl(base[0]->ex_contaddrs[j]);
417
418         /* Every time we allocate a new extent block, it is allocated after
419          * the previous ones. But it must be before the EOF.
420          */
421         if ((sit < (a + VL_ADDREXTBLK_SIZE))
422             || (sit > dbsize - VL_ADDREXTBLK_SIZE)) {
423             continue;
424         }
425
426         /* Read the extent block in */
427         sit += 64;
428         code = lseek(oldfd, sit, L_SET);
429         if (code < 0) {
430             perror("seek MH block");
431             exit(1);
432         }
433         base[j] = (struct extentaddr *)malloc(VL_ADDREXTBLK_SIZE);
434         if (!base[j]) {
435             perror("malloc1");
436             exit(1);
437         }
438         code = read(oldfd, (char *)base[j], VL_ADDREXTBLK_SIZE);
439         if (code != VL_ADDREXTBLK_SIZE) {
440             perror("read MH block");
441             exit(1);
442         }
443
444         /* Verify that this block knows its an extent block */
445         if (ntohl(base[j]->ex_flags) != VLCONTBLOCK) {
446             free(base[j]);
447             base[j] = 0;
448             continue;
449         }
450
451         /* The extent block passed our tests */
452         a = ntohl(base[0]->ex_contaddrs[j]);
453     }
454 }
455
456 /* Follow the SIT pointer in the header (mhaddr) to the multihomed
457  * extent blocks and verify that the pointers are good. And fix.
458  * Then convert the multihomed addresses to single address if we
459  * are converting back from version 4.
460  *
461  * Before this can be called, the routine read_mhentries must be called.
462  */
463 void
464 convert_mhentries(int oldfd, int newfd, struct vlheader_2 *header,
465                   int fromver, int tover)
466 {
467     afs_int32 code;
468     int i, j, modified = 0, w;
469     afs_uint32 raddr, addr;
470     struct extentaddr *exp;
471     int basei, index;
472
473     /* Check if the header says the extent block exists. If
474      * it does, then read_mhentries should have read it in.
475      */
476     if (mhaddr && !base[0]) {
477         printf("Fix Bad base extent block pointer\n");
478         header->SIT = mhaddr = 0;
479     } else if (mhaddr && base[0]) {
480
481         if ((ntohl(header->SIT) != mhaddr) && (tover == 4)) {
482             printf
483                 ("Fix pointer to first base extent block. Was 0x%x, now 0x%x\n",
484                  ntohl(header->SIT), mhaddr);
485             header->SIT = htonl(mhaddr);
486         }
487
488         /* Check if the first block points to itself. If not, then fix it */
489         if (ntohl(base[0]->ex_contaddrs[0]) != mhaddr) {
490             printf("Fix bad pointer in base extent block: Base 0\n");
491             base[0]->ex_contaddrs[0] = htonl(mhaddr);
492             modified = 1;
493         }
494
495         /* The first block contains pointers to the other extent blocks.
496          * Check to see if the pointers are good.
497          */
498         for (j = 1; j < VL_MAX_ADDREXTBLKS; j++) {
499             /* Check if the base extent block says the extent blocks exist.
500              * If it does, then read_mhentries should have read it in.
501              */
502             if (base[0]->ex_contaddrs[j] && !base[j]) {
503                 printf("Fix bad pointer in base extent block: Base %d\n", j);
504                 base[0]->ex_contaddrs[j] = 0;
505                 modified = 1;
506             }
507         }
508
509         /* Now write out the base extent blocks if it changed */
510         if (modified) {
511             code = lseek(newfd, mhaddr + 64, L_SET);
512             if (code < 0) {
513                 perror("seek MH Block");
514                 exit(1);
515             }
516             w = write(newfd, (char *)base[0], VL_ADDREXTBLK_SIZE);
517             if (w != VL_ADDREXTBLK_SIZE) {
518                 perror("write MH Block");
519                 exit(1);
520             }
521         }
522     }
523
524     /* If we are converting from version 4 to version 3, then
525      * translate any multihome ptrs in the IpMappedAddr array
526      * to true IP addresses.
527      */
528     if ((fromver == 4) && (tover == 3)) {
529         /* Step through the fileserver addresses in the VLDB header
530          * and convert the pointers back to IP addresses.
531          */
532         for (i = 0; i < 254; i++) {
533             addr = ntohl(header->IpMappedAddr[i]);
534             if (addr && ((addr & 0xff000000) == 0xff000000)) {
535                 basei = (addr >> 16) & 0xff;
536                 index = addr & 0xffff;
537
538                 if ((basei >= VL_ADDREXTBLK_SIZE) || !base[basei]) {
539                     fprintf(stderr,
540                             "Warning: mh entry %d has no IP address; ignored!!\n",
541                             i);
542                     header->IpMappedAddr[i] = 0;
543                     continue;
544                 }
545                 exp = &base[basei][index];
546
547                 /* For now return the first ip address back */
548                 for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
549                     if (exp->ex_addrs[j]) {
550                         raddr = ntohl(exp->ex_addrs[j]);
551                         break;
552                     }
553                 }
554                 if (j >= VL_MAXIPADDRS_PERMH) {
555                     fprintf(stderr,
556                             "Warning: mh entry %d has no ip address; ignored!!\n",
557                             i);
558                     raddr = 0;
559                 } else {
560                     printf
561                         ("Multi-homed addr: converting to single ip address %d.%d.%d.%d\n",
562                          (raddr >> 24 & 0xff), (raddr >> 16 & 0xff),
563                          (raddr >> 8 & 0xff), (raddr & 0xff));
564                 }
565                 header->IpMappedAddr[i] = htonl(raddr);
566             }
567         }
568         header->SIT = mhaddr = 0;       /* mhinfo block has been removed */
569
570         /* Now step through the hash tables in header updating them.
571          * Because we removed the mh info blocks and some entries they
572          * point to may have changed position.
573          * The VolnameHash
574          */
575         for (i = 0; i < 8191; i++) {
576             header->VolnameHash[i] = Conv4to3(header->VolnameHash[i]);
577         }
578         /* The VolidHash */
579         for (i = 0; i < 3; i++) {
580             for (j = 0; j < 8191; j++) {
581                 header->VolidHash[i][j] = Conv4to3(header->VolidHash[i][j]);
582             }
583         }
584
585         /* Update eofptr to take into account the removal of the mhinfo blocks */
586         header->vital_header.eofPtr = htonl(Conv4to3(dbsize));
587     }
588 }
589
590
591 int
592 convert_header(int ofd, int fd, int fromv, int tov, void *fromaddr,
593                void *toaddr)
594 {
595     struct vlheader_1 *tvp1;
596     struct vlheader_2 *tvp2;
597     int i, j, diff, w;
598
599     if (fromv == 1) {
600         if (tov == 1) {
601             memcpy(toaddr, fromaddr, sizeof(struct vlheader_1));
602             tvp1 = (struct vlheader_1 *)toaddr;
603
604             w = write(fd, tvp1, sizeof(struct vlheader_1));
605             if (w != sizeof(struct vlheader_1)) {
606                 printf("Write of header failed %d; error %u\n", w, errno);
607                 exit(1);
608             }
609
610             /* for garbage-collecting... */
611             for (i = 0; i < 31; i++)
612                 tvp1->IpMappedAddr[i] = 0;
613
614         } else if (tov == 2 || tov == 3) {
615             tvp1 = (struct vlheader_1 *)fromaddr;
616             tvp2 = (struct vlheader_2 *)toaddr;
617             memset(tvp2, 0, sizeof(struct vlheader_2));
618             tvp2->vital_header.vldbversion = htonl(tov);
619             tvp2->vital_header.headersize = htonl(sizeof(struct vlheader_2));
620             diff =
621                 ntohl(tvp2->vital_header.headersize) -
622                 ntohl(tvp1->vital_header.headersize);
623             if (ntohl(tvp1->vital_header.freePtr))
624                 tvp2->vital_header.freePtr =
625                     htonl(ntohl(tvp1->vital_header.freePtr) + diff);
626             if (ntohl(tvp1->vital_header.eofPtr))
627                 tvp2->vital_header.eofPtr =
628                     htonl(ntohl(tvp1->vital_header.eofPtr) + diff);
629             tvp2->vital_header.allocs = tvp1->vital_header.allocs;
630             tvp2->vital_header.frees = tvp1->vital_header.frees;
631             tvp2->vital_header.MaxVolumeId = tvp1->vital_header.MaxVolumeId;
632             for (i = 0; i < 3; i++)
633                 tvp2->vital_header.totalEntries[i] =
634                     tvp1->vital_header.totalEntries[i];
635
636             for (i = 0; i < 31; i++)
637                 tvp2->IpMappedAddr[i] = tvp1->IpMappedAddr[i];
638
639             for (i = 0; i < 8191; i++) {
640                 if (ntohl(tvp1->VolnameHash[i]))
641                     tvp2->VolnameHash[i] =
642                         htonl(ntohl(tvp1->VolnameHash[i]) + diff);
643             }
644
645             for (i = 0; i < 3; i++) {
646                 for (j = 0; j < 8191; j++) {
647                     if (ntohl(tvp1->VolidHash[i][j]))
648                         tvp2->VolidHash[i][j] =
649                             htonl(ntohl(tvp1->VolidHash[i][j]) + diff);
650                 }
651             }
652
653             w = write(fd, tvp2, sizeof(struct vlheader_2));
654             if (w != sizeof(struct vlheader_2)) {
655                 printf("Write of header failed %d; error %u\n", w, errno);
656                 exit(1);
657             }
658
659             /* for garbage-collecting... */
660             for (i = 0; i < 31; i++)
661                 tvp2->IpMappedAddr[i] = 0;
662         } else
663             return EINVAL;
664     } else if (fromv == 2 || fromv == 3 || fromv == 4) {
665         if (tov == 2 || tov == 3 || tov == 4) {
666             memcpy(toaddr, fromaddr, sizeof(struct vlheader_2));
667             tvp2 = (struct vlheader_2 *)toaddr;
668             tvp2->vital_header.vldbversion = htonl(tov);
669             w = write(fd, tvp2, sizeof(struct vlheader_2));
670             if (w != sizeof(struct vlheader_2)) {
671                 printf("Write of header failed %d; error %u\n", w, errno);
672                 exit(1);
673             }
674
675         } else if (tov == 1) {
676             tvp2 = (struct vlheader_2 *)fromaddr;
677             tvp1 = (struct vlheader_1 *)toaddr;
678             memset(tvp1, 0, sizeof(struct vlheader_1));
679             tvp1->vital_header.vldbversion = htonl(1);
680             tvp1->vital_header.headersize = htonl(sizeof(struct vlheader_1));
681             diff =
682                 ntohl(tvp1->vital_header.headersize) -
683                 ntohl(tvp2->vital_header.headersize);
684             if (ntohl(tvp2->vital_header.freePtr))
685                 tvp1->vital_header.freePtr =
686                     htonl(ntohl(tvp2->vital_header.freePtr) + diff);
687             if (ntohl(tvp2->vital_header.eofPtr))
688                 tvp1->vital_header.eofPtr =
689                     htonl(ntohl(tvp2->vital_header.eofPtr) + diff);
690             tvp1->vital_header.allocs = tvp2->vital_header.allocs;
691             tvp1->vital_header.frees = tvp2->vital_header.frees;
692             tvp1->vital_header.MaxVolumeId = tvp2->vital_header.MaxVolumeId;
693             for (i = 0; i < 3; i++)
694                 tvp1->vital_header.totalEntries[i] =
695                     tvp2->vital_header.totalEntries[i];
696
697             for (i = 0; i < 31; i++)
698                 tvp1->IpMappedAddr[i] = tvp2->IpMappedAddr[i];
699
700             for (i = 0; i < 8191; i++) {
701                 if (ntohl(tvp2->VolnameHash[i]))
702                     tvp1->VolnameHash[i] =
703                         htonl(ntohl(tvp2->VolnameHash[i]) + diff);
704             }
705
706             for (i = 0; i < 3; i++) {
707                 for (j = 0; j < 8191; j++) {
708                     if (ntohl(tvp2->VolidHash[i][j]))
709                         tvp1->VolidHash[i][j] =
710                             htonl(ntohl(tvp2->VolidHash[i][j]) + diff);
711                 }
712             }
713
714             w = write(fd, tvp1, sizeof(struct vlheader_1));
715             if (w != sizeof(struct vlheader_2)) {
716                 printf("Write of header failed %d; error %u\n", w, errno);
717                 exit(1);
718             }
719
720             /* for garbage-collecting... */
721             for (i = 0; i < 31; i++)
722                 tvp1->IpMappedAddr[i] = 0;
723         } else
724             return EINVAL;
725     } else
726         return EINVAL;
727     return 0;
728 }
729
730
731 /* Convert an address pointer to a vlentry from version 4 to version 3.
732  * This involves checking if the address is after any of the four
733  * MH block and if it is, subtract the size of the MH block.
734  *
735  * In going from version 4 to 3, the mh blocks go away and all entries
736  * move up in their place. The adresses then need to be updated.
737  *
738  * Before this can be called, the routine read_mhentries must be called.
739  */
740 static afs_int32
741 Conv4to3(afs_uint32 addr)
742 {
743     afs_uint32 raddr;
744     int i;
745
746     if (!base[0] || !addr)
747         return (addr);
748
749     raddr = addr;
750     for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
751         if (base[i] && base[0]->ex_contaddrs[i]
752             && (addr > base[0]->ex_contaddrs[i]))
753             raddr -= VL_ADDREXTBLK_SIZE;
754     }
755
756     return (raddr);
757 }
758
759 /* this only works because the vlheader struct is essentially the same
760  * from version 1 to version 2 -- that is, the first bunch of fields
761  * aren't any more or any larger, so they match up pretty well.
762 */
763
764 static void
765 convert_vlentry(int new, int fromvers, int tovers,
766                 struct vlheader_1 *oldheader, struct vlheader_1 *newheader,
767                 struct vlentry_1 *vlentryp)
768 {
769     int diff, i, s, w;
770     struct vlentry_3 *vl3p = (struct vlentry_3 *)vlentryp;
771
772     /* For mh information blocks,
773      * If going to version 4 or greater, keep the mh info block.
774      * Otherwise, don't keep it (version 3 and earlier don't have them).
775      */
776     if (vl3p->flags == VLCONTBLOCK) {
777         if (tovers >= 4) {
778             w = write(new, vlentryp, VL_ADDREXTBLK_SIZE);
779             if (w != VL_ADDREXTBLK_SIZE) {
780                 printf("Write of mh info block failed %d; error %u\n", w,
781                        errno);
782                 exit(1);
783             }
784         }
785         return;
786     }
787
788     if (fromvers == 2 && tovers == 3) {
789         struct vlentry_3 vl;
790
791         vl.volumeId[0] = vlentryp->volumeId[0];
792         vl.volumeId[1] = vlentryp->volumeId[1];
793         vl.volumeId[2] = vlentryp->volumeId[2];
794         vl.flags = vlentryp->flags;
795         vl.LockAfsId = vlentryp->LockAfsId;
796         vl.LockTimestamp = vlentryp->LockTimestamp;
797         vl.cloneId = vlentryp->cloneId;
798         vl.nextIdHash[0] = vlentryp->nextIdHash[0];
799         vl.nextIdHash[1] = vlentryp->nextIdHash[1];
800         vl.nextIdHash[2] = vlentryp->nextIdHash[2];
801         vl.nextNameHash = vlentryp->nextNameHash;
802         memcpy(vl.name, vlentryp->name, 65);
803         for (i = 0; i < 8; i++) {
804             vl.serverNumber[i] = vlentryp->serverNumber[i];
805             vl.serverPartition[i] = vlentryp->serverPartition[i];
806             vl.serverFlags[i] = vlentryp->serverFlags[i];
807         }
808         for (; i < 13; i++)
809             vl.serverNumber[i] = vl.serverPartition[i] = vl.serverFlags[i] =
810                 BADSERVERID;
811         w = write(new, &vl, sizeof(struct vlentry_3));
812         if (w != sizeof(struct vlentry_3)) {
813             printf("Write of entry failed %d; error %u\n", w, errno);
814             exit(1);
815         }
816
817         return;
818     } else if (fromvers == 3 && tovers == 2) {
819         struct vlentry_2 vl;
820         struct vlentry_3 *xnvlentry = (struct vlentry_3 *)vlentryp;
821
822         memset(&vl, 0, sizeof(struct vlentry_2));
823         vl.volumeId[0] = xnvlentry->volumeId[0];
824         vl.volumeId[1] = xnvlentry->volumeId[1];
825         vl.volumeId[2] = xnvlentry->volumeId[2];
826         vl.flags = xnvlentry->flags;
827         vl.LockAfsId = xnvlentry->LockAfsId;
828         vl.LockTimestamp = xnvlentry->LockTimestamp;
829         vl.cloneId = xnvlentry->cloneId;
830         for (i = 0; i < 3; i++) {
831             if (ntohl(xnvlentry->nextIdHash[i]))
832                 vl.nextIdHash[i] = xnvlentry->nextIdHash[i];
833         }
834         if (ntohl(xnvlentry->nextNameHash))
835             vl.nextNameHash = xnvlentry->nextNameHash;
836         memcpy(vl.name, xnvlentry->name, 65);
837         for (i = 0; i < 8; i++) {
838             vl.serverNumber[i] = xnvlentry->serverNumber[i];
839             vl.serverPartition[i] = xnvlentry->serverPartition[i];
840             vl.serverFlags[i] = xnvlentry->serverFlags[i];
841         }
842         w = write(new, &vl, sizeof(struct vlentry_2));
843         if (w != sizeof(struct vlentry_2)) {
844             printf("Write of entry failed %d; error %u\n", w, errno);
845             exit(1);
846         }
847         return;
848     } else if (fromvers == 3 && tovers == 1) {
849         struct vlentry_1 vl;
850         struct vlentry_3 *xnvlentry = (struct vlentry_3 *)vlentryp;
851
852         diff =
853             (tovers ==
854              1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2))
855             - (fromvers ==
856                1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2));
857         memset(&vl, 0, sizeof(struct vlentry_1));
858         vl.volumeId[0] = xnvlentry->volumeId[0];
859         vl.volumeId[1] = xnvlentry->volumeId[1];
860         vl.volumeId[2] = xnvlentry->volumeId[2];
861         vl.flags = xnvlentry->flags;
862         vl.LockAfsId = xnvlentry->LockAfsId;
863         vl.LockTimestamp = xnvlentry->LockTimestamp;
864         vl.cloneId = xnvlentry->cloneId;
865         for (i = 0; i < 3; i++) {
866             if (ntohl(xnvlentry->nextIdHash[i]))
867                 vl.nextIdHash[i] =
868                     htonl(ntohl(xnvlentry->nextIdHash[i]) + diff);
869         }
870         if (ntohl(xnvlentry->nextNameHash))
871             vl.nextNameHash = htonl(ntohl(xnvlentry->nextNameHash) + diff);
872
873         memcpy(vl.name, xnvlentry->name, 65);
874         for (i = 0; i < 8; i++) {
875             vl.serverNumber[i] = xnvlentry->serverNumber[i];
876             vl.serverPartition[i] = xnvlentry->serverPartition[i];
877             vl.serverFlags[i] = xnvlentry->serverFlags[i];
878         }
879         for (i = 0; i < 8; i++) {
880             s = xnvlentry->serverNumber[i];
881             if (s != 255) {
882                 if (s > MaxServers[tovers - 1]) {
883                     fprintf(stderr,
884                             "%s: Too Many Servers (%d) for this version!\n",
885                             pn, s + 1);
886                     exit(-1);
887                 } else
888                     newheader->IpMappedAddr[s] = oldheader->IpMappedAddr[s];
889             }
890         }
891         w = write(new, &vl, sizeof(struct vlentry_1));
892         if (w != sizeof(struct vlentry_1)) {
893             printf("Write of entry failed %d; error %u\n", w, errno);
894             exit(1);
895         }
896         return;
897     } else if (fromvers == 4 && tovers == 3) {
898         struct vlentry_3 vl;
899         /* We are converting from version 4 to 3. In this conversion, mh info
900          * blocks go away and all vlentries after them move up in the vldb file.
901          * When this happens, the linked list pointers need to be updated.
902          */
903         memcpy(&vl, vlentryp, sizeof(vl));
904         for (i = 0; i < 3; i++) {
905             vl.nextIdHash[i] = Conv4to3(vl.nextIdHash[i]);
906         }
907         vl.nextNameHash = Conv4to3(vl.nextNameHash);
908
909         w = write(new, &vl, sizeof(vl));
910         if (w != sizeof(vl)) {
911             printf("Write of entry failed %d; error %u\n", w, errno);
912             exit(1);
913         }
914         return;
915     }
916
917     if (tovers == 1) {
918         w = write(new, vlentryp, sizeof(struct vlentry_1));
919         if (w != sizeof(struct vlentry_1)) {
920             printf("Write of entry failed %d; error %u\n", w, errno);
921             exit(1);
922         }
923     } else if (tovers == 2) {
924         w = write(new, vlentryp, sizeof(struct vlentry_2));
925         if (w != sizeof(struct vlentry_2)) {
926             printf("Write of entry failed %d; error %u\n", w, errno);
927             exit(1);
928         }
929     } else if (tovers == 3 || tovers == 4) {
930         w = write(new, vlentryp, sizeof(struct vlentry_3));
931         if (w != sizeof(struct vlentry_3)) {
932             printf("Write of entry failed %d; error %u\n", w, errno);
933             exit(1);
934         }
935     } else {
936         perror(pn);
937         fprintf(stderr,
938                 "Skipping vlentry write - db corrupted - bad toversion %d\n",
939                 tovers);
940     }
941
942     return;
943 }
944
945 static void
946 rewrite_header(int new, int tovers, void *newheader)
947 {
948     int pos, w, towrite;
949
950     pos = lseek(new, 64, L_SET);        /* leave room for ubik */
951     if (pos == -1) {
952         perror(pn);
953         fprintf(stderr, "%s: no garbage colection\n", pn);
954         return;
955     } else if (pos != 64) {
956         fprintf(stderr, "%s: Can't rewind: no garbage collection\n", pn);
957         return;
958     }
959
960     towrite =
961         ((tovers ==
962           1) ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2));
963     w = write(new, newheader, towrite);
964     if (w != towrite) {
965         printf("Write of entry failed %d; error %u\n", w, errno);
966         exit(1);
967     }
968
969     return;
970 }
971
972
973 #include "AFS_component_version_number.c"
974
975 int
976 main(int argc, char **argv)
977 {
978     struct cmd_syndesc *ts;
979     afs_int32 code;
980
981     ts = cmd_CreateSyntax("initcmd", handleit, NULL, "optional");
982     cmd_AddParm(ts, "-to", CMD_SINGLE, CMD_OPTIONAL, "goal version");
983     cmd_AddParm(ts, "-from", CMD_SINGLE, CMD_OPTIONAL, "current version");
984     cmd_AddParm(ts, "-path", CMD_SINGLE, CMD_OPTIONAL, "pathname");
985     cmd_AddParm(ts, "-showversion", CMD_FLAG, CMD_OPTIONAL,
986                 "Just display version of current vldb");
987     cmd_AddParm(ts, "-dumpvldb", CMD_FLAG, CMD_OPTIONAL,
988                 "display all vldb entries");
989
990 #ifdef DEBUG
991     cmd_AddParm(ts, "-noGC", CMD_FLAG, CMD_OPTIONAL,
992                 "Don't do garbage collection");
993 #endif /* DEBUG */
994
995     dbPath = AFSDIR_SERVER_VLDB_FILEPATH;
996
997     code = cmd_Dispatch(argc, argv);
998     exit(code);
999 }