#endif
extern int smallMem;
+extern int restrictedQueryLevel;
extern int extent_mod;
extern struct afsconf_dir *vldb_confdir;
extern struct ubik_dbase *VL_dbase;
code = (c); \
goto abort; \
} while (0)
-#undef END
-#define END(c) do { \
- code = (c); \
- goto end; \
-} while (0)
#define VLDBALLOCLIMIT 10000
#define VLDBALLOCINCR 2048
code = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS, &ctx->trans);
wl = 1;
} else if (locktype == LOCKREAD) {
- code =
- ubik_BeginTransReadAnyWrite(VL_dbase, UBIK_READTRANS, &ctx->trans);
+#ifdef UBIK_READ_WHILE_WRITE
+ code = ubik_BeginTransReadAnyWrite(VL_dbase, UBIK_READTRANS, &ctx->trans);
+#else
+ code = ubik_BeginTransReadAny(VL_dbase, UBIK_READTRANS, &ctx->trans);
+#endif
wl = 0;
} else {
code = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS, &ctx->trans);
return code;
} else { /* No code */
if (pass == 2) {
- ubik_EndTrans(ctx->trans); /* Rebuilt db. End trans, then retake original lock */
+ /* The database header was rebuilt; end the write transaction.
+ * This will call vlsynccache() to copy the write header buffers
+ * to the read header buffers, before calling vlsetache().
+ * Do a third pass to re-acquire the original lock, which
+ * may be a read lock. */
+ ubik_EndTrans(ctx->trans);
} else {
break; /* didn't rebuild and successful - exit */
}
* (non-existant in vldb).
*/
-afs_int32
-SVL_CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
+static afs_int32
+CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
{
int this_op = VLCREATEENTRY;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
- code = VL_PERM;
- goto end;
+ return VL_PERM;
}
/* Do some validity tests on new entry */
if ((code = check_vldbentry(newentry))
|| (code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1,
("OCreate Volume %d %s\n", newentry->volumeId[RWVOL],
FreeBlock(&ctx, blockindex);
goto abort;
} else {
- code = ubik_EndTrans(ctx.trans);
- goto end;
+ return ubik_EndTrans(ctx.trans);
}
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
+afs_int32
+SVL_CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
+{
+ afs_int32 code;
+
+ code = CreateEntry(rxcall, newentry);
osi_auditU(rxcall, VLCreateEntryEvent, code, AUD_STR,
(newentry ? newentry->name : NULL), AUD_END);
return code;
}
-
-afs_int32
-SVL_CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
+static afs_int32
+CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
{
int this_op = VLCREATEENTRYN;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
- code = VL_PERM;
- goto end;
+ return VL_PERM;
}
/* Do some validity tests on new entry */
if ((code = check_nvldbentry(newentry))
|| (code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1,
("Create Volume %d %s\n", newentry->volumeId[RWVOL],
FreeBlock(&ctx, blockindex);
goto abort;
} else {
- code = ubik_EndTrans(ctx.trans);
- goto end;
+ return ubik_EndTrans(ctx.trans);
}
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
+
+afs_int32
+SVL_CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
+{
+ afs_int32 code;
- end:
+ code = CreateEntryN(rxcall, newentry);
osi_auditU(rxcall, VLCreateEntryEvent, code, AUD_STR,
(newentry ? newentry->name : NULL), AUD_END);
return code;
}
-
-afs_int32
-SVL_ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
+static afs_int32
+ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
{
int this_op = VLCHANGEADDR;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
- code = VL_PERM;
- goto end;
+ return VL_PERM;
}
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("Change Addr %u -> %u %s\n", ip1, ip2, rxinfo(rxstr, rxcall)));
if ((code = ChangeIPAddr(&ctx, ip1, ip2)))
goto abort;
else {
code = ubik_EndTrans(ctx.trans);
- goto end;
+ return code;
}
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
+afs_int32
+SVL_ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
+{
+ afs_int32 code;
+
+ code = ChangeAddr(rxcall, ip1, ip2);
osi_auditU(rxcall, VLChangeAddrEvent, code, AUD_LONG, ip1, AUD_LONG,
ip2, AUD_END);
return code;
}
/* Delete a vldb entry given the volume id. */
-afs_int32
-SVL_DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
+static afs_int32
+DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
{
int this_op = VLDELETEENTRY;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((voltype != -1) && (InvalidVoltype(voltype)))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("Delete Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
if ((code = RemoveEntry(&ctx, blockindex, &tentry))) {
goto abort;
}
- code = (ubik_EndTrans(ctx.trans));
- goto end;
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
+
+afs_int32
+SVL_DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
+{
+ afs_int32 code;
- end:
+ code = DeleteEntry(rxcall, volid, voltype);
osi_auditU(rxcall, VLDeleteEntryEvent, code, AUD_LONG, volid,
AUD_END);
return code;
/* Get a vldb entry given its volume id; make sure it's not a deleted entry. */
-int
+static int
GetEntryByID(struct rx_call *rxcall,
afs_uint32 volid,
afs_int32 voltype,
/* Get a vldb entry given the volume's name; of course, very similar to
* VLGetEntryByID() above. */
-afs_int32
+static afs_int32
GetEntryByName(struct rx_call *rxcall,
char *volname,
char *aentry, /* entry data copied here */
if (NameIsId(volname)) {
return GetEntryByID(rxcall, strtoul(volname, NULL, 10), -1, aentry, new, this_op);
}
+
+ countRequest(this_op);
+
if (InvalidVolname(volname))
return VL_BADNAME;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
VLGETENTRYBYNAME));
}
-
afs_int32
SVL_GetEntryByNameN(struct rx_call *rxcall,
char *volname,
VLGETENTRYBYNAMEU));
}
-
-
/* Get the current value of the maximum volume id and bump the volume id counter by Maxvolidbump. */
-afs_int32
-SVL_GetNewVolumeId(struct rx_call *rxcall, afs_uint32 Maxvolidbump,
+static afs_int32
+getNewVolumeId(struct rx_call *rxcall, afs_uint32 Maxvolidbump,
afs_uint32 *newvolumeid)
{
int this_op = VLGETNEWVOLUMEID;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if (Maxvolidbump > MAXBUMPCOUNT)
- END(VL_BADVOLIDBUMP);
+ return VL_BADVOLIDBUMP;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
*newvolumeid = maxvolumeid = NextUnusedID(&ctx,
ntohl(ctx.cheader->vital_header.MaxVolumeId), Maxvolidbump, &code);
if (write_vital_vlheader(&ctx)) {
ABORT(VL_IO);
}
- code = (ubik_EndTrans(ctx.trans));
- goto end;
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
+
+afs_int32
+SVL_GetNewVolumeId(struct rx_call *rxcall, afs_uint32 Maxvolidbump,
+ afs_uint32 *newvolumeid)
+{
+ afs_int32 code;
- end:
+ code = getNewVolumeId(rxcall, Maxvolidbump, newvolumeid);
osi_auditU(rxcall, VLGetNewVolumeIdEvent, code, AUD_END);
return code;
}
* newentry. No individual checking/updating per field (alike
* VLUpdateEntry) is done. */
-afs_int32
-SVL_ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+static afs_int32
+ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
struct vldbentry *newentry, afs_int32 releasetype)
{
int this_op = VLREPLACEENTRY;
hashVol[typeindex] = 0;
hashnewname = 0;
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((code = check_vldbentry(newentry)))
- goto end;
+ return code;
if (voltype != -1 && InvalidVoltype(voltype))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("OReplace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
/* find vlentry we're changing */
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
-
- end:
- osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid,
- AUD_END);
return code;
}
afs_int32
-SVL_ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+SVL_ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ struct vldbentry *newentry, afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = ReplaceEntry(rxcall, volid, voltype, newentry, releasetype);
+ osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid, AUD_END);
+ return code;
+}
+
+static afs_int32
+ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
struct nvldbentry *newentry, afs_int32 releasetype)
{
int this_op = VLREPLACEENTRYN;
hashVol[typeindex] = 0;
hashnewname = 0;
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((code = check_nvldbentry(newentry)))
- goto end;
+ return code;
if (voltype != -1 && InvalidVoltype(voltype))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("Replace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
/* find vlentry we're changing */
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
- osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid,
- AUD_END);
+afs_int32
+SVL_ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ struct nvldbentry *newentry, afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = ReplaceEntryN(rxcall, volid, voltype, newentry, releasetype);
+ osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid, AUD_END);
return code;
}
* appropriate bits in the Mask field in VldbUpdateentry. */
/* this routine may never have been tested; use replace entry instead
* unless you're brave */
-afs_int32
-SVL_UpdateEntry(struct rx_call *rxcall,
- afs_uint32 volid,
- afs_int32 voltype,
- struct VldbUpdateEntry *updateentry, /* Update entry copied here */
- afs_int32 releasetype)
+static afs_int32
+UpdateEntry(struct rx_call *rxcall,
+ afs_uint32 volid,
+ afs_int32 voltype,
+ struct VldbUpdateEntry *updateentry, /* Update entry copied here */
+ afs_int32 releasetype)
{
int this_op = VLUPDATEENTRY;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((voltype != -1) && (InvalidVoltype(voltype)))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("Update Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
-
- end:
- osi_auditU(rxcall, VLUpdateEntryEvent, code, AUD_LONG, volid,
- AUD_END);
return code;
}
-
afs_int32
-SVL_UpdateEntryByName(struct rx_call *rxcall,
- char *volname,
- struct VldbUpdateEntry *updateentry, /* Update entry copied here */
- afs_int32 releasetype)
+SVL_UpdateEntry(struct rx_call *rxcall,
+ afs_uint32 volid,
+ afs_int32 voltype,
+ struct VldbUpdateEntry *updateentry,
+ afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = UpdateEntry(rxcall, volid, voltype, updateentry, releasetype);
+ osi_auditU(rxcall, VLUpdateEntryEvent, code, AUD_LONG, volid, AUD_END);
+ return code;
+}
+
+static afs_int32
+UpdateEntryByName(struct rx_call *rxcall,
+ char *volname,
+ struct VldbUpdateEntry *updateentry, /* Update entry copied here */
+ afs_int32 releasetype)
{
int this_op = VLUPDATEENTRYBYNAME;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
blockindex = FindByName(&ctx, volname, &tentry, &code);
if (blockindex == 0) { /* entry not found */
if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
+afs_int32
+SVL_UpdateEntryByName(struct rx_call *rxcall,
+ char *volname,
+ struct VldbUpdateEntry *updateentry, /* Update entry copied here */
+ afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = UpdateEntryByName(rxcall, volname, updateentry, releasetype);
osi_auditU(rxcall, VLUpdateEntryEvent, code, AUD_LONG, -1, AUD_END);
return code;
}
-
/* Set a lock to the vldb entry for volid (of type voltype if not -1). */
-afs_int32
-SVL_SetLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
- afs_int32 voloper)
+static afs_int32
+SetLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ afs_int32 voloper)
{
int this_op = VLSETLOCK;
afs_int32 timestamp, blockindex, code;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((voltype != -1) && (InvalidVoltype(voltype)))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (InvalidOperation(voloper))
- END(VL_BADVOLOPER);
+ return VL_BADVOLOPER;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("SetLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
+afs_int32
+SVL_SetLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ afs_int32 voloper)
+{
+ afs_int32 code;
+
+ code = SetLock(rxcall, volid, voltype, voloper);
osi_auditU(rxcall, VLSetLockEvent, code, AUD_LONG, volid, AUD_END);
return code;
}
-
/* Release an already locked vldb entry. Releasetype determines what
* fields (afsid and/or volume operation) will be cleared along with
* the lock time stamp. */
-afs_int32
-SVL_ReleaseLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
- afs_int32 releasetype)
+static afs_int32
+ReleaseLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ afs_int32 releasetype)
{
int this_op = VLRELEASELOCK;
afs_int32 blockindex, code;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((voltype != -1) && (InvalidVoltype(voltype)))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("ReleaseLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
-
- end:
- osi_auditU(rxcall, VLReleaseLockEvent, code, AUD_LONG, volid,
- AUD_END);
return code;
}
+afs_int32
+SVL_ReleaseLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = ReleaseLock(rxcall, volid, voltype, releasetype);
+ osi_auditU(rxcall, VLReleaseLockEvent, code, AUD_LONG, volid, AUD_END);
+ return code;
+}
/* ListEntry returns a single vldb entry, aentry, with offset previous_index;
* the remaining parameters (i.e. next_index) are used so that sequential
* calls to this routine will get the next (all) vldb entries.
*/
-afs_int32
-SVL_ListEntry(struct rx_call *rxcall, afs_int32 previous_index,
- afs_int32 *count, afs_int32 *next_index,
- struct vldbentry *aentry)
+static afs_int32
+ListEntry(struct rx_call *rxcall, afs_int32 previous_index,
+ afs_int32 *count, afs_int32 *next_index,
+ struct vldbentry *aentry)
{
int this_op = VLLISTENTRY;
int code;
char rxstr[AFS_RXINFO_LEN];
countRequest(this_op);
+
+ if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
+ restrictedQueryLevel))
+ return VL_PERM;
+
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return code;
VLog(25, ("OListEntry index=%d %s\n", previous_index,
return code;
}
}
- return (ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
+}
+
+afs_int32
+SVL_ListEntry(struct rx_call *rxcall, afs_int32 previous_index,
+ afs_int32 *count, afs_int32 *next_index,
+ struct vldbentry *aentry)
+{
+ afs_int32 code;
+
+ code = ListEntry(rxcall, previous_index, count, next_index, aentry);
+ osi_auditU(rxcall, VLListEntryEvent, code, AUD_LONG, previous_index, AUD_END);
+ return code;
}
/* ListEntry returns a single vldb entry, aentry, with offset previous_index;
* the remaining parameters (i.e. next_index) are used so that sequential
* calls to this routine will get the next (all) vldb entries.
*/
-afs_int32
-SVL_ListEntryN(struct rx_call *rxcall, afs_int32 previous_index,
- afs_int32 *count, afs_int32 *next_index,
- struct nvldbentry *aentry)
+static afs_int32
+ListEntryN(struct rx_call *rxcall, afs_int32 previous_index,
+ afs_int32 *count, afs_int32 *next_index,
+ struct nvldbentry *aentry)
{
int this_op = VLLISTENTRYN;
int code;
char rxstr[AFS_RXINFO_LEN];
countRequest(this_op);
+
+ if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
+ restrictedQueryLevel))
+ return VL_PERM;
+
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return code;
VLog(25, ("ListEntry index=%d %s\n", previous_index, rxinfo(rxstr, rxcall)));
}
}
- return (ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
}
+afs_int32
+SVL_ListEntryN(struct rx_call *rxcall, afs_int32 previous_index,
+ afs_int32 *count, afs_int32 *next_index,
+ struct nvldbentry *aentry)
+{
+ afs_int32 code;
+
+ code = ListEntryN(rxcall, previous_index, count, next_index, aentry);
+ osi_auditU(rxcall, VLListEntryEventN, code, AUD_LONG, previous_index, AUD_END);
+ return code;
+}
/* Retrieves in vldbentries all vldb entries that match the specified
* attributes (by server number, partition, volume type, and flag); if volume
* CAUTION: This could be a very expensive call since in most cases
* sequential search of all vldb entries is performed.
*/
-afs_int32
-SVL_ListAttributes(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- afs_int32 *nentries,
- bulkentries *vldbentries)
+static afs_int32
+ListAttributes(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ bulkentries *vldbentries)
{
int this_op = VLLISTATTRIBUTES;
int code, allocCount = 0;
char rxstr[AFS_RXINFO_LEN];
countRequest(this_op);
+
+ if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
+ restrictedQueryLevel))
+ return VL_PERM;
+
vldbentries->bulkentries_val = 0;
vldbentries->bulkentries_len = *nentries = 0;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return code;
allocCount = VLDBALLOCCOUNT;
Vldbentry = VldbentryFirst = vldbentries->bulkentries_val =
- (vldbentry *) malloc(allocCount * sizeof(vldbentry));
+ malloc(allocCount * sizeof(vldbentry));
if (Vldbentry == NULL) {
code = VL_NOMEM;
goto abort;
VLog(5,
("ListAttrs nentries=%d %s\n", vldbentries->bulkentries_len,
rxinfo(rxstr, rxcall)));
- return (ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
if (vldbentries->bulkentries_val)
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
-
return code;
}
afs_int32
-SVL_ListAttributesN(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- afs_int32 *nentries,
- nbulkentries *vldbentries)
+SVL_ListAttributes(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ bulkentries *vldbentries)
+{
+ afs_int32 code;
+
+ code = ListAttributes(rxcall, attributes, nentries, vldbentries);
+ osi_auditU(rxcall, VLListAttributesEvent, code, AUD_END);
+ return code;
+}
+
+static afs_int32
+ListAttributesN(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ nbulkentries *vldbentries)
{
int this_op = VLLISTATTRIBUTESN;
int code, allocCount = 0;
char rxstr[AFS_RXINFO_LEN];
countRequest(this_op);
+
+ if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
+ restrictedQueryLevel))
+ return VL_PERM;
+
vldbentries->nbulkentries_val = 0;
vldbentries->nbulkentries_len = *nentries = 0;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return code;
allocCount = VLDBALLOCCOUNT;
Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
- (nvldbentry *) malloc(allocCount * sizeof(nvldbentry));
+ malloc(allocCount * sizeof(nvldbentry));
if (Vldbentry == NULL) {
code = VL_NOMEM;
goto abort;
VLog(5,
("NListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,
rxinfo(rxstr, rxcall)));
- return (ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
return code;
}
-
afs_int32
-SVL_ListAttributesN2(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- char *name, /* Wildcarded volume name */
- afs_int32 startindex,
- afs_int32 *nentries,
- nbulkentries *vldbentries,
- afs_int32 *nextstartindex)
+SVL_ListAttributesN(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ nbulkentries *vldbentries)
+{
+ afs_int32 code;
+
+ code = ListAttributesN(rxcall, attributes, nentries, vldbentries);
+ osi_auditU(rxcall, VLListAttributesNEvent, code, AUD_END);
+ return code;
+}
+
+static afs_int32
+ListAttributesN2(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ char *name, /* Wildcarded volume name */
+ afs_int32 startindex,
+ afs_int32 *nentries,
+ nbulkentries *vldbentries,
+ afs_int32 *nextstartindex)
{
int this_op = VLLISTATTRIBUTESN2;
int code = 0, maxCount = VLDBALLOCCOUNT;
int pollcount = 0;
int namematchRWBK, namematchRO, thismatch;
int matchtype = 0;
- char volumename[VL_MAXNAMELEN+2]; /* regex anchors */
+ int size;
+ char volumename[VL_MAXNAMELEN+3]; /* regex anchors */
char rxstr[AFS_RXINFO_LEN];
#ifdef HAVE_POSIX_REGEX
regex_t re;
#endif
countRequest(this_op);
+
+ if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
+ restrictedQueryLevel))
+ return VL_PERM;
+
vldbentries->nbulkentries_val = 0;
vldbentries->nbulkentries_len = 0;
*nentries = 0;
return code;
Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
- (nvldbentry *) malloc(maxCount * sizeof(nvldbentry));
+ malloc(maxCount * sizeof(nvldbentry));
if (Vldbentry == NULL) {
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
findpartition = ((attributes->Mask & VLLIST_PARTITION) ? 1 : 0);
findflag = ((attributes->Mask & VLLIST_FLAG) ? 1 : 0);
if (name && (strcmp(name, ".*") != 0) && (strcmp(name, "") != 0)) {
- sprintf(volumename, "^%s$", name);
+ if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
+ code = VL_PERM;
+ goto done;
+ }
+ size = snprintf(volumename, sizeof(volumename), "^%s$", name);
+ if (size < 0 || size >= sizeof(volumename)) {
+ code = VL_BADNAME;
+ goto done;
+ }
#ifdef HAVE_POSIX_REGEX
if (regcomp(&re, volumename, REG_NOSUB) != 0) {
code = VL_BADNAME;
/* Does the name match the RW name */
if (tentry.flags & VLF_RWEXISTS) {
if (findname) {
- sprintf(volumename, "%s", tentry.name);
+ size = snprintf(volumename, sizeof(volumename),
+ "%s", tentry.name);
+ if (size < 0 || size >= sizeof(volumename)) {
+ code = VL_BADNAME;
+ goto done;
+ }
#ifdef HAVE_POSIX_REGEX
if (regexec(&re, volumename, 0, NULL, 0) == 0) {
thismatch = VLSF_RWVOL;
/* Does the name match the BK name */
if (!thismatch && (tentry.flags & VLF_BACKEXISTS)) {
if (findname) {
- sprintf(volumename, "%s.backup", tentry.name);
+ /* If this fails, the tentry.name is invalid */
+ size = snprintf(volumename, sizeof(volumename),
+ "%s.backup", tentry.name);
+ if (size < 0 || size >= sizeof(volumename)) {
+ code = VL_BADNAME;
+ goto done;
+ }
#ifdef HAVE_POSIX_REGEX
if (regexec(&re, volumename, 0, NULL, 0) == 0) {
thismatch = VLSF_BACKVOL;
thismatch =
((namematchRO == 1) ? VLSF_ROVOL : 0);
} else {
- sprintf(volumename, "%s.readonly",
- tentry.name);
+ /* If this fails, the tentry.name is invalid */
+ size = snprintf(volumename, sizeof(volumename),
+ "%s.readonly", tentry.name);
+ if (size < 0 || size >= sizeof(volumename)) {
+ code = VL_BADNAME;
+ goto done;
+ }
#ifdef HAVE_POSIX_REGEX
if (regexec(&re, volumename, 0, NULL, 0) == 0) {
thismatch = VLSF_ROVOL;
vldbentries->nbulkentries_val = 0;
vldbentries->nbulkentries_len = 0;
*nextstartindex = -1;
- return code;
} else {
VLog(5,
("N2ListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,
rxinfo(rxstr, rxcall)));
- return (ubik_EndTrans(ctx.trans));
+ code = ubik_EndTrans(ctx.trans);
}
+
+ return code;
}
+afs_int32
+SVL_ListAttributesN2(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ char *name, /* Wildcarded volume name */
+ afs_int32 startindex,
+ afs_int32 *nentries,
+ nbulkentries *vldbentries,
+ afs_int32 *nextstartindex)
+{
+ afs_int32 code;
+
+ code = ListAttributesN2(rxcall, attributes, name, startindex,
+ nentries, vldbentries, nextstartindex);
+ osi_auditU(rxcall, VLListAttributesN2Event, code, AUD_END);
+ return code;
+}
/* Retrieves in vldbentries all vldb entries that match the specified
* attributes (by server number, partition, volume type, and flag); if
* returned. CAUTION: This could be a very expensive call since in most
* cases sequential search of all vldb entries is performed.
*/
-afs_int32
-SVL_LinkedList(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- afs_int32 *nentries,
- vldb_list *vldbentries)
+static afs_int32
+LinkedList(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ vldb_list *vldbentries)
{
int this_op = VLLINKEDLIST;
int code;
int pollcount = 0;
countRequest(this_op);
+
+ if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
+ restrictedQueryLevel))
+ return VL_PERM;
+
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return code;
goto abort;
}
- vllist = (single_vldbentry *) malloc(sizeof(single_vldbentry));
+ vllist = malloc(sizeof(single_vldbentry));
if (vllist == NULL) {
code = VL_NOMEM;
goto abort;
continue;
}
- vllist = (single_vldbentry *) malloc(sizeof(single_vldbentry));
+ vllist = malloc(sizeof(single_vldbentry));
if (vllist == NULL) {
code = VL_NOMEM;
goto abort;
}
}
*vllistptr = NULL;
- return (ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
}
afs_int32
-SVL_LinkedListN(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- afs_int32 *nentries,
- nvldb_list *vldbentries)
+SVL_LinkedList(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ vldb_list *vldbentries)
+{
+ afs_int32 code;
+
+ code = LinkedList(rxcall, attributes, nentries, vldbentries);
+ osi_auditU(rxcall, VLLinkedListEvent, code, AUD_END);
+ return code;
+}
+
+static afs_int32
+LinkedListN(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ nvldb_list *vldbentries)
{
int this_op = VLLINKEDLISTN;
int code;
int pollcount = 0;
countRequest(this_op);
+
+ if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
+ restrictedQueryLevel))
+ return VL_PERM;
+
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return code;
goto abort;
}
- vllist = (single_nvldbentry *) malloc(sizeof(single_nvldbentry));
+ vllist = malloc(sizeof(single_nvldbentry));
if (vllist == NULL) {
code = VL_NOMEM;
goto abort;
continue;
}
- vllist = (single_nvldbentry *) malloc(sizeof(single_nvldbentry));
+ vllist = malloc(sizeof(single_nvldbentry));
if (vllist == NULL) {
code = VL_NOMEM;
goto abort;
}
}
*vllistptr = NULL;
- return (ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
return code;
}
+afs_int32
+SVL_LinkedListN(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ nvldb_list *vldbentries)
+{
+ afs_int32 code;
+
+ code = LinkedListN(rxcall, attributes, nentries, vldbentries);
+ osi_auditU(rxcall, VLLinkedListNEvent, code, AUD_END);
+ return code;
+}
+
/* Get back vldb header statistics (allocs, frees, maxvolumeid,
* totalentries, etc) and dynamic statistics (number of requests and/or
* aborts per remote procedure call, etc)
*/
-afs_int32
-SVL_GetStats(struct rx_call *rxcall,
- vldstats *stats,
- vital_vlheader *vital_header)
+static afs_int32
+GetStats(struct rx_call *rxcall,
+ vldstats *stats,
+ vital_vlheader *vital_header)
{
int this_op = VLGETSTATS;
afs_int32 code;
char rxstr[AFS_RXINFO_LEN];
countRequest(this_op);
-#ifdef notdef
- /* Allow users to get statistics freely */
- if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) /* Must be in 'UserList' to use */
+
+ if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
+ restrictedQueryLevel))
return VL_PERM;
-#endif
+
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return code;
VLog(5, ("GetStats %s\n", rxinfo(rxstr, rxcall)));
memcpy((char *)vital_header, (char *)&ctx.cheader->vital_header,
sizeof(vital_vlheader));
memcpy((char *)stats, (char *)&dynamic_statistics, sizeof(vldstats));
- return (ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
+}
+
+afs_int32
+SVL_GetStats(struct rx_call *rxcall,
+ vldstats *stats,
+ vital_vlheader *vital_header)
+{
+ afs_int32 code;
+
+ code = GetStats(rxcall, stats, vital_header);
+ osi_auditU(rxcall, VLGetStatsEvent, code, AUD_END);
+ return code;
}
/* Get the list of file server addresses from the VLDB. Currently it's pretty
VLog(5, ("GetAddrs\n"));
addrsp->bulkaddrs_val = taddrp =
- (afs_uint32 *) malloc(sizeof(afs_int32) * (MAXSERVERID + 1));
+ malloc(sizeof(afs_uint32) * (MAXSERVERID + 1));
nservers = *nentries = addrsp->bulkaddrs_len = 0;
if (!taddrp) {
return code;
}
-#define PADDR(addr) VLog(0,("%d.%d.%d.%d", (addr>>24)&0xff, (addr>>16)&0xff, (addr>>8) &0xff, addr&0xff));
+static_inline void
+append_addr(char *buffer, afs_uint32 addr, size_t buffer_size)
+{
+ int n = strlen(buffer);
+ if (buffer_size > n) {
+ snprintf(buffer + n, buffer_size - n, "%u.%u.%u.%u",
+ (addr >> 24) & 0xff, (addr >> 16) & 0xff, (addr >> 8) & 0xff,
+ addr & 0xff);
+ }
+}
afs_int32
SVL_RegisterAddrs(struct rx_call *rxcall, afsUUID *uuidp, afs_int32 spare1,
struct vl_ctx ctx;
int cnt, h, i, j, k, m;
struct extentaddr *exp = 0, *tex;
+ char addrbuf[256];
afsUUID tuuid;
afs_uint32 addrs[VL_MAXIPADDRS_PERMH];
int base;
|| (!foundUuidEntry && (count > 1))) {
VLog(0,
("The following fileserver is being registered in the VLDB:\n"));
- VLog(0, (" ["));
- for (k = 0; k < cnt; k++) {
+ for (addrbuf[0] = '\0', k = 0; k < cnt; k++) {
if (k > 0)
- VLog(0,(" "));
- PADDR(addrs[k]);
+ strlcat(addrbuf, " ", sizeof(addrbuf));
+ append_addr(addrbuf, addrs[k], sizeof(addrbuf));
}
- VLog(0,("]\n"));
+ VLog(0, (" [%s]\n", addrbuf));
if (foundUuidEntry) {
code = multiHomedExtent(&ctx, FoundUuid, &exp);
if (code == 0) {
VLog(0, (" It would have replaced the existing VLDB server "
"entry:\n"));
- VLog(0, (" entry %d: [", FoundUuid));
- for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
+ for (addrbuf[0] = '\0', mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
if (!exp->ex_addrs[mhidx])
continue;
if (mhidx > 0)
- VLog(0,(" "));
- PADDR(ntohl(exp->ex_addrs[mhidx]));
+ strlcat(addrbuf, " ", sizeof(addrbuf));
+ append_addr(addrbuf, ntohl(exp->ex_addrs[mhidx]), sizeof(addrbuf));
}
- VLog(0, ("]\n"));
+ VLog(0, (" entry %d: [%s]\n", FoundUuid, addrbuf));
}
}
if (code)
goto abort;
+ addrbuf[0] = '\0';
if (exp) {
- VLog(0, ("["));
for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
if (!exp->ex_addrs[mhidx])
continue;
if (mhidx > 0)
- VLog(0, (" "));
- PADDR(ntohl(exp->ex_addrs[mhidx]));
+ strlcat(addrbuf, " ", sizeof(addrbuf));
+ append_addr(addrbuf, ntohl(exp->ex_addrs[mhidx]), sizeof(addrbuf));
}
- VLog(0, ("]"));
} else {
- PADDR(ctx.hostaddress[srvidx]);
+ append_addr(addrbuf, ctx.hostaddress[srvidx], sizeof(addrbuf));
}
- VLog(0, ("\n"));
+ VLog(0, (" entry %d: [%s]\n", srvidx, addrbuf));
}
if (count == 1)
}
VLog(0, ("The following fileserver is being registered in the VLDB:\n"));
- VLog(0, (" ["));
- for (k = 0; k < cnt; k++) {
+ for (addrbuf[0] = '\0', k = 0; k < cnt; k++) {
if (k > 0)
- VLog(0, (" "));
- PADDR(addrs[k]);
+ strlcat(addrbuf, " ", sizeof(addrbuf));
+ append_addr(addrbuf, addrs[k], sizeof(addrbuf));
}
- VLog(0, ("]\n"));
+ VLog(0, (" [%s]\n", addrbuf));
if (foundUuidEntry) {
VLog(0,
(" It will replace the following existing entry in the VLDB (same uuid):\n"));
- VLog(0, (" entry %d: [", FoundUuid));
- for (k = 0; k < VL_MAXIPADDRS_PERMH; k++) {
+ for (addrbuf[0] = '\0', k = 0; k < VL_MAXIPADDRS_PERMH; k++) {
if (exp->ex_addrs[k] == 0)
continue;
if (k > 0)
- VLog(0, (" "));
- PADDR(ntohl(exp->ex_addrs[k]));
+ strlcat(addrbuf, " ", sizeof(addrbuf));
+ append_addr(addrbuf, ntohl(exp->ex_addrs[k]), sizeof(addrbuf));
}
- VLog(0, ("]\n"));
+ VLog(0, (" entry %d: [%s]\n", FoundUuid, addrbuf));
} else if (willReplaceCnt || (count == 1)) {
/* If we are not replacing an entry and there is only one entry to change,
* then we will replace that entry.
if (exp) {
VLog(0,
(" It will replace the following existing entry in the VLDB (new uuid):\n"));
- VLog(0, (" entry %d: [", ReplaceEntry));
- for (k = 0; k < VL_MAXIPADDRS_PERMH; k++) {
+ for (addrbuf[0] = '\0', k = 0; k < VL_MAXIPADDRS_PERMH; k++) {
if (exp->ex_addrs[k] == 0)
continue;
if (k > 0)
- VLog(0, (" "));
- PADDR(ntohl(exp->ex_addrs[k]));
+ strlcat(addrbuf, " ", sizeof(addrbuf));
+ append_addr(addrbuf, ntohl(exp->ex_addrs[k]), sizeof(addrbuf));
}
- VLog(0, ("]\n"));
+ VLog(0, (" entry %d: [%s]\n", ReplaceEntry, addrbuf));
} else {
/* Not a mh entry. So we have to create a new mh entry and
* put it on the ReplaceEntry slot of the ctx.hostaddress array.
*/
- VLog(0, (" It will replace existing entry %d, ", ReplaceEntry));
- PADDR(ctx.hostaddress[ReplaceEntry]);
- VLog(0,(", in the VLDB (new uuid):\n"));
-
+ addrbuf[0] = '\0';
+ append_addr(addrbuf, ctx.hostaddress[ReplaceEntry], sizeof(addrbuf));
+ VLog(0, (" It will replace existing entry %d, %s,"
+ " in the VLDB (new uuid):\n", ReplaceEntry, addrbuf));
code =
FindExtentBlock(&ctx, uuidp, 1, ReplaceEntry, &exp, &base);
if (code || !exp) {
VLog(0,
(" The following existing entries in the VLDB will be updated:\n"));
- VLog(0, (" entry %d: [", WillChange[i]));
- for (h = j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
+ for (addrbuf[0] = '\0', h = j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
if (tex->ex_addrs[j]) {
if (j > 0)
- printf(" ");
- PADDR(ntohl(tex->ex_addrs[j]));
+ strlcat(addrbuf, " ", sizeof(addrbuf));
+ append_addr(addrbuf, ntohl(tex->ex_addrs[j]), sizeof(addrbuf));
}
for (k = 0; k < cnt; k++) {
for (j = h; j < VL_MAXIPADDRS_PERMH; j++) {
tex->ex_addrs[j] = 0; /* zero rest of mh entry */
}
- VLog(0, ("]\n"));
+ VLog(0, (" entry %d: [%s]\n", WillChange[i], addrbuf));
/* Write out the modified mh entry */
tex->ex_uniquifier = htonl(ntohl(tex->ex_uniquifier) + 1);
bulkaddrs *addrsp)
{
int this_op = VLGETADDRSU;
- afs_int32 code, index = -1, offset;
+ afs_int32 code, index;
struct vl_ctx ctx;
int nservers, i, j, base = 0;
struct extentaddr *exp = 0;
code = VL_BADMASK;
goto abort;
}
- for (base = 0; base < VL_MAX_ADDREXTBLKS; base++) {
- if (!ctx.ex_addr[base])
- break;
- for (i = 1; i < VL_MHSRV_PERBLK; i++) {
- exp = &ctx.ex_addr[base][i];
- tuuid = exp->ex_hostuuid;
- afs_ntohuuid(&tuuid);
- if (afs_uuid_is_nil(&tuuid))
- continue;
+ /* Search for a server registered with the VLDB with this ip address. */
+ for (index = 0; index <= MAXSERVERID; index++) {
+ code = multiHomedExtent(&ctx, index, &exp);
+ if (code)
+ continue;
+
+ if (exp) {
for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
if (exp->ex_addrs[j]
&& (ntohl(exp->ex_addrs[j]) == attributes->ipaddr)) {
if (j < VL_MAXIPADDRS_PERMH)
break;
}
- if (i < VL_MHSRV_PERBLK)
- break;
}
- if (base >= VL_MAX_ADDREXTBLKS) {
+ if (index > MAXSERVERID) {
code = VL_NOENT;
goto abort;
}
code = VL_BADMASK;
goto abort;
}
- index = attributes->index;
- if (index < 1 || index >= (VL_MAX_ADDREXTBLKS * VL_MHSRV_PERBLK)) {
+ /* VLADDR_INDEX index is one based */
+ if (attributes->index < 1 || attributes->index > MAXSERVERID) {
code = VL_INDEXERANGE;
goto abort;
}
- base = index / VL_MHSRV_PERBLK;
- offset = index % VL_MHSRV_PERBLK;
- if (offset == 0) {
+ index = attributes->index - 1;
+ code = multiHomedExtent(&ctx, index, &exp);
+ if (code) {
code = VL_NOENT;
goto abort;
}
- if (!ctx.ex_addr[base]) {
- code = VL_INDEXERANGE;
- goto abort;
- }
- exp = &ctx.ex_addr[base][offset];
} else if (attributes->Mask & VLADDR_UUID) {
if (attributes->Mask & (VLADDR_IPADDR | VLADDR_INDEX)) {
code = VL_BADMASK;
goto abort;
}
addrsp->bulkaddrs_val = taddrp =
- (afs_uint32 *) malloc(sizeof(afs_int32) * (MAXSERVERID + 1));
+ malloc(sizeof(afs_uint32) * (MAXSERVERID + 1));
nservers = *nentries = addrsp->bulkaddrs_len = 0;
if (!taddrp) {
code = VL_NOMEM;
for (i = 0; i < OMAXNSERVERS; i++) {
if (VlEntry->serverNumber[i] == BADSERVERID)
break;
- j = VlEntry->serverNumber[i];
code = multiHomedExtent(ctx, VlEntry->serverNumber[i], &exp);
if (code)
return code;
int i, j;
afs_int32 code;
struct extentaddr *exp = NULL;
- int base;
+ int base = -1;
int mhidx;
afsUUID tuuid;
afs_int32 blockindex, count;
int pollcount = 0;
struct nvlentry tentry;
int ipaddr1_id = -1, ipaddr2_id = -1;
+ char addrbuf1[256];
+ char addrbuf2[256];
- /* Don't let addr change to 256.*.*.* : Causes internal error below */
+ /* Don't let addr change to 255.*.*.* : Causes internal error below */
if ((ipaddr2 & 0xff000000) == 0xff000000)
return (VL_BADSERVER);
}
for (i = 0; i <= MAXSERVERID; i++) {
- code = multiHomedExtentBase(ctx, i, &exp, &base);
+ struct extentaddr *texp = NULL;
+ int tbase;
+
+ code = multiHomedExtentBase(ctx, i, &texp, &tbase);
if (code)
return code;
- if (exp) {
+ if (texp) {
for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
- if (!exp->ex_addrs[mhidx])
+ if (!texp->ex_addrs[mhidx])
continue;
- if (ntohl(exp->ex_addrs[mhidx]) == ipaddr1) {
+ if (ntohl(texp->ex_addrs[mhidx]) == ipaddr1) {
ipaddr1_id = i;
+ exp = texp;
+ base = tbase;
}
- if (ipaddr2 != 0 && ntohl(exp->ex_addrs[mhidx]) == ipaddr2) {
+ if (ipaddr2 != 0 && ntohl(texp->ex_addrs[mhidx]) == ipaddr2) {
ipaddr2_id = i;
}
}
} else {
if (ctx->hostaddress[i] == ipaddr1) {
exp = NULL;
+ base = -1;
ipaddr1_id = i;
}
if (ipaddr2 != 0 && ctx->hostaddress[i] == ipaddr2) {
}
}
}
+ } else if (exp) {
+ /* Do not allow changing addresses in multi-homed entries.
+ Older versions of this RPC would silently "downgrade" mh entries
+ to single-homed entries and orphan the mh enties. */
+ addrbuf1[0] = '\0';
+ append_addr(addrbuf1, ipaddr1, sizeof(addrbuf1));
+ VLog(0, ("Refusing to change address %s in multi-homed entry; "
+ "use RegisterAddrs instead.\n", addrbuf1));
+ return VL_NOENT; /* single-homed entry not found */
}
/* Log a message saying we are changing/removing an IP address */
VLog(0,
("The following IP address is being %s:\n",
(ipaddr2 ? "changed" : "removed")));
- VLog(0, (" entry %d: ", i));
+ addrbuf1[0] = addrbuf2[0] = '\0';
if (exp) {
- VLog(0, ("["));
for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
if (!exp->ex_addrs[mhidx])
continue;
if (mhidx > 0)
- VLog(0, (" "));
- PADDR(ntohl(exp->ex_addrs[mhidx]));
+ strlcat(addrbuf1, " ", sizeof(addrbuf1));
+ append_addr(addrbuf1, ntohl(exp->ex_addrs[mhidx]), sizeof(addrbuf1));
}
- VLog(0, ("]"));
} else {
- PADDR(ipaddr1);
+ append_addr(addrbuf1, ipaddr1, sizeof(addrbuf1));
}
if (ipaddr2) {
- VLog(0, (" -> "));
- PADDR(ipaddr2);
+ append_addr(addrbuf2, ipaddr2, sizeof(addrbuf2));
}
- VLog(0, ("\n"));
+ VLog(0, (" entry %d: [%s] -> [%s]\n", ipaddr1_id, addrbuf1, addrbuf2));
/* Change the registered uuuid addresses */
- if (exp) {
+ if (exp && base != -1) {
memset(&tuuid, 0, sizeof(afsUUID));
afs_htonuuid(&tuuid);
exp->ex_hostuuid = tuuid;
git://git.openafs.org / openafs.git / blobdiff