memset(nentryp, 0, sizeof(struct nvldbentry));
strncpy(nentryp->name, oentryp->name, sizeof(nentryp->name));
for (i = 0; i < oentryp->nServers; i++) {
- nentryp->serverNumber[i] = oentryp->serverNumber[i];
+ bulkaddrs m_addrs;
+ ListAddrByAttributes m_attrs;
+ afs_int32 m_nentries;
+
+ m_attrs.Mask = VLADDR_IPADDR;
+ m_attrs.ipaddr = oentryp->serverNumber[i];
+ m_nentries = 0;
+ m_addrs.bulkaddrs_val = 0;
+ m_addrs.bulkaddrs_len = 0;
+ nentryp->serverNumber[i] = oentryp->serverNumber[i];
nentryp->serverPartition[i] = oentryp->serverPartition[i];
nentryp->serverFlags[i] = oentryp->serverFlags[i];
}
nentryp->flags = oentryp->flags;
}
+#if 0
+/* It is here for when we need it. Not currently used. */
static int
nvlentry_to_ovlentry(struct nvldbentry *nentryp,
struct vldbentry *oentryp)
oentryp->flags = nentryp->flags;
return 0;
}
+#endif
+
+static void
+ovlentry_to_uvlentry(struct vldbentry *oentryp,
+ struct uvldbentry *uentryp)
+{
+ int i;
+
+ memset(uentryp, 0, sizeof(struct uvldbentry));
+ strncpy(uentryp->name, oentryp->name, sizeof(uentryp->name));
+ for (i = 0; i < oentryp->nServers; i++) {
+ afs_int32 vcode, m_uniq=0;
+ bulkaddrs m_addrs;
+ ListAddrByAttributes m_attrs;
+ afs_int32 m_nentries;
+
+ m_attrs.Mask = VLADDR_IPADDR;
+ m_attrs.ipaddr = oentryp->serverNumber[i];
+ m_nentries = 0;
+ m_addrs.bulkaddrs_val = 0;
+ m_addrs.bulkaddrs_len = 0;
+ vcode =
+ ubik_VL_GetAddrsU(cstruct, 0, &m_attrs,
+ &uentryp->serverNumber[i],
+ &m_uniq, &m_nentries,
+ &m_addrs);
+ uentryp->serverUnique[i] = oentryp->serverNumber[i];
+ uentryp->serverPartition[i] = oentryp->serverPartition[i];
+ uentryp->serverFlags[i] = oentryp->serverFlags[i];
+ }
+ uentryp->nServers = oentryp->nServers;
+ for (i = 0; i < MAXTYPES; i++)
+ uentryp->volumeId[i] = oentryp->volumeId[i];
+ uentryp->cloneId = oentryp->cloneId;
+ uentryp->flags = oentryp->flags;
+}
+
+static int
+uvlentry_to_ovlentry(struct uvldbentry *uentryp,
+ struct vldbentry *oentryp)
+{
+ int i;
+
+ memset(oentryp, 0, sizeof(struct vldbentry));
+ strncpy(oentryp->name, uentryp->name, sizeof(oentryp->name));
+ if (uentryp->nServers > OMAXNSERVERS) {
+ /*
+ * The alternative is to store OMAXSERVERS but it's always better
+ * to know what's going on...
+ */
+ return VL_BADSERVER;
+ }
+ for (i = 0; i < uentryp->nServers; i++) {
+ oentryp->serverNumber[i] = uentryp->serverUnique[i];
+ oentryp->serverPartition[i] = uentryp->serverPartition[i];
+ oentryp->serverFlags[i] = uentryp->serverFlags[i];
+ }
+ oentryp->nServers = i;
+ for (i = 0; i < MAXTYPES; i++)
+ oentryp->volumeId[i] = uentryp->volumeId[i];
+ oentryp->cloneId = uentryp->cloneId;
+ oentryp->flags = uentryp->flags;
+ return 0;
+}
+
+void
+nvlentry_to_uvlentry(struct nvldbentry *nentryp,
+ struct uvldbentry *uentryp)
+{
+ int i;
-static int newvlserver = 0;
+ memset(uentryp, 0, sizeof(struct uvldbentry));
+ strncpy(uentryp->name, nentryp->name, sizeof(uentryp->name));
+ for (i = 0; i < nentryp->nServers; i++) {
+ afs_int32 vcode, m_uniq=0;
+ bulkaddrs m_addrs;
+ ListAddrByAttributes m_attrs;
+ afs_int32 m_nentries;
+
+ m_attrs.Mask = VLADDR_IPADDR;
+ m_attrs.ipaddr = nentryp->serverNumber[i];
+ m_nentries = 0;
+ m_addrs.bulkaddrs_val = 0;
+ m_addrs.bulkaddrs_len = 0;
+ vcode =
+ ubik_VL_GetAddrsU(cstruct, 0, &m_attrs,
+ &uentryp->serverNumber[i],
+ &m_uniq, &m_nentries,
+ &m_addrs);
+ uentryp->serverUnique[i] = nentryp->serverNumber[i];
+ uentryp->serverPartition[i] = nentryp->serverPartition[i];
+ uentryp->serverFlags[i] = nentryp->serverFlags[i];
+ }
+ uentryp->nServers = nentryp->nServers;
+ for (i = 0; i < MAXTYPES; i++)
+ uentryp->volumeId[i] = nentryp->volumeId[i];
+ uentryp->cloneId = nentryp->cloneId;
+ uentryp->flags = nentryp->flags;
+ uentryp->matchindex = nentryp->matchindex;
+}
+
+int
+uvlentry_to_nvlentry(struct uvldbentry *uentryp,
+ struct nvldbentry *nentryp)
+{
+ int i;
+
+ memset(nentryp, 0, sizeof(struct vldbentry));
+ strncpy(nentryp->name, uentryp->name, sizeof(nentryp->name));
+ if (uentryp->nServers > NMAXNSERVERS) {
+ /*
+ * The alternative is to store NMAXSERVERS but it's always better
+ * to know what's going on...
+ */
+ return VL_BADSERVER;
+ }
+ for (i = 0; i < uentryp->nServers; i++) {
+ nentryp->serverNumber[i] = uentryp->serverUnique[i];
+ nentryp->serverPartition[i] = uentryp->serverPartition[i];
+ nentryp->serverFlags[i] = uentryp->serverFlags[i];
+ }
+ nentryp->nServers = i;
+ for (i = 0; i < MAXTYPES; i++)
+ nentryp->volumeId[i] = uentryp->volumeId[i];
+ nentryp->cloneId = uentryp->cloneId;
+ nentryp->flags = uentryp->flags;
+ nentryp->matchindex = uentryp->matchindex;
+ return 0;
+}
+
+enum _vlserver_type {
+ vltype_unknown = 0,
+ vltype_old = 1,
+ vltype_new = 2,
+ vltype_uuid = 3
+};
+
+static enum _vlserver_type newvlserver = vltype_unknown;
int
VLDB_CreateEntry(struct nvldbentry *entryp)
{
- struct vldbentry oentry;
int code;
+ struct uvldbentry uentry;
- if (newvlserver == 1) {
+ nvlentry_to_uvlentry(entryp, &uentry);
+ code = VLDB_CreateEntryU(&uentry);
+ if (!code)
+ code = uvlentry_to_nvlentry(&uentry, entryp);
+ return code;
+}
+
+int
+VLDB_CreateEntryU(struct uvldbentry *entryp)
+{
+ struct nvldbentry nentry;
+ int code;
+
+ if (newvlserver == vltype_old) {
+ struct vldbentry oentry;
tryold:
- code = nvlentry_to_ovlentry(entryp, &oentry);
+ code = uvlentry_to_ovlentry(entryp, &oentry);
if (code)
return code;
code = ubik_VL_CreateEntry(cstruct, 0, &oentry);
return code;
}
- code = ubik_VL_CreateEntryN(cstruct, 0, entryp);
- if (!newvlserver) {
- if (code == RXGEN_OPCODE) {
- newvlserver = 1; /* Doesn't support new interface */
- goto tryold;
- } else if (!code) {
- newvlserver = 2;
- }
+
+ code = uvlentry_to_nvlentry(entryp, &nentry);
+ if (code)
+ return code;
+ code = ubik_VL_CreateEntryN(cstruct, 0, &nentry);
+ if (code == RXGEN_OPCODE) {
+ newvlserver = vltype_old;
+ goto tryold;
}
return code;
}
int
VLDB_GetEntryByID(afs_uint32 volid, afs_int32 voltype, struct nvldbentry *entryp)
{
- struct vldbentry oentry;
+ int code;
+ struct uvldbentry uentry;
+
+ nvlentry_to_uvlentry(entryp, &uentry);
+ code = VLDB_GetEntryByIDU(volid, voltype, &uentry);
+ if (!code)
+ code = uvlentry_to_nvlentry(&uentry, entryp);
+ return code;
+}
+
+int
+VLDB_GetEntryByIDU(afs_uint32 volid, afs_int32 voltype, struct uvldbentry *entryp)
+{
+ struct nvldbentry nentry;
int code;
- if (newvlserver == 1) {
+ if (newvlserver == vltype_old) {
+ struct vldbentry oentry;
tryold:
code =
ubik_VL_GetEntryByID(cstruct, 0, volid, voltype, &oentry);
if (!code)
- ovlentry_to_nvlentry(&oentry, entryp);
+ ovlentry_to_uvlentry(&oentry, entryp);
return code;
}
- code = ubik_VL_GetEntryByIDN(cstruct, 0, volid, voltype, entryp);
- if (!newvlserver) {
- if (code == RXGEN_OPCODE) {
- newvlserver = 1; /* Doesn't support new interface */
- goto tryold;
- } else if (!code) {
- newvlserver = 2;
- }
+
+ code = ubik_VL_GetEntryByIDN(cstruct, 0, volid, voltype, &nentry);
+ if (code == RXGEN_OPCODE) {
+ newvlserver = vltype_old;
+ goto tryold;
}
+ if (!code)
+ nvlentry_to_uvlentry(&nentry, entryp);
return code;
}
int
VLDB_GetEntryByName(char *namep, struct nvldbentry *entryp)
{
- struct vldbentry oentry;
+ int code;
+ struct uvldbentry uentry;
+
+ nvlentry_to_uvlentry(entryp, &uentry);
+ code = VLDB_GetEntryByNameU(namep, &uentry);
+ if (!code)
+ code = uvlentry_to_nvlentry(&uentry, entryp);
+ return code;
+}
+
+int
+VLDB_GetEntryByNameU(char *namep, struct uvldbentry *entryp)
+{
int code;
- if (newvlserver == 1) {
+ if (newvlserver == vltype_old) {
+ struct vldbentry oentry;
tryold:
code = ubik_VL_GetEntryByNameO(cstruct, 0, namep, &oentry);
if (!code)
- ovlentry_to_nvlentry(&oentry, entryp);
+ ovlentry_to_uvlentry(&oentry, entryp);
return code;
}
- code = ubik_VL_GetEntryByNameN(cstruct, 0, namep, entryp);
- if (!newvlserver) {
+ if (newvlserver == vltype_new) {
+ struct nvldbentry nentry;
+ trynew:
+ code = ubik_VL_GetEntryByNameN(cstruct, 0, namep, &nentry);
+ if (code == RXGEN_OPCODE) {
+ newvlserver = vltype_old;
+ goto tryold;
+ }
+ if (!code)
+ nvlentry_to_uvlentry(&nentry, entryp);
+ }
+ code = ubik_VL_GetEntryByNameU(cstruct, 0, namep, entryp);
+ if (newvlserver == vltype_unknown) {
if (code == RXGEN_OPCODE) {
- newvlserver = 1; /* Doesn't support new interface */
- goto tryold;
+ newvlserver = vltype_new;
+ goto trynew;
} else if (!code) {
- newvlserver = 2;
+ newvlserver = vltype_uuid;
}
}
return code;
}
int
-VLDB_ReplaceEntry(afs_uint32 volid, afs_int32 voltype, struct nvldbentry *entryp, afs_int32 releasetype)
+VLDB_ReplaceEntry(afs_uint32 volid, afs_int32 voltype, struct nvldbentry *nentryp, afs_int32 releasetype)
+{
+ struct uvldbentry uentry;
+ int code;
+
+ nvlentry_to_uvlentry(nentryp, &uentry);
+ code = VLDB_ReplaceEntryU(volid, voltype, &uentry, releasetype);
+ if (!code)
+ code = uvlentry_to_nvlentry(&uentry, nentryp);
+
+ return code;
+}
+
+int
+VLDB_ReplaceEntryU(afs_uint32 volid, afs_int32 voltype, struct uvldbentry *entryp, afs_int32 releasetype)
{
- struct vldbentry oentry;
int code;
+ struct nvldbentry nentry;
- if (newvlserver == 1) {
+ if (newvlserver == vltype_old) {
+ struct vldbentry oentry;
tryold:
- code = nvlentry_to_ovlentry(entryp, &oentry);
+ code = uvlentry_to_ovlentry(entryp, &oentry);
if (code)
return code;
code =
- ubik_VL_ReplaceEntry(cstruct, 0, volid, voltype, &oentry,
- releasetype);
+ ubik_VL_ReplaceEntry(cstruct, 0, volid, voltype, &oentry, releasetype);
return code;
}
- code =
- ubik_VL_ReplaceEntryN(cstruct, 0, volid, voltype, entryp,
- releasetype);
- if (!newvlserver) {
- if (code == RXGEN_OPCODE) {
- newvlserver = 1; /* Doesn't support new interface */
- goto tryold;
- } else if (!code) {
- newvlserver = 2;
- }
+ code = uvlentry_to_nvlentry(entryp, &nentry);
+ if (code)
+ return code;
+ code = ubik_VL_ReplaceEntryN(cstruct, 0, volid, voltype, &nentry, releasetype);
+ if (code == RXGEN_OPCODE) {
+ newvlserver = vltype_old;
+ goto tryold;
}
return code;
}
afs_int32 *entriesp,
nbulkentries *blkentriesp)
{
- bulkentries arrayEntries;
- int code, i;
+ int code;
- if (newvlserver == 1) {
+ if (newvlserver == vltype_old) {
+ int i;
+ bulkentries arrayEntries;
tryold:
memset(&arrayEntries, 0, sizeof(arrayEntries)); /*initialize to hint the stub to alloc space */
code =
&arrayEntries);
if (!code) {
blkentriesp->nbulkentries_val =
- (nvldbentry *) malloc(*entriesp * sizeof(struct nvldbentry));
+ (nvldbentry *) xdr_alloc(*entriesp * sizeof(struct nvldbentry));
for (i = 0; i < *entriesp; i++) { /* process each entry */
ovlentry_to_nvlentry(&arrayEntries.bulkentries_val[i],
&blkentriesp->nbulkentries_val[i]);
}
}
if (arrayEntries.bulkentries_val)
- free(arrayEntries.bulkentries_val);
+ xdr_free((xdrproc_t) xdr_bulkentries, &arrayEntries);
return code;
}
+
code =
- ubik_VL_ListAttributesN(cstruct, 0, attrp, entriesp,
- blkentriesp);
- if (!newvlserver) {
- if (code == RXGEN_OPCODE) {
- newvlserver = 1; /* Doesn't support new interface */
- goto tryold;
- } else if (!code) {
- newvlserver = 2;
+ ubik_VL_ListAttributesN(cstruct, 0, attrp, entriesp, blkentriesp);
+ if (code == RXGEN_OPCODE) {
+ newvlserver = vltype_old; /* Doesn't support new interface */
+ goto tryold;
+ }
+ return code;
+}
+
+int
+VLDB_ListAttributesU(VldbListByAttributes *attrp,
+ afs_int32 *entriesp,
+ ubulkentries *blkentriesp)
+{
+ nbulkentries narrayEntries;
+ int code, i;
+
+ if (newvlserver == vltype_old) {
+ bulkentries arrayEntries;
+ tryold:
+ memset(&arrayEntries, 0, sizeof(arrayEntries)); /*initialize to hint the stub to alloc space */
+ code =
+ ubik_VL_ListAttributes(cstruct, 0, attrp, entriesp,
+ &arrayEntries);
+ if (!code) {
+ blkentriesp->ubulkentries_val =
+ (uvldbentry *) xdr_alloc(*entriesp * sizeof(struct uvldbentry));
+ for (i = 0; i < *entriesp; i++) { /* process each entry */
+ ovlentry_to_uvlentry(&arrayEntries.bulkentries_val[i],
+ &blkentriesp->ubulkentries_val[i]);
+ }
}
+ if (arrayEntries.bulkentries_val)
+ xdr_free((xdrproc_t) xdr_bulkentries, &arrayEntries);
+ return code;
+ }
+
+ memset(&narrayEntries, 0, sizeof(narrayEntries)); /*initialize to hint the stub to alloc space */
+ code =
+ ubik_VL_ListAttributesN(cstruct, 0, attrp, entriesp, &narrayEntries);
+ if (code == RXGEN_OPCODE) {
+ newvlserver = vltype_old; /* Doesn't support new interface */
+ goto tryold;
+ }
+ if (!code) {
+ blkentriesp->ubulkentries_val =
+ (uvldbentry *) xdr_alloc(*entriesp * sizeof(struct uvldbentry));
+ for (i = 0; i < *entriesp; i++) { /* process each entry */
+ nvlentry_to_uvlentry(&narrayEntries.nbulkentries_val[i],
+ &blkentriesp->ubulkentries_val[i]);
+ }
}
+ if (narrayEntries.nbulkentries_val)
+ xdr_free((xdrproc_t) xdr_bulkentries, &narrayEntries);
return code;
}
nbulkentries *blkentriesp,
afs_int32 *nextindexp)
{
- afs_int32 code;
+ afs_int32 code = RXGEN_OPCODE;
- code =
- ubik_VL_ListAttributesN2(cstruct, 0, attrp, (name ? name : ""),
- thisindex, nentriesp, blkentriesp, nextindexp);
+ if (newvlserver != vltype_old) {
+ code =
+ ubik_VL_ListAttributesN2(cstruct, 0, attrp, (name ? name : ""),
+ thisindex, nentriesp, blkentriesp, nextindexp);
+ }
+ return code;
+}
+
+int
+VLDB_ListAttributesN2U(VldbListByAttributes *attrp,
+ char *name,
+ afs_int32 thisindex,
+ afs_int32 *nentriesp,
+ ubulkentries *blkentriesp,
+ afs_int32 *nextindexp)
+{
+ afs_int32 code = RXGEN_OPCODE;
+ int i;
+
+ if (newvlserver != vltype_old) {
+ nbulkentries narrayEntries;
+
+ memset(&narrayEntries, 0, sizeof(narrayEntries)); /*initialize to hint the stub to alloc space */
+ code =
+ ubik_VL_ListAttributesN2(cstruct, 0, attrp, (name ? name : ""),
+ thisindex, nentriesp, &narrayEntries, nextindexp);
+ if (!code) {
+ blkentriesp->ubulkentries_val =
+ (uvldbentry *) xdr_alloc(*nentriesp * sizeof(struct uvldbentry));
+ for (i = 0; i < *nentriesp; i++) { /* process each entry */
+ nvlentry_to_uvlentry(&narrayEntries.nbulkentries_val[i],
+ &blkentriesp->ubulkentries_val[i]);
+ }
+ }
+ if (narrayEntries.nbulkentries_val)
+ xdr_free((xdrproc_t) xdr_bulkentries, &narrayEntries);
+ return code;
+ }
return code;
}
-static int vlserverv4 = -1;
struct cacheips {
afs_uint32 server;
afs_int32 count;
int code;
ListAddrByAttributes attrs;
bulkaddrs addrs;
- afs_uint32 *addrp, i, j, f1, f2;
- afs_int32 unique, nentries;
+ afs_uint32 *addrp, f1, f2;
+ afs_int32 i, j, unique, nentries;
afsUUID uuid;
static int initcache = 0;
if (serv1 == serv2)
return 1;
- if (vlserverv4 == 1) {
+ if (newvlserver == vltype_old ||
+ newvlserver == vltype_new) {
return 0;
}
if (!initcache) {
code =
ubik_VL_GetAddrsU(cstruct, 0, &attrs, &uuid, &unique, &nentries,
&addrs);
- if (vlserverv4 == -1) {
+ if (newvlserver == vltype_unknown) {
if (code == RXGEN_OPCODE) {
- vlserverv4 = 1; /* Doesn't support new interface */
+ newvlserver = vltype_new;
return 0;
} else if (!code) {
- vlserverv4 = 2;
+ newvlserver = vltype_uuid;
}
}
if (code == VL_NOENT)
vsu_ExtractName(char rname[], char name[])
{
char sname[VOLSER_OLDMAXVOLNAME + 1];
- int total;
+ size_t total;
strncpy(sname, name, sizeof(sname));
sname[sizeof(sname) - 1] = '\0';
vsu_GetVolumeID(char *astring, struct ubik_client *acstruct, afs_int32 *errp)
{
char volname[VOLSER_OLDMAXVOLNAME + 1];
- struct nvldbentry entry;
+ struct uvldbentry entry;
afs_int32 vcode = 0;
- int total;
+ size_t total;
*errp = 0;
/* It was not a volume number but something else */
total = strlen(astring);
vsu_ExtractName(volname, astring);
- vcode = VLDB_GetEntryByName(volname, &entry);
+ vcode = VLDB_GetEntryByNameU(volname, &entry);
if (!vcode) {
if ((total >= 9) && (!strcmp(&astring[total - 9], ".readonly")))
return entry.volumeId[ROVOL];
git://git.openafs.org / openafs.git / blobdiff