COMMONPARM_OFFSET_ENCRYPT = 29,
COMMONPARM_OFFSET_NORESOLVE = 30,
COMMONPARM_OFFSET_CONFIG = 31,
+ COMMONPARM_OFFSET_RXGK = 32,
};
#define COMMONPARMS \
"-noresolve", CMD_FLAG, CMD_OPTIONAL, "don't resolve addresses"); \
cmd_AddParmAtOffset(ts, COMMONPARM_OFFSET_CONFIG, \
"-config", CMD_SINGLE, CMD_OPTIONAL, "config location"); \
+cmd_AddParmAtOffset(ts, COMMONPARM_OFFSET_RXGK, \
+ "-rxgk", CMD_SINGLE, CMD_OPTIONAL, "rxgk security level to use"); \
#define ERROR_EXIT(code) do { \
error = (code); \
} /*XDisplayVolumes2 */
-
-/* set <server> and <part> to the correct values depending on
- * <voltype> and <entry> */
-static void
+/**
+ * Retrieve the sites (i.e., server id, partition id) from a vldb entry for a
+ * given volume type. May be called repeatedly to get each read-only site.
+ *
+ * @param[in] entry vldb entry from a previous vldb query
+ * @param[in] voltype type of volume of interest (rw, ro, bk)
+ * @param[out] server vldb entry server number for voltype
+ * @param[out] part vldb part id for voltype
+ * @param[inout] previdx cursor; should be initialized to -1
+ * before first call on a given entry.
+ *
+ * @returns true when a volume site has been found
+ */
+static int
GetServerAndPart(struct nvldbentry *entry, int voltype, afs_uint32 *server,
afs_int32 *part, int *previdx)
{
int i, istart, vtype;
- *server = -1;
- *part = -1;
-
- /* Doesn't check for non-existance of backup volume */
+ /* Doesn't check for non-existence of backup volume */
if ((voltype == RWVOL) || (voltype == BACKVOL)) {
vtype = VLSF_RWVOL;
- istart = 0; /* seach the entire entry */
+ istart = 0; /* search the entire entry */
} else {
vtype = VLSF_ROVOL;
- /* Seach from beginning of entry or pick up where we left off */
+ /* Search from beginning of entry or pick up where we left off */
istart = ((*previdx < 0) ? 0 : *previdx + 1);
}
*server = entry->serverNumber[i];
*part = entry->serverPartition[i];
*previdx = i;
- return;
+ return 1;
}
}
- /* Didn't find any, return -1 */
+ /* Didn't find any more, reset index. */
*previdx = -1;
- return;
+ return 0;
}
static void
* It its a BK vol, get the RW entry (even if VLDB may say the BK doen't exist).
* If its a RO vol, get the next RO entry.
*/
- GetServerAndPart(&entry, ((voltype == ROVOL) ? ROVOL : RWVOL),
- &aserver, &apart, &previdx);
- if (previdx == -1) { /* searched all entries */
- if (!foundentry) {
- fprintf(STDERR, "Volume %s does not exist in VLDB\n\n",
- as->parms[0].items->data);
- error = ENOENT;
- }
+ foundentry = GetServerAndPart(&entry, ((voltype == ROVOL) ? ROVOL : RWVOL),
+ &aserver, &apart, &previdx);
+ if (!foundentry) { /* searched all entries */
+ fprintf(STDERR, "Volume %s does not exist in VLDB\n\n",
+ as->parms[0].items->data);
+ error = ENOENT;
break;
}
- foundentry = 1;
/* Get information about the volume from the server */
if (verbose) {
afs_int32 apart;
int previdx = -1;
int have_field = 0;
+ int found;
volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err); /* -id */
if (volid == 0) {
}
MapHostToNetwork(&entry);
- GetServerAndPart(&entry, RWVOL, &aserver, &apart, &previdx);
- if (previdx == -1) {
+ found = GetServerAndPart(&entry, RWVOL, &aserver, &apart, &previdx);
+ if (!found) {
fprintf(STDERR, "Volume %s does not exist in VLDB\n\n",
as->parms[0].items->data);
return (ENOENT);
return 0;
}
-#if 0
-static afs_int32
-DeleteAll(struct nvldbentry *entry)
-{
- int i;
- afs_int32 error, code, curserver, curpart;
- afs_uint32 volid;
-
- MapHostToNetwork(entry);
- error = 0;
- for (i = 0; i < entry->nServers; i++) {
- curserver = entry->serverNumber[i];
- curpart = entry->serverPartition[i];
- if (entry->serverFlags[i] & VLSF_ROVOL) {
- volid = entry->volumeId[ROVOL];
- } else {
- volid = entry->volumeId[RWVOL];
- }
- code = UV_DeleteVolume(curserver, curpart, volid);
- if (code && !error)
- error = code;
- }
- return error;
-}
-#endif
-
static int
DeleteVolume(struct cmd_syndesc *as, void *arock)
{
char pname[10];
afs_int32 idx, j;
+ if (as->parms[1].items && !as->parms[0].items) {
+ fprintf(STDERR, "vos: The -partition option requires the -server option.\n");
+ return EINVAL;
+ }
+
if (as->parms[0].items) {
server = GetServer(as->parms[0].items->data);
if (!server) {
volname, VOLSER_OLDMAXVOLNAME - 1);
return E2BIG;
}
-#if 0
- /*
- * In order that you be able to make clones of RO or BK, this
- * check must be omitted.
- */
- if (!VolNameOK(volname)) {
- fprintf(STDERR,
- "Illegal volume name %s, should not end in .readonly or .backup\n",
- volname);
- return EINVAL;
- }
-#endif
if (IsNumeric(volname)) {
fprintf(STDERR,
"Illegal volume name %s, should not be a number\n",
if (as->parms[1].items) /* -force */
flags |= (REL_COMPLETE | REL_FULLDUMPS);
- if (as->parms[2].items) /* -stayonline */
- flags |= REL_STAYUP;
+ if (as->parms[2].items) { /* -stayonline */
+ fprintf(STDERR, "vos: -stayonline not supported\n");
+ return EINVAL;
+ }
if (as->parms[3].items) /* -force-reclone */
flags |= REL_COMPLETE;
afs_uint32 tserver;
tserver = 0;
+
+ if (as->parms[1].items && !as->parms[0].items) {
+ fprintf(STDERR, "vos: The -partition option requires the -server option.\n");
+ exit(1);
+ }
+
if (as->parms[0].items) {
tserver = GetServer(as->parms[0].items->data);
if (!tserver) {
exit(1);
}
flags = 1;
-
- if (!tserver) {
- fprintf(STDERR,
- "The -partition option requires a -server option\n");
- exit(1);
- }
}
if (as->parms[3].items) {
}
if (pntr->iflags) {
fprintf(STDOUT, "attachFlags: ");
- switch (pntr->iflags) {
- case ITOffline:
+ if ((pntr->iflags & ITOffline) != 0) {
fprintf(STDOUT, "offline ");
- break;
- case ITBusy:
+ }
+ if ((pntr->iflags & ITBusy) != 0) {
fprintf(STDOUT, "busy ");
- break;
- case ITReadOnly:
+ }
+ if ((pntr->iflags & ITReadOnly) != 0) {
fprintf(STDOUT, "readonly ");
- break;
- case ITCreate:
+ }
+ if ((pntr->iflags & ITCreate) != 0) {
fprintf(STDOUT, "create ");
- break;
- case ITCreateVolID:
+ }
+ if ((pntr->iflags & ITCreateVolID) != 0) {
fprintf(STDOUT, "create volid ");
- break;
}
fprintf(STDOUT, "\n");
}
if (pntr->vflags) {
fprintf(STDOUT, "volumeStatus: ");
- switch (pntr->vflags) {
- case VTDeleteOnSalvage:
+ if ((pntr->vflags & VTDeleteOnSalvage) != 0) {
fprintf(STDOUT, "deleteOnSalvage ");
- case VTOutOfService:
+ }
+ if ((pntr->vflags & VTOutOfService) != 0) {
fprintf(STDOUT, "outOfService ");
- case VTDeleted:
+ }
+ if ((pntr->vflags & VTDeleted) != 0) {
fprintf(STDOUT, "deleted ");
}
fprintf(STDOUT, "\n");
static int
RenameVolume(struct cmd_syndesc *as, void *arock)
{
- afs_int32 code1, code2, code;
+ afs_int32 code;
struct nvldbentry entry;
+ struct nvldbentry entry2;
- code1 = VLDB_GetEntryByName(as->parms[0].items->data, &entry);
- if (code1) {
+ /* Get the entry of the volume to be renamed (-oldname), by name or id. */
+ code = VLDB_GetEntryByName(as->parms[0].items->data, &entry);
+ if (code) {
fprintf(STDERR, "vos: Could not find entry for volume %s\n",
as->parms[0].items->data);
+ PrintError("", code);
exit(1);
}
- code2 = VLDB_GetEntryByName(as->parms[1].items->data, &entry);
- if ((!code1) && (!code2)) { /*the newname already exists */
- fprintf(STDERR, "vos: volume %s already exists\n",
+
+ /*
+ * Verify the new name is available before attempting to rename.
+ * Allow renaming of the same volume in order to complete a
+ * previously interrupted rename.
+ */
+ code = VLDB_GetEntryByName(as->parms[1].items->data, &entry2);
+ if (code != 0 && code != VL_NOENT) {
+ fprintf(STDERR, "vos: Could not check entry for volume %s\n",
as->parms[1].items->data);
+ PrintError("", code);
exit(1);
}
-
- if (code1 && code2) {
- fprintf(STDERR, "vos: Could not find entry for volume %s or %s\n",
- as->parms[0].items->data, as->parms[1].items->data);
+ if (code == 0 && entry.volumeId[RWVOL] != entry2.volumeId[RWVOL]) {
+ fprintf(STDERR, "vos: Cannot rename volume %s (%lu) to %s;"
+ " volume %s (%lu) already exists\n",
+ as->parms[0].items->data,
+ (unsigned long)entry.volumeId[RWVOL],
+ as->parms[1].items->data,
+ as->parms[1].items->data,
+ (unsigned long)entry2.volumeId[RWVOL]);
exit(1);
}
if (!VolNameOK(as->parms[0].items->data)) {
apart = 0;
- attributes.Mask = 0;
+ memset(&attributes, 0, sizeof(attributes));
lock = (as->parms[3].items ? 1 : 0); /* -lock flag */
quiet = (as->parms[4].items ? 1 : 0); /* -quit flag */
sort = (as->parms[5].items ? 0 : 1); /* -nosort flag */
#ifndef HAVE_POSIX_REGEX
char *ccode;
#endif
+ int found;
memset(&attributes, 0, sizeof(struct VldbListByAttributes));
attributes.Mask = 0;
avolid = vllist->volumeId[RWVOL];
MapHostToNetwork(vllist);
- GetServerAndPart(vllist, RWVOL, &aserver1, &apart1, &previdx);
- if (aserver1 == -1 || apart1 == -1) {
+ found = GetServerAndPart(vllist, RWVOL, &aserver1, &apart1, &previdx);
+ if (!found) {
fprintf(STDOUT, "could not backup %s, invalid VLDB entry\n",
vllist->name);
totalFail++;
apart = -1;
totalE = 0;
- attributes.Mask = 0;
+ memset(&attributes, 0, sizeof(attributes));
if (as->parms[0].items) { /* server specified */
aserver = GetServer(as->parms[0].items->data);
as->parms[1].items->data);
exit(1);
}
- if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */
- if (code)
- PrintError("", code);
- else
- fprintf(STDERR,
- "vos : partition %s does not exist on the server\n",
- as->parms[1].items->data);
- exit(1);
+ if (aserver) {
+ /* Check for validity of the partition if a server was given. */
+ if (!IsPartValid(apart, aserver, &code)) {
+ if (code)
+ PrintError("", code);
+ else
+ fprintf(STDERR,
+ "vos : partition %s does not exist on the server\n",
+ as->parms[1].items->data);
+ exit(1);
+ }
}
attributes.partition = apart;
attributes.Mask |= VLLIST_PARTITION;
{
afs_int32 ip1, ip2, vcode;
int remove = 0;
+ int force = 0;
if (noresolve)
ip1 = GetServerNoresolve(as->parms[0].items->data);
return (EINVAL);
}
+ if (as->parms[3].items) {
+ force = 1;
+ }
+
if (as->parms[1].items) {
if (noresolve)
ip2 = GetServerNoresolve(as->parms[1].items->data);
ip1 = 0xffffffff;
}
+ if (!remove && !force) {
+ afs_int32 m_nentries;
+ bulkaddrs m_addrs;
+ afs_int32 m_uniq = 0;
+ afsUUID m_uuid;
+ ListAddrByAttributes m_attrs;
+ struct uuid_fmtbuf buffer;
+
+ memset(&m_attrs, 0, sizeof(m_attrs));
+ memset(&m_uuid, 0, sizeof(m_uuid));
+ memset(&m_addrs, 0, sizeof(m_addrs));
+
+ m_attrs.Mask = VLADDR_IPADDR;
+ m_attrs.ipaddr = ntohl(ip1); /* -oldaddr */
+
+ vcode =
+ ubik_VL_GetAddrsU(cstruct, UBIK_CALL_NEW, &m_attrs, &m_uuid,
+ &m_uniq, &m_nentries, &m_addrs);
+ xdr_free((xdrproc_t) xdr_bulkaddrs, &m_addrs);
+ switch (vcode) {
+ case 0: /* mh entry detected */
+ afsUUID_to_string(&m_uuid, &buffer);
+ fprintf(STDERR, "vos: Refusing to change address in multi-homed server entry.\n");
+ fprintf(STDERR, " -oldaddr address is registered to file server UUID %s\n",
+ buffer.buffer);
+ fprintf(STDERR, " Please restart the file server or use vos setaddrs.\n");
+ return EINVAL;
+ case VL_NOENT:
+ break;
+ default:
+ fprintf(STDERR, "vos: could not list the server addresses\n");
+ PrintError("", vcode);
+ return vcode;
+ }
+ }
+
vcode = ubik_VL_ChangeAddr(cstruct, UBIK_CALL_NEW, ntohl(ip1), ntohl(ip2));
if (vcode) {
char hoststr1[16], hoststr2[16];
{
int i;
afs_uint32 addr;
- char buf[1024];
+ struct uuid_fmtbuf buf;
if (print) {
- afsUUID_to_string(m_uuid, buf, sizeof(buf));
- printf("UUID: %s\n", buf);
+ afsUUID_to_string(m_uuid, &buf);
+ printf("UUID: %s\n", buf.buffer);
}
/* print out the list of all the server */
MyBeforeProc(struct cmd_syndesc *as, void *arock)
{
char *tcell;
+ char *rxgk_seclevel_str = NULL;
afs_int32 code;
int secFlags;
if (as->parms[COMMONPARM_OFFSET_CONFIG].items) /* -config flag set */
confdir = as->parms[COMMONPARM_OFFSET_CONFIG].items->data;
+ if (cmd_OptionAsString(as, COMMONPARM_OFFSET_RXGK, &rxgk_seclevel_str) == 0) {
+ if (strcmp(rxgk_seclevel_str, "clear") == 0)
+ secFlags |= AFSCONF_SECOPTS_ALWAYSCLEAR;
+ else if (strcmp(rxgk_seclevel_str, "auth") == 0)
+ secFlags |= AFSCONF_SECOPTS_NEVERENCRYPT;
+ else if (strcmp(rxgk_seclevel_str, "crypt") == 0) {
+ /* don't need to set any flags; this is the default for rxgk */
+ } else {
+ fprintf(STDERR, "Invalid argument to -rxgk: %s\n", rxgk_seclevel_str);
+ exit(1);
+ }
+ secFlags |= AFSCONF_SECOPTS_RXGK;
+
+ free(rxgk_seclevel_str);
+ rxgk_seclevel_str = NULL;
+ }
+
if ((code = vsu_ClientInit(confdir, tcell, secFlags, UV_SetSecurity,
&cstruct))) {
fprintf(STDERR, "could not initialize VLDB library (code=%lu) \n",
"initial quota (KB)");
cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_OPTIONAL, "volume ID");
cmd_AddParm(ts, "-roid", CMD_SINGLE, CMD_OPTIONAL, "readonly volume ID");
-#ifdef notdef
- cmd_AddParm(ts, "-minquota", CMD_SINGLE, CMD_OPTIONAL, "");
-#endif
COMMONPARMS;
ts = cmd_CreateSyntax("remove", DeleteVolume, NULL, 0, "delete a volume");
cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
"force a complete release and full dumps");
cmd_AddParmAlias(ts, 1, "-f"); /* original force option */
- cmd_AddParm(ts, "-stayonline", CMD_FLAG, CMD_OPTIONAL,
+ /* keep this reserved */
+ cmd_AddParm(ts, "-stayonline", CMD_FLAG, CMD_OPTIONAL|CMD_HIDDEN,
"release to cloned temp vol, then clone back to repsite RO");
cmd_AddParm(ts, "-force-reclone", CMD_FLAG, CMD_OPTIONAL,
"force a reclone and complete release with incremental dumps");
cmd_AddParm(ts, "-newaddr", CMD_SINGLE, CMD_OPTIONAL, "new IP address");
cmd_AddParm(ts, "-remove", CMD_FLAG, CMD_OPTIONAL,
"remove the IP address from the VLDB");
+ cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
+ "allow multi-homed server entry change (not recommended)");
COMMONPARMS;
ts = cmd_CreateSyntax("listaddrs", ListAddrs, NULL, 0,
"set the list of IP addresses for a given UUID in the VLDB");
cmd_AddParm(ts, "-uuid", CMD_SINGLE, 0, "uuid of server");
cmd_AddParm(ts, "-host", CMD_LIST, 0, "address of host");
+ COMMONPARMS;
ts = cmd_CreateSyntax("remaddrs", RemoveAddrs, NULL, 0,
"remove the list of IP addresses for a given UUID in the VLDB");
cmd_AddParm(ts, "-uuid", CMD_SINGLE, 0, "uuid of server");
-
COMMONPARMS;
+
code = cmd_Dispatch(argc, argv);
if (rxInitDone) {
/* Shut down the ubik_client and rx connections */
git://git.openafs.org / openafs.git / blobdiff