#include <afsconfig.h>
#include <afs/param.h>
-RCSID
- ("$Header$");
#include <afs/stds.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <sys/file.h>
-
-#ifdef HAVE_STRING_H
#include <string.h>
-#else
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
-#endif
-#include "cnvldb.h" /* CHANGEME! */
#include <netinet/in.h>
#include <afs/venus.h>
#include <afs/cmd.h>
#include <afs/fileutil.h>
#include "vlserver.h"
+#include "cnvldb.h" /* CHANGEME! */
-#define MAXSIZE 2048 /* most I'll get back from PIOCTL */
#define BADSERVERID 255 /* XXX */
-extern struct cmd_syndesc *cmd_CreateSyntax();
static char pn[] = "cnvldb";
static char tempname[] = "XXnewvldb";
-static char space[MAXSIZE];
static int MaxServers[3] = { 30, 254, 254 }; /* max server # permitted in this version */
-static afs_int32 Conv4to3();
+static afs_int32 Conv4to3(afs_uint32 addr);
-static int convert_vlentry();
-static int rewrite_header();
+static void convert_vlentry(int, int, int, struct vlheader_1 *,
+ struct vlheader_1 *, struct vlentry_1 *);
+static void rewrite_header(int, int, void *);
+static void readheader(int fd, int version, void *addr);
+static int readentry(int fd, int version, void *addr);
+static void printentry(int version, void *addr);
static char tspace[1024]; /* chdir can't handle anything bigger, anyway */
+
+void read_mhentries(afs_uint32 mh_addr, int oldfd);
+void convert_mhentries(int oldfd, int newfd, struct vlheader_2 *header, int fromver, int tover);
+
+static int convert_header(int ofd, int fd, int fromv, int tov, void *fromaddr,
+ void *toaddr);
+
/* return a static pointer to a buffer */
static char *
-Parent(apath)
- char *apath;
+Parent(const char *apath)
{
register char *tp;
strcpy(tspace, apath);
int fromvers = 0, tovers = 0, showversion = 0;
afs_uint32 mhaddr;
afs_int32 dbsize;
-char *pathname = NULL;
+const char *pathname = NULL;
const char *dbPath;
-static
-handleit(as)
- struct cmd_syndesc *as;
+static int
+handleit(struct cmd_syndesc *as, void *arock)
{
- register struct cmd_item *ti;
- register afs_int32 code;
int w, old, new, rc, dump = 0, fromv = 0;
- short uvers;
char ubik[80]; /* space for some ubik header */
union {
struct vlheader_1 header1;
struct vlheader_2 header2;
struct vlheader_3 header3;
- } oldheader, oldheader1, newheader; /* large enough for either */
+ } oldheader, newheader; /* large enough for either */
union {
struct vlentry_1 entry1;
read(old, &fromv, sizeof(int));
fromv = ntohl(fromv);
if ((fromv < 1) || (fromv > 4)) {
- fprintf(stderr, pn);
+ fprintf(stderr, "%s", pn);
fprintf(stderr, ": Unrecognized VLDB version %d.\n", fromv);
exit(-1);
}
}
if ((fromvers < 1) || (fromvers > 4)) {
- fprintf(stderr, pn);
+ fprintf(stderr, "%s", pn);
fprintf(stderr, ": VLDB version %d is not supported.\n", fromvers);
- fprintf(stderr, pn);
+ fprintf(stderr, "%s", pn);
fprintf(stderr, ": Only versions 1-4 are currently supported.\n");
exit(-1);
}
tovers = fromvers + 1;
if (tovers < 1 || tovers > 4) {
- fprintf(stderr, pn);
+ fprintf(stderr, "%s", pn);
fprintf(stderr, ": VLDB version %d is not supported.\n", tovers);
- fprintf(stderr, pn);
+ fprintf(stderr, "%s", pn);
fprintf(stderr, ": Only versions 1 - 4 are currently supported.\n");
exit(-1);
}
if (mhaddr && (tovers < 3)) {
- fprintf(stderr, pn);
+ fprintf(stderr, "%s", pn);
fprintf(stderr, ": Cannot convert. VLDB contains multihome info.\n");
exit(-1);
}
rc = readentry(old, fromvers, &xvlentry);
if ((rc == 0) || (rc == EOF))
break;
- convert_vlentry(new, fromvers, tovers, &oldheader, &newheader,
- &xvlentry);
+ convert_vlentry(new, fromvers, tovers,
+ (struct vlheader_1 *)&oldheader,
+ (struct vlheader_1 *)&newheader,
+ (struct vlentry_1 *)&xvlentry);
}
/* We have now finished sequentially reading and writing the database.
* Now randomly offset into database and update multihome entries.
*/
- convert_mhentries(old, new, &newheader, fromvers, tovers);
+ convert_mhentries(old, new, (struct vlheader_2 *)&newheader,
+ fromvers, tovers);
rewrite_header(new, tovers, &newheader);
close(old);
}
-readheader(fd, version, addr)
- int fd;
- int version;
- char *addr;
+static void
+readheader(int fd, int version, void *addr)
{
int hdrsize, size = 0;
return;
}
-readentry(fd, version, addr)
- int fd;
- int version;
- char *addr;
+static int
+readentry(int fd, int version, void *addr)
{
int rc, rc1;
struct vlentry_3 *vl3p = (struct vlentry_3 *)addr;
int toread;
+ char *caddr = (char *)addr;
toread =
((version ==
if (!mhaddr) /* Remember first mh block */
mhaddr = oldpos - rc;
- rc1 = read(fd, &addr[rc], VL_ADDREXTBLK_SIZE - rc);
+ rc1 = read(fd, &caddr[rc], VL_ADDREXTBLK_SIZE - rc);
if (rc1 != VL_ADDREXTBLK_SIZE - rc)
printf("Partial read of mhblock at pos %u: %d\n", oldpos + rc,
rc1);
return rc;
}
-printentry(version, addr)
- int version;
- char *addr;
+static void
+printentry(int version, void *addr)
{
struct vlentry_2 *vl2p = (struct vlentry_2 *)addr;
struct vlentry_3 *vl3p = (struct vlentry_3 *)addr;
printf("%s\t%5d [%10d:%10d:%10d]%8X%8d\n", vl2p->name, vl2p->spares3,
vl2p->volumeId[0], vl2p->volumeId[1], vl2p->volumeId[2],
vl2p->flags, vl2p->LockAfsId);
- printf("\t%8d%8d%8d [%7d%7d%7d]%7d% [%4d%4d%4d%4d][%4d%4d%4d%4d]\n",
+ printf("\t%8d%8d%8d [%7d%7d%7d]%7d [%4d%4d%4d%4d][%4d%4d%4d%4d]\n",
vl2p->LockTimestamp, vl2p->cloneId, vl2p->spares0,
vl2p->nextIdHash[0], vl2p->nextIdHash[1], vl2p->nextIdHash[2],
vl2p->nextNameHash, vl2p->serverNumber[0],
if (vl3p->flags == VLFREE)
return;
- printf("%s\tPos=%d NextIdHash=[%d:%d:%d] NextNameHash=%d\n",
+ printf("%s\tPos=%" AFS_SIZET_FMT " NextIdHash=[%d:%d:%d] NextNameHash=%d\n",
vl3p->name, (oldpos - sizeof(struct vlentry_3)),
vl3p->nextIdHash[0], vl3p->nextIdHash[1], vl3p->nextIdHash[2],
vl3p->nextNameHash);
* verifying their address is not pass the EOF and the flags are good.
* If it's not good, then don't read the block in.
*/
-read_mhentries(mh_addr, oldfd)
- int oldfd;
- afs_uint32 mh_addr;
+void
+read_mhentries(afs_uint32 mh_addr, int oldfd)
{
afs_uint32 sit, a;
afs_int32 code;
*
* Before this can be called, the routine read_mhentries must be called.
*/
-convert_mhentries(oldfd, newfd, header, fromver, tover)
- int oldfd, newfd;
- struct vlheader_2 *header;
- int fromver, tover;
+void
+convert_mhentries(int oldfd, int newfd, struct vlheader_2 *header,
+ int fromver, int tover)
{
- afs_uint32 sit;
afs_int32 code;
int i, j, modified = 0, w;
afs_uint32 raddr, addr;
}
-convert_header(ofd, fd, fromv, tov, fromaddr, toaddr)
- int ofd, fd, fromv, tov;
- char *fromaddr, *toaddr;
+int
+convert_header(int ofd, int fd, int fromv, int tov, void *fromaddr,
+ void *toaddr)
{
struct vlheader_1 *tvp1;
struct vlheader_2 *tvp2;
* Before this can be called, the routine read_mhentries must be called.
*/
static afs_int32
-Conv4to3(addr)
- afs_int32 addr;
+Conv4to3(afs_uint32 addr)
{
- afs_int32 raddr;
+ afs_uint32 raddr;
int i;
if (!base[0] || !addr)
* aren't any more or any larger, so they match up pretty well.
*/
-static int
-convert_vlentry(new, fromvers, tovers, oldheader, newheader, vlentryp)
- int new, fromvers, tovers;
- struct vlheader_1 *oldheader, *newheader; /* close enough */
- struct vlentry_1 *vlentryp; /* 1 and 2 are identical */
+static void
+convert_vlentry(int new, int fromvers, int tovers,
+ struct vlheader_1 *oldheader, struct vlheader_1 *newheader,
+ struct vlentry_1 *vlentryp)
{
int diff, i, s, w;
struct vlentry_3 *vl3p = (struct vlentry_3 *)vlentryp;
exit(1);
}
}
- return 0;
+ return;
}
if (fromvers == 2 && tovers == 3) {
exit(1);
}
- return 0;
+ return;
} else if (fromvers == 3 && tovers == 2) {
struct vlentry_2 vl;
struct vlentry_3 *xnvlentry = (struct vlentry_3 *)vlentryp;
- memset((char *)&vl, 0, sizeof(struct vlentry_2));
+ memset(&vl, 0, sizeof(struct vlentry_2));
vl.volumeId[0] = xnvlentry->volumeId[0];
vl.volumeId[1] = xnvlentry->volumeId[1];
vl.volumeId[2] = xnvlentry->volumeId[2];
printf("Write of entry failed %d; error %u\n", w, errno);
exit(1);
}
- return 0;
+ return;
} else if (fromvers == 3 && tovers == 1) {
struct vlentry_1 vl;
struct vlentry_3 *xnvlentry = (struct vlentry_3 *)vlentryp;
1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2))
- (fromvers ==
1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2));
- memset((char *)&vl, 0, sizeof(struct vlentry_1));
+ memset(&vl, 0, sizeof(struct vlentry_1));
vl.volumeId[0] = xnvlentry->volumeId[0];
vl.volumeId[1] = xnvlentry->volumeId[1];
vl.volumeId[2] = xnvlentry->volumeId[2];
printf("Write of entry failed %d; error %u\n", w, errno);
exit(1);
}
- return 0;
+ return;
} else if (fromvers == 4 && tovers == 3) {
struct vlentry_3 vl;
/* We are converting from version 4 to 3. In this conversion, mh info
printf("Write of entry failed %d; error %u\n", w, errno);
exit(1);
}
- return 0;
+ return;
}
if (tovers == 1) {
return;
}
-static int
-rewrite_header(new, tovers, newheader)
- int new, tovers;
- char *newheader;
+static void
+rewrite_header(int new, int tovers, void *newheader)
{
int pos, w, towrite;
#include "AFS_component_version_number.c"
-main(argc, argv)
- int argc;
- char **argv;
+int
+main(int argc, char **argv)
{
register struct cmd_syndesc *ts;
afs_int32 code;
- ts = cmd_CreateSyntax("initcmd", handleit, 0, "optional");
+ ts = cmd_CreateSyntax("initcmd", handleit, NULL, "optional");
cmd_AddParm(ts, "-to", CMD_SINGLE, CMD_OPTIONAL, "goal version");
cmd_AddParm(ts, "-from", CMD_SINGLE, CMD_OPTIONAL, "current version");
cmd_AddParm(ts, "-path", CMD_SINGLE, CMD_OPTIONAL, "pathname");
git://git.openafs.org / openafs.git / blobdiff