static int get_cellconfig(char *cell, struct afsconf_cell *cellconfig, char *local_cell, char *linkedcell)
{
int status = 0;
struct afsconf_dir *configdir;
memset(local_cell, 0, sizeof(local_cell));
memset(cellconfig, 0, sizeof(*cellconfig));
if (!(configdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH))) {
return AFSCONF_NODB;
}
if (afsconf_GetLocalCell(configdir, local_cell, MAXCELLCHARS)) {
return AFSCONF_FAILURE;
}
if ((cell == NULL) || (cell[0] == 0))
cell = local_cell;
linkedcell[0] = '\0';
if (afsconf_GetCellInfo(configdir, cell, NULL, cellconfig)) {
status = AFSCONF_NOTFOUND;
}
if (cellconfig->linkedCell)
strncpy(linkedcell,cellconfig->linkedCell,MAXCELLCHARS);
(void) afsconf_Close(configdir);
return(status);
}
static int
internal_client_init_dir(const char *confDir, char *cellName, int secFlags,
struct ubik_client **uclientp,
int (*secproc) (struct rx_securityClass *, afs_int32),
afs_int32 maxservers, char *serviceid, afs_int32 deadtime,
afs_uint32 server, afs_uint32 port, afs_int32 usrvid)
{
int code;
const char *progname;
struct afsconf_dir *dir;
struct afsconf_cell info;
progname = getprogname();
if (progname == NULL)
progname = "<unknown>";
if (confDir == NULL)
confDir = AFSDIR_CLIENT_ETC_DIRPATH;
dir = afsconf_Open(confDir);
if (!dir) {
fprintf(stderr,
"%s: Could not process files in configuration directory (%s).\n",
progname, confDir);
return EIO;
}
if (cellName == NULL)
cellName = dir->cellName;
code = afsconf_GetCellInfo(dir, cellName, serviceid, &info);
if (code) {
fprintf(stderr, "%s: can't find cell %s's hosts in %s/%s\n",
progname?progname:"<unknown>", cellName, confDir,
AFSDIR_CELLSERVDB_FILE);
afsconf_Close(dir);
return code;
}
code = internal_client_init(dir, &info, secFlags, uclientp, secproc,
maxservers, serviceid, deadtime, server,
port, usrvid);
afsconf_Close(dir);
return code;
}
void
afscp_SetConfDir(char *confDir)
{
if (confdir != NULL)
afsconf_Close(confdir);
confdir = afsconf_Open(confDir);
}
int
unlog_NormalizeCellNames(char **list, int size)
{
char *newCellName;
unsigned index;
struct afsconf_dir *conf;
int code;
struct afsconf_cell cellinfo;
if (!(conf = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH))) {
fprintf(stderr, "Cannot get cell configuration info!\n");
exit(1);
}
for (index = 0; index < size; index++, list++) {
newCellName = malloc(MAXKTCREALMLEN);
if (!newCellName) {
perror("unlog_NormalizeCellNames --- malloc failed");
exit(1);
}
lcstring(newCellName, *list, MAXKTCREALMLEN);
code = afsconf_GetCellInfo(conf, newCellName, 0, &cellinfo);
if (code) {
if (code == AFSCONF_NOTFOUND) {
fprintf(stderr, "Unrecognized cell name %s\n", newCellName);
} else {
fprintf(stderr,
"unlog_NormalizeCellNames - afsconf_GetCellInfo");
fprintf(stderr, " failed, code = %d\n", code);
}
exit(1);
}
strcpy(newCellName, cellinfo.name);
*list = newCellName;
}
afsconf_Close(conf);
return 0;
}
struct afscp_cell *
afscp_DefaultCell(void)
{
struct afsconf_dir *dir;
char localcell[MAXCELLCHARS + 1];
int code;
if (defcell) {
return afscp_CellByName(defcell, defrealm);
}
dir = afsconf_Open(AFSCONF_CLIENTNAME);
if (dir == NULL) {
afscp_errno = AFSCONF_NODB;
return NULL;
}
code = afsconf_GetLocalCell(dir, localcell, MAXCELLCHARS);
if (code != 0) {
afscp_errno = code;
return NULL;
}
afsconf_Close(dir);
return afscp_CellByName(localcell, defrealm);
}
static int get_cellconfig(char *cell, struct afsconf_cell *cellconfig,
char *local_cell)
{
int status = AKLOG_SUCCESS;
struct afsconf_dir *configdir;
memset(local_cell, 0, sizeof(local_cell));
memset(cellconfig, 0, sizeof(*cellconfig));
if (!(configdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH)))
{
fprintf(stderr, "%s: can't get afs configuration (afsconf_Open(%s))\n",
progname, AFSDIR_CLIENT_ETC_DIRPATH);
exit(AKLOG_AFS);
}
if (afsconf_GetLocalCell(configdir, local_cell, MAXCELLCHARS))
{
fprintf(stderr, "%s: can't determine local cell.\n", progname);
exit(AKLOG_AFS);
}
if ((cell == NULL) || (cell[0] == 0))
cell = local_cell;
if (afsconf_GetCellInfo(configdir, cell, NULL, cellconfig))
{
fprintf(stderr, "%s: Can't get information about cell %s.\n",
progname, cell);
status = AKLOG_AFS;
}
(void) afsconf_Close(configdir);
return(status);
}
/*
* cfg_ClientQueryStatus() -- Query status of static client configuration
* on host, i.e., status of required configuration files, etc.
* Upon successful completion *configStP is set to the client
* configuration status, with a value of zero (0) indicating that
* the configuration is valid.
*
* If client configuration is not valid then *cellNameP is set to NULL;
* otherwise, *cellNameP is an allocated buffer containing client cell.
*
* If client software (cache-manager) is not installed then *versionP is
* undefined; otherwise *versionP is 34 for 3.4, 35 for 3.5, etc.
*
* Note: Client configuration is checked even if the client software
* is not installed. This is useful for tools that require
* client configuration information but NOT the actual
* client (cache-manager); for example, the AFS Server Manager.
*/
int ADMINAPI
cfg_ClientQueryStatus(const char *hostName, /* name of host */
short *isInstalledP, /* client software installed */
unsigned *versionP, /* client software version */
afs_status_p configStP, /* client config status */
char **cellNameP, /* client's cell */
afs_status_p st)
{ /* completion status */
int rc = 1;
afs_status_t tst2, tst = 0;
afs_status_t clientSt = 0;
char *clientCellName = NULL;
short cmInstalled = 0;
unsigned cmVersion = 0;
/* validate parameters */
if (hostName == NULL || *hostName == '\0') {
tst = ADMCFGHOSTNAMENULL;
} else if (strlen(hostName) > (MAXHOSTCHARS - 1)) {
tst = ADMCFGHOSTNAMETOOLONG;
} else if (isInstalledP == NULL) {
tst = ADMCFGINSTALLEDFLAGPNULL;
} else if (versionP == NULL) {
tst = ADMCFGVERSIONPNULL;
} else if (configStP == NULL) {
tst = ADMCFGCONFIGSTATUSPNULL;
} else if (cellNameP == NULL) {
tst = ADMCFGCELLNAMEPNULL;
}
/* remote configuration not yet supported; hostName must be local host */
if (tst == 0) {
short isLocal;
if (!cfgutil_HostNameIsLocal(hostName, &isLocal, &tst2)) {
tst = tst2;
} else if (!isLocal) {
tst = ADMCFGNOTSUPPORTED;
}
}
/* determine if client software (CM) is installed and if so what version */
#ifdef AFS_NT40_ENV
/* Windows - cache manager is a service */
if (tst == 0) {
DWORD svcState;
if (!cfgutil_WindowsServiceQuery
(AFSREG_CLT_SVC_NAME, &svcState, &tst2)) {
/* CM not installed, or insufficient privilege to check */
if (tst2 == ADMNOPRIV) {
tst = tst2;
} else {
cmInstalled = 0;
}
} else {
/* CM installed, get version */
unsigned major, minor, patch;
cmInstalled = 1;
if (afssw_GetClientVersion(&major, &minor, &patch)) {
/* failed to retrieve version information */
if (errno == EACCES) {
tst = ADMNOPRIV;
} else {
tst = ADMCFGCLIENTVERSIONNOTREAD;
}
} else {
cmVersion = (major * 10) + minor;
}
}
}
#else
if (tst == 0) {
/* function not yet implemented for Unix */
tst = ADMCFGNOTSUPPORTED;
}
#endif /* AFS_NT40_ENV */
/* check static client configuration; not necessary that client
* software (CM) be installed for this information to be valid and useable.
*/
if (tst == 0) {
struct afsconf_dir *confdir;
if ((confdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH)) == NULL) {
/* the client configuration appears to be missing/invalid */
clientSt = ADMCFGCLIENTBASICINFOINVALID;
} else {
struct afsconf_entry *cellentry;
if (confdir->cellName == NULL || *confdir->cellName == '\0') {
/* no cell set for client */
clientSt = ADMCFGCLIENTNOTINCELL;
} else {
for (cellentry = confdir->entries; cellentry != NULL;
cellentry = cellentry->next) {
if (!strcasecmp
(confdir->cellName, cellentry->cellInfo.name)) {
break;
}
}
if (cellentry == NULL) {
clientSt = ADMCFGCLIENTCELLNOTINDB;
} else if (cellentry->cellInfo.numServers <= 0) {
clientSt = ADMCFGCLIENTCELLHASNODBENTRIES;
}
}
if (tst == 0 && clientSt == 0) {
/* everything looks good; malloc cell name buffer to return */
clientCellName = strdup(cellentry->cellInfo.name);
if (clientCellName == NULL)
tst = ADMNOMEM;
}
(void)afsconf_Close(confdir);
}
}
/* return result of query */
if (tst == 0) {
/* return client status and cell name */
*isInstalledP = cmInstalled;
*versionP = cmVersion;
*configStP = clientSt;
if (clientSt == 0) {
*cellNameP = clientCellName;
} else {
*cellNameP = NULL;
}
} else {
/* indicate failure */
rc = 0;
/* free cell name if allocated before failure */
if (clientCellName != NULL) {
free(clientCellName);
}
}
if (st != NULL) {
*st = tst;
}
return rc;
}
static int
_GetLocalSecurityObject(struct afscp_cell *cell,
char *aname, char *ainst)
{
int code = 0;
char tbuffer[256];
struct ktc_encryptionKey key, session;
struct rx_securityClass *tc;
afs_int32 kvno;
afs_int32 ticketLen;
rxkad_level lev;
struct afsconf_dir *tdir;
tdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH);
if (!tdir) {
code = AFSCONF_FAILURE;
goto done;
}
code = afsconf_GetLatestKey(tdir, &kvno, &key);
if (code) {
goto done;
}
DES_init_random_number_generator((DES_cblock *)&key);
code = DES_new_random_key((DES_cblock *)&session);
if (code) {
goto done;
}
ticketLen = sizeof(tbuffer);
memset(tbuffer, 0, sizeof(tbuffer));
code = tkt_MakeTicket(tbuffer, &ticketLen, &key, aname, ainst, "", 0,
0xffffffff, &session, 0, "afs", "");
if (code) {
goto done;
}
if (insecure) {
lev = rxkad_clear;
} else {
lev = rxkad_crypt;
}
tc = (struct rx_securityClass *)
rxkad_NewClientSecurityObject(lev, &session, kvno, ticketLen,
tbuffer);
if (!tc) {
code = RXKADBADKEY;
goto done;
}
cell->security = tc;
cell->scindex = 2;
done:
if (tdir) {
afsconf_Close(tdir);
}
return code;
}
afs_int32
pr_Initialize(IN afs_int32 secLevel, IN const char *confDir, IN char *cell)
{
afs_int32 code;
struct rx_connection *serverconns[MAXSERVERS];
struct rx_securityClass *sc = NULL;
static struct afsconf_dir *tdir = (struct afsconf_dir *)NULL; /* only do this once */
static char tconfDir[100] = "";
static char tcell[64] = "";
afs_int32 scIndex;
afs_int32 secFlags;
static struct afsconf_cell info;
afs_int32 i;
#if !defined(UKERNEL)
char cellstr[64];
#endif
afs_int32 gottdir = 0;
afs_int32 refresh = 0;
initialize_PT_error_table();
initialize_RXK_error_table();
initialize_ACFG_error_table();
initialize_KTC_error_table();
#if defined(UKERNEL)
if (!cell) {
cell = afs_LclCellName;
}
#else /* defined(UKERNEL) */
if (!cell) {
if (!tdir)
tdir = afsconf_Open(confDir);
if (!tdir) {
if (confDir && strcmp(confDir, ""))
fprintf(stderr,
"%s: Could not open configuration directory: %s.\n",
whoami, confDir);
else
fprintf(stderr,
"%s: No configuration directory specified.\n",
whoami);
return -1;
}
gottdir = 1;
code = afsconf_GetLocalCell(tdir, cellstr, sizeof(cellstr));
if (code) {
fprintf(stderr,
"libprot: Could not get local cell. [%d]\n", code);
return code;
}
cell = cellstr;
}
#endif /* defined(UKERNEL) */
if (tdir == NULL || strcmp(confDir, tconfDir) || strcmp(cell, tcell)) {
/*
* force re-evaluation. we either don't have an afsconf_dir,
* the directory has changed or the cell has changed.
*/
if (tdir && !gottdir) {
afsconf_Close(tdir);
tdir = (struct afsconf_dir *)NULL;
}
pruclient = (struct ubik_client *)NULL;
refresh = 1;
}
if (refresh) {
strncpy(tconfDir, confDir, sizeof(tconfDir));
strncpy(tcell, cell, sizeof(tcell));
#if defined(UKERNEL)
tdir = afs_cdir;
#else /* defined(UKERNEL) */
if (!gottdir)
tdir = afsconf_Open(confDir);
if (!tdir) {
if (confDir && strcmp(confDir, ""))
fprintf(stderr,
"libprot: Could not open configuration directory: %s.\n",
confDir);
else
fprintf(stderr,
"libprot: No configuration directory specified.\n");
return -1;
}
#endif /* defined(UKERNEL) */
code = afsconf_GetCellInfo(tdir, cell, "afsprot", &info);
if (code) {
fprintf(stderr, "libprot: Could not locate cell %s in %s/%s\n",
cell, confDir, AFSDIR_CELLSERVDB_FILE);
return code;
}
}
/* If we already have a client and it is at the security level we
* want, don't get a new one. Unless the security level is 2 in
* which case we will get one (and re-read the key file).
*/
if (pruclient && (lastLevel == secLevel) && (secLevel != 2)) {
return 0;
}
code = rx_Init(0);
if (code) {
fprintf(stderr, "libprot: Could not initialize rx.\n");
return code;
}
/* Most callers use secLevel==1, however, the fileserver uses secLevel==2
* to force use of the KeyFile. secLevel == 0 implies -noauth was
* specified. */
if (secLevel == 2) {
code = afsconf_GetLatestKey(tdir, 0, 0);
if (code) {
afs_com_err(whoami, code, "(getting key from local KeyFile)\n");
} else {
/* If secLevel is two assume we're on a file server and use
* ClientAuthSecure if possible. */
code = afsconf_ClientAuthSecure(tdir, &sc, &scIndex);
if (code)
afs_com_err(whoami, code, "(calling client secure)\n");
}
} else if (secLevel > 0) {
secFlags = 0;
if (secLevel > 1)
secFlags |= AFSCONF_SECOPTS_ALWAYSENCRYPT;
code = afsconf_ClientAuthToken(&info, secFlags, &sc, &scIndex, NULL);
if (code) {
afs_com_err(whoami, code, "(getting token)");
if (secLevel > 1)
return code;
}
}
if (sc == NULL) {
sc = rxnull_NewClientSecurityObject();
scIndex = RX_SECIDX_NULL;
}
if ((scIndex == RX_SECIDX_NULL) && (secLevel != 0))
fprintf(stderr,
"%s: Could not get afs tokens, running unauthenticated\n",
whoami);
memset(serverconns, 0, sizeof(serverconns)); /* terminate list!!! */
for (i = 0; i < info.numServers; i++)
serverconns[i] =
rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
info.hostAddr[i].sin_port, PRSRV, sc,
scIndex);
code = ubik_ClientInit(serverconns, &pruclient);
if (code) {
afs_com_err(whoami, code, "ubik client init failed.");
return code;
}
lastLevel = scIndex;
code = rxs_Release(sc);
return code;
}
/*!
* \brief Get the appropriate type of ubik client structure out from the system.
*/
afs_int32
ugen_ClientInit(int noAuthFlag, const char *confDir, char *cellName, afs_int32 sauth,
struct ubik_client **uclientp,
int (*secproc) (struct rx_securityClass *, afs_int32),
char *funcName, afs_int32 gen_rxkad_level,
afs_int32 maxservers, char *serviceid, afs_int32 deadtime,
afs_uint32 server, afs_uint32 port, afs_int32 usrvid)
{
afs_int32 code, secFlags, i;
afs_int32 scIndex;
struct afsconf_cell info;
struct afsconf_dir *tdir;
struct rx_securityClass *sc;
/* This must change if VLDB_MAXSERVERS becomes larger than MAXSERVERS */
static struct rx_connection *serverconns[MAXSERVERS];
code = rx_Init(0);
if (code) {
fprintf(stderr, "%s: could not initialize rx.\n", funcName);
return code;
}
rx_SetRxDeadTime(deadtime);
secFlags = AFSCONF_SECOPTS_FALLBACK_NULL;
if (sauth) {
secFlags |= AFSCONF_SECOPTS_LOCALAUTH;
confDir = AFSDIR_SERVER_ETC_DIRPATH;
} else {
if (confDir == NULL)
confDir = AFSDIR_CLIENT_ETC_DIRPATH;
}
if (noAuthFlag) {
secFlags |= AFSCONF_SECOPTS_NOAUTH;
}
tdir = afsconf_Open(confDir);
if (!tdir) {
fprintf(stderr,
"%s: Could not process files in configuration directory (%s).\n",
funcName, confDir);
return -1;
}
if (sauth)
cellName = tdir->cellName;
code = afsconf_GetCellInfo(tdir, cellName, serviceid, &info);
if (code) {
afsconf_Close(tdir);
fprintf(stderr, "%s: can't find cell %s's hosts in %s/%s\n",
funcName, cellName, confDir, AFSDIR_CELLSERVDB_FILE);
return -1;
}
code = afsconf_PickClientSecObj(tdir, secFlags, &info, cellName, &sc,
&scIndex, NULL);
if (code) {
fprintf(stderr, "%s: can't create client security object", funcName);
return -1;
}
if (scIndex == RX_SECIDX_NULL && !noAuthFlag) {
fprintf(stderr,
"%s: Could not get afs tokens, running unauthenticated.\n",
funcName);
}
afsconf_Close(tdir);
if (secproc) /* tell UV module about default authentication */
(*secproc) (sc, scIndex);
if (server) {
serverconns[0] = rx_NewConnection(server, port,
usrvid, sc, scIndex);
} else {
if (info.numServers > maxservers) {
fprintf(stderr,
"%s: info.numServers=%d (> maxservers=%d)\n",
funcName, info.numServers, maxservers);
return -1;
}
for (i = 0; i < info.numServers; i++) {
if (!info.hostAddr[i].sin_port && port)
info.hostAddr[i].sin_port = port;
serverconns[i] =
rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
info.hostAddr[i].sin_port, usrvid,
sc, scIndex);
}
}
/* Are we just setting up connections, or is this really ubik stuff? */
if (uclientp) {
*uclientp = 0;
code = ubik_ClientInit(serverconns, uclientp);
if (code) {
fprintf(stderr, "%s: ubik client init failed.\n", funcName);
return code;
}
}
return 0;
}
int
main(int argc, char **argv)
{
char localName[64];
register afs_int32 code;
register char *cname;
struct afsconf_dir *tdir;
struct ktc_principal tserver;
struct ktc_token token;
strcpy(whoami, argv[0]);
if (argc <= 1) {
printf
("%s: copies a file system ticket from the local cell to another cell\n",
whoami);
printf("%s: usage is 'setauth <new-cell>\n", whoami);
exit(1);
}
cname = argv[1];
/* lookup the name of the local cell */
tdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH);
if (!tdir) {
printf("copyauth: can't open dir %s\n", AFSDIR_CLIENT_ETC_DIRPATH);
exit(1);
}
code = afsconf_GetLocalCell(tdir, localName, sizeof(localName));
if (code) {
printf("%s: can't determine local cell name\n", whoami);
exit(1);
}
/* done with configuration stuff now */
afsconf_Close(tdir);
/* get ticket in local cell */
strcpy(tserver.cell, localName);
strcpy(tserver.name, "afs");
tserver.instance[0] = 0;
code = ktc_GetToken(&tserver, &token, sizeof(token), NULL);
if (code) {
printf
("%s: failed to get '%s' service ticket in cell '%s' (code %d)\n",
whoami, tserver.name, tserver.cell, code);
exit(1);
}
/* and now set the ticket in the new cell */
strcpy(tserver.cell, argv[1]);
code = ktc_SetToken(&tserver, &token, NULL, 0);
if (code) {
printf
("%s: failed to set ticket (code %d), are you sure you're authenticated?\n",
whoami, code);
exit(1);
}
/* all done */
printf("Authentication established for cell %s.\n", cname);
exit(0);
}
void CloseConf(struct afsconf_dir **pconfigdir)
{
(void) afsconf_Close(*pconfigdir);
}
afs_int32
udbClientInit(int noAuthFlag, int localauth, char *cellName)
{
struct afsconf_cell info;
struct afsconf_dir *acdir;
const char *confdir;
int i;
afs_int32 secFlags;
afs_int32 code = 0;
secFlags = parseSecFlags(noAuthFlag, localauth, &confdir);
secFlags |= AFSCONF_SECOPTS_FALLBACK_NULL;
if (cellName && cellName[0] == '\0')
cellName = NULL;
acdir = afsconf_Open(confdir);
if (!acdir) {
afs_com_err(whoami, 0, "Can't open configuration directory '%s'",
confdir);
ERROR(BC_NOCELLCONFIG);
}
code = afsconf_GetCellInfo(acdir, cellName, 0, &info);
if (code) {
afs_com_err(whoami, code, "; Can't find cell %s's hosts in %s",
cellName, acdir->cellservDB);
ERROR(BC_NOCELLCONFIG);
}
code = afsconf_PickClientSecObj(acdir, secFlags, &info, cellName,
&udbHandle.uh_secobj,
&udbHandle.uh_scIndex, NULL);
if (code) {
afs_com_err(whoami, code, "(configuring connection security)");
ERROR(BC_NOCELLCONFIG);
}
if (udbHandle.uh_scIndex == RX_SECIDX_NULL && !noAuthFlag)
afs_com_err(whoami, 0, "Can't get tokens - running unauthenticated");
/* We have to have space for the trailing NULL that terminates the server
* conneciton array - so we can only store MAXSERVERS-1 real elements in
* that array.
*/
if (info.numServers >= MAXSERVERS) {
afs_com_err(whoami, 0,
"Warning: %d BDB servers exist for cell '%s', can only remember the first %d",
info.numServers, cellName, MAXSERVERS-1);
info.numServers = MAXSERVERS - 1;
}
/* establish connections to the servers. Check for failed connections? */
for (i = 0; i < info.numServers; i++) {
udbHandle.uh_serverConn[i] =
rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
htons(AFSCONF_BUDBPORT), BUDB_SERVICE,
udbHandle.uh_secobj, udbHandle.uh_scIndex);
}
udbHandle.uh_serverConn[i] = 0;
code = ubik_ClientInit(udbHandle.uh_serverConn, &udbHandle.uh_client);
if (code) {
afs_com_err(whoami, code,
"; Can't initialize ubik connection to backup database");
ERROR(code);
}
/* Try to quickly find a good site by setting deadtime low */
for (i = 0; i < info.numServers; i++)
rx_SetConnDeadTime(udbHandle.uh_client->conns[i], 1);
code =
ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
&udbHandle.uh_instanceId);
/* Reset dead time back up to default */
for (i = 0; i < info.numServers; i++)
rx_SetConnDeadTime(udbHandle.uh_client->conns[i], 60);
/* If did not find a site on first quick pass, try again */
if (code == -1)
code =
ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
&udbHandle.uh_instanceId);
if (code) {
afs_com_err(whoami, code, "; Can't access backup database");
ERROR(code);
}
error_exit:
if (acdir)
afsconf_Close(acdir);
return (code);
}
/* vldbClientInit
* Initialize a client for the vl ubik database.
*/
int
vldbClientInit(int noAuthFlag, int localauth, char *cellName,
struct ubik_client **cstruct,
time_t *expires)
{
afs_int32 code = 0;
struct afsconf_dir *acdir;
struct rx_securityClass *sc;
afs_int32 i, scIndex = RX_SECIDX_NULL;
struct afsconf_cell info;
struct rx_connection *serverconns[VLDB_MAXSERVERS];
afsconf_secflags secFlags;
const char *confdir;
secFlags = parseSecFlags(noAuthFlag, localauth, &confdir);
secFlags |= AFSCONF_SECOPTS_FALLBACK_NULL;
/* This just preserves old behaviour of using the default cell when
* passed an empty string */
if (cellName && cellName[0] == '\0')
cellName = NULL;
/* Find out about the given cell */
acdir = afsconf_Open(confdir);
if (!acdir) {
afs_com_err(whoami, 0, "Can't open configuration directory '%s'", confdir);
ERROR(BC_NOCELLCONFIG);
}
code = afsconf_GetCellInfo(acdir, cellName, AFSCONF_VLDBSERVICE, &info);
if (code) {
afs_com_err(whoami, code, "; Can't find cell %s's hosts in %s",
cellName, acdir->cellservDB);
ERROR(BC_NOCELLCONFIG);
}
code = afsconf_PickClientSecObj(acdir, secFlags, &info, cellName,
&sc, &scIndex, expires);
if (code) {
afs_com_err(whoami, code, "(configuring connection security)");
ERROR(BC_NOCELLCONFIG);
}
if (scIndex == RX_SECIDX_NULL && !noAuthFlag)
afs_com_err(whoami, 0, "Can't get tokens - running unauthenticated");
/* tell UV module about default authentication */
UV_SetSecurity(sc, scIndex);
if (info.numServers > VLDB_MAXSERVERS) {
afs_com_err(whoami, 0,
"Warning: %d VLDB servers exist for cell '%s', can only remember the first %d",
info.numServers, cellName, VLDB_MAXSERVERS);
info.numServers = VLDB_MAXSERVERS;
}
for (i = 0; i < info.numServers; i++)
serverconns[i] =
rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
info.hostAddr[i].sin_port, USER_SERVICE_ID, sc,
scIndex);
serverconns[i] = 0;
*cstruct = 0;
code = ubik_ClientInit(serverconns, cstruct);
if (code) {
afs_com_err(whoami, code, "; Can't initialize ubik connection to vldb");
ERROR(code);
}
error_exit:
if (acdir)
afsconf_Close(acdir);
return (code);
}
afs_uint32
xfon_voldump(XFILE * X, int flag, char *name)
{
struct hostent *he;
struct rx_securityClass *class;
struct rx_connection *conn;
struct ktc_principal sname;
struct ktc_token token;
struct afsconf_dir *confdir;
afs_uint32 code, server_addr = 0;
afs_int32 volid, date, partid = 0;
int isnum, index;
char *x, *y;
/* Parse out the optional date and server location */
if ((code = rx_Init(0)))
return code;
if (!(name = strdup(name)))
return ENOMEM;
if ((x = strrchr(name, ','))) {
*x++ = 0;
date = atoi(x);
} else {
date = 0;
}
if ((x = strrchr(name, '@'))) {
int a, b, c, d;
*x++ = 0;
if (!(y = strchr(x, '/'))) {
free(name);
return VL_BADPARTITION;
}
*y++ = 0;
if (sscanf(x, "%d.%d.%d.%d", &a, &b, &c, &d) == 4 && a >= 0
&& a <= 255 && b >= 0 && b <= 255 && c >= 0 && c <= 255 && d >= 0
&& d <= 255) {
server_addr = (a << 24) | (b << 16) | (c << 8) | d;
server_addr = htonl(server_addr);
} else {
he = gethostbyname(x);
if (!he) {
free(name);
return VL_BADSERVER;
}
memcpy(&server_addr, he->h_addr, sizeof(server_addr));
}
partid = volutil_GetPartitionID(y);
if (partid < 0) {
free(name);
return VL_BADPARTITION;
}
}
/* Get tokens and set up a security object */
confdir = afsconf_Open(AFSCONF_CLIENTNAME);
if (!confdir) {
free(name);
return AFSCONF_NODB;
}
if ((code = afsconf_GetLocalCell(confdir, sname.cell, MAXKTCNAMELEN))) {
free(name);
return code;
}
afsconf_Close(confdir);
strcpy(sname.name, "afs");
sname.instance[0] = 0;
code = ktc_GetToken(&sname, &token, sizeof(token), 0);
if (code) {
class = rxnull_NewClientSecurityObject();
index = 0;
} else {
/*
* cfg_HostQueryStatus() -- Query status of static server configuration
* on host, i.e., status of required configuration files, etc.
* Upon successful completion *configStP is set to the server
* configuration status, with a value of zero (0) indicating that
* the configuration is valid.
*
* If server configuration is not valid then *cellNameP is set to NULL;
* otherwise, *cellNameP is an allocated buffer containing server cell.
*
* Warning: in determining if server configuration is valid, no check
* is made for consistency with other servers in cell; also, the
* internal consistency of configuration files may not be verified.
*/
int ADMINAPI
cfg_HostQueryStatus(const char *hostName, /* name of host */
afs_status_p configStP, /* server config status */
char **cellNameP, /* server's cell */
afs_status_p st)
{ /* completion status */
int rc = 1;
afs_status_t tst2, tst = 0;
afs_status_t serverSt = 0;
char *serverCellName = NULL;
/* validate parameters */
if (hostName == NULL || *hostName == '\0') {
tst = ADMCFGHOSTNAMENULL;
} else if (strlen(hostName) > (MAXHOSTCHARS - 1)) {
tst = ADMCFGHOSTNAMETOOLONG;
} else if (configStP == NULL) {
tst = ADMCFGCONFIGSTATUSPNULL;
} else if (cellNameP == NULL) {
tst = ADMCFGCELLNAMEPNULL;
}
/* remote configuration not yet supported; hostName must be local host */
if (tst == 0) {
short isLocal;
if (!cfgutil_HostNameIsLocal(hostName, &isLocal, &tst2)) {
tst = tst2;
} else if (!isLocal) {
tst = ADMCFGNOTSUPPORTED;
}
}
/* check for existence and readability of required server config files */
if (tst == 0) {
int i;
const char *cfgfile[4];
cfgfile[0] = AFSDIR_SERVER_THISCELL_FILEPATH;
cfgfile[1] = AFSDIR_SERVER_CELLSERVDB_FILEPATH;
cfgfile[2] = AFSDIR_SERVER_KEY_FILEPATH;
cfgfile[3] = AFSDIR_SERVER_ULIST_FILEPATH;
for (i = 0; i < 4; i++) {
int fd;
if ((fd = open(cfgfile[i], O_RDONLY)) < 0) {
break;
}
(void)close(fd);
}
if (i < 4) {
if (errno == EACCES) {
tst = ADMNOPRIV;
} else {
serverSt = ADMCFGSERVERBASICINFOINVALID;
}
}
}
/* verify the required server config files to the degree possible */
if (tst == 0 && serverSt == 0) {
struct afsconf_dir *confdir;
if ((confdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH)) == NULL) {
/* one or more config files appears to be invalid */
serverSt = ADMCFGSERVERBASICINFOINVALID;
} else {
struct afsconf_entry *cellentry;
if (confdir->cellName == NULL || *confdir->cellName == '\0') {
/* no cell set for server */
serverSt = ADMCFGSERVERNOTINCELL;
} else if (confdir->keystr == NULL || confdir->keystr->nkeys == 0) {
/* no server keys */
serverSt = ADMCFGSERVERNOKEYS;
} else {
for (cellentry = confdir->entries; cellentry != NULL;
cellentry = cellentry->next) {
if (!strcasecmp
(confdir->cellName, cellentry->cellInfo.name)) {
break;
}
}
if (cellentry == NULL) {
serverSt = ADMCFGSERVERCELLNOTINDB;
} else if (cellentry->cellInfo.numServers <= 0) {
serverSt = ADMCFGSERVERCELLHASNODBENTRIES;
}
}
if (tst == 0 && serverSt == 0) {
/* everything looks good; malloc cell name buffer to return */
serverCellName =
(char *)malloc(strlen(cellentry->cellInfo.name) + 1);
if (serverCellName == NULL) {
tst = ADMNOMEM;
} else {
strcpy(serverCellName, cellentry->cellInfo.name);
}
}
(void)afsconf_Close(confdir);
}
}
if (tst == 0) {
/* return server status and cell name */
*configStP = serverSt;
if (serverSt == 0) {
*cellNameP = serverCellName;
} else {
*cellNameP = NULL;
}
} else {
/* indicate failure */
rc = 0;
/* free cell name if allocated before failure */
if (serverCellName != NULL) {
free(serverCellName);
}
}
if (st != NULL) {
*st = tst;
}
return rc;
}
