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