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; }