afs_int32
pxclient_Initialize(int auth, afs_int32 serverAddr)
{
afs_int32 code;
rx_securityIndex scIndex;
struct rx_securityClass *sc;
code = rx_Init(htons(2115) /*0 */ );
if (code) {
fprintf(stderr, "pxclient_Initialize: Could not initialize rx.\n");
return code;
}
scIndex = RX_SECIDX_NULL;
rx_SetRxDeadTime(50);
sc = rxnull_NewClientSecurityObject();
serverconns[0] =
rx_NewConnection(serverAddr, htons(7000), 1, sc, scIndex);
code = ubik_ClientInit(serverconns, &cstruct);
if (code) {
fprintf(stderr, "pxclient_Initialize: ubik client init failed.\n");
return code;
}
return 0;
}
int
udbLocalInit(void)
{
afs_uint32 serverList[MAXSERVERS];
char hostname[256];
char *args[3];
int i;
afs_int32 code;
/* get our host name */
gethostname(hostname, sizeof(hostname));
/* strcpy(hostname, "hops"); */
args[0] = "";
args[1] = "-servers";
args[2] = hostname;
code = ubik_ParseClientList(3, args, serverList);
if (code) {
afs_com_err(whoami, code, "; udbLocalInit: parsing ubik server list");
return (-1);
}
udbHandle.uh_scIndex = RX_SECIDX_NULL;
udbHandle.uh_secobj = (struct rx_securityClass *)
rxnull_NewClientSecurityObject();
for (i = 0; serverList[i] != 0; i++) {
udbHandle.uh_serverConn[i] =
rx_NewConnection(serverList[i], htons(AFSCONF_BUDBPORT),
BUDB_SERVICE, udbHandle.uh_secobj,
udbHandle.uh_scIndex);
if (udbHandle.uh_serverConn[i] == 0) {
afs_com_err(whoami, 0, "connection %d failed", i);
continue;
}
}
udbHandle.uh_serverConn[i] = 0;
code = ubik_ClientInit(udbHandle.uh_serverConn, &udbHandle.uh_client);
if (code) {
afs_com_err(whoami, code, "; in ubik_ClientInit");
return (code);
}
code =
ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
&udbHandle.uh_instanceId);
if (code) {
afs_com_err(whoami, code, "; Can't estblish instance Id");
return (code);
}
/* abort: */
return (0);
}
static int
whoami(struct ktc_token *atoken,
struct afsconf_cell *cellconfig,
struct ktc_principal *aclient,
int *vicep)
{
int scIndex;
int code;
int i;
struct ubik_client *ptconn = 0;
struct rx_securityClass *sc;
struct rx_connection *conns[MAXSERVERS+1];
idlist lids[1];
namelist lnames[1];
char tempname[PR_MAXNAMELEN + 1];
memset(lnames, 0, sizeof *lnames);
memset(lids, 0, sizeof *lids);
scIndex = 2;
sc = rxkad_NewClientSecurityObject(rxkad_auth,
&atoken->sessionKey, atoken->kvno,
atoken->ticketLen, atoken->ticket);
for (i = 0; i < cellconfig->numServers; ++i)
conns[i] = rx_NewConnection(cellconfig->hostAddr[i].sin_addr.s_addr,
cellconfig->hostAddr[i].sin_port, PRSRV, sc, scIndex);
conns[i] = 0;
ptconn = 0;
if ((code = ubik_ClientInit(conns, &ptconn)))
goto Failed;
if (*aclient->instance)
snprintf (tempname, sizeof tempname, "%s.%s",
aclient->name, aclient->instance);
else
snprintf (tempname, sizeof tempname, "%s", aclient->name);
lnames->namelist_len = 1;
lnames->namelist_val = (prname *) tempname;
code = ubik_PR_NameToID(ptconn, 0, lnames, lids);
if (lids->idlist_val) {
*vicep = *lids->idlist_val;
}
Failed:
if (lids->idlist_val) free(lids->idlist_val);
if (ptconn) ubik_ClientDestroy(ptconn);
return code;
}
afs_int32
pxclient_Initialize(int auth, afs_int32 serverAddr)
{
afs_int32 code;
afs_int32 scIndex;
struct rx_securityClass *sc;
code = rx_Init(htons(2115) /*0 */ );
if (code) {
fprintf(stderr, "pxclient_Initialize: Could not initialize rx.\n");
return code;
}
scIndex = 0;
rx_SetRxDeadTime(50);
switch (scIndex) {
case 0:
sc = rxnull_NewClientSecurityObject();
break;
#ifdef notdef /* security */
case 1:
sc = rxvab_NewClientSecurityObject(&ttoken.sessionKey, ttoken.ticket,
0);
break;
case 2:
sc = rxkad_NewClientSecurityObject(rxkad_clear, &ttoken.sessionKey,
ttoken.kvno, ttoken.ticketLen,
ttoken.ticket);
#endif /* notdef */
}
serverconns[0] =
rx_NewConnection(serverAddr, htons(7000), 1, sc, scIndex);
code = ubik_ClientInit(serverconns, &cstruct);
if (code) {
fprintf(stderr, "pxclient_Initialize: ubik client init failed.\n");
return code;
}
return 0;
}
int
_GetVLservers(struct afscp_cell *cell)
{
struct rx_connection *conns[MAXHOSTSPERCELL + 1];
int i;
int code;
struct afsconf_cell celldata;
code = _GetCellInfo(cell->name, &celldata);
if (code != 0) {
return code;
}
for (i = 0; i < celldata.numServers; i++) {
conns[i] = rx_NewConnection(celldata.hostAddr[i].sin_addr.s_addr,
htons(AFSCONF_VLDBPORT),
USER_SERVICE_ID, cell->security,
cell->scindex);
}
conns[i] = 0;
return ubik_ClientInit(conns, &cell->vlservers);
}
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;
}
static afs_int32
InitThisModule(int a_noAuthFlag, char *a_confDir, char *a_cellName)
{ /*InitThisModule */
#ifdef USS_VOL_DB
static char rn[] = "uss_vol:InitThisModule";
#endif
afs_int32 code; /*Return code */
struct afsconf_dir *tdir; /*Ptr to conf dir info */
struct afsconf_cell info; /*Info about chosen cell */
afs_int32 scIndex; /*Chosen security index */
afs_int32 secFlags;
struct rx_securityClass *sc; /*Generated security object */
afs_int32 i; /*Loop index */
/*
* Only once, guys, will 'ya?
*/
if (initDone) {
#ifdef USS_VOL_DB
printf("[%s] Called multiple times!\n", rn);
#endif /* USS_VOL_DB */
return (0);
}
/*
* Set up our Rx environment.
*/
#ifdef USS_VOL_DB
printf("[%s] Initializing Rx environment\n", rn);
#endif /* USS_VOL_DB */
code = rx_Init(0);
if (code) {
fprintf(stderr, "%s: Couldn't initialize Rx.\n", uss_whoami);
return (code);
}
rx_SetRxDeadTime(50);
/*
* Find out all about our configuration.
*/
#ifdef USS_VOL_DB
printf("[%s] Handling configuration info\n", rn);
#endif /* USS_VOL_DB */
tdir = afsconf_Open(a_confDir);
if (!tdir) {
fprintf(stderr, "%s: Couldn't open configuration directory (%s).\n",
uss_whoami, a_confDir);
return (-1);
}
code = afsconf_GetCellInfo(tdir, a_cellName, AFSCONF_VLDBSERVICE, &info);
if (code) {
printf("%s: Can't find VLDB server(s) for cell %s\n", uss_whoami,
a_cellName);
exit(1);
}
#ifdef USS_VOL_DB
printf("[%s] Getting tickets if needed\n", rn);
#endif /* USS_VOL_DB */
secFlags = AFSCONF_SECOPTS_FALLBACK_NULL;
if (a_noAuthFlag)
secFlags |= AFSCONF_SECOPTS_NOAUTH;
code = afsconf_PickClientSecObj(tdir, secFlags, &info, a_cellName,
&sc, &scIndex, NULL);
if (code) {
printf("%s: Can't create client security object\n", uss_whoami);
exit(1);
}
if (scIndex == RX_SECIDX_NULL && !a_noAuthFlag) {
fprintf(stderr,
"%s: Couldn't get AFS tokens, running unauthenticated.\n",
uss_whoami);
}
/*
* Tell UV module about default authentication.
*/
#ifdef USS_VOL_DB
printf("[%s] Setting UV security: obj 0x%x, index %d\n", rn, sc, scIndex);
#endif /* USS_VOL_DB */
UV_SetSecurity(sc, scIndex);
if (info.numServers > VLDB_MAXSERVERS) {
fprintf(stderr, "%s: info.numServers=%d (> VLDB_MAXSERVERS=%d)\n",
uss_whoami, info.numServers, VLDB_MAXSERVERS);
exit(1);
}
/*
* Connect to each VLDB server for the chosen cell.
*/
for (i = 0; i < info.numServers; i++) {
#ifdef USS_VOL_DB
printf
("[%s] Connecting to VLDB server 0x%x, port %d, service id %d\n",
rn, info.hostAddr[i].sin_addr.s_addr, info.hostAddr[i].sin_port,
USER_SERVICE_ID);
#endif /* USS_VOL_DB */
serverconns[i] =
rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
info.hostAddr[i].sin_port, USER_SERVICE_ID, sc,
scIndex);
}
/*
* Set up to execute Ubik transactions on the VLDB.
*/
#ifdef USS_VOL_DB
printf("[%s] Initializing Ubik interface\n", rn);
#endif /* USS_VOL_DB */
code = ubik_ClientInit(serverconns, &uconn_vldbP);
if (code) {
fprintf(stderr, "%s: Ubik client init failed.\n", uss_whoami);
return (code);
}
#ifdef USS_VOL_DB
printf("[%s] VLDB ubik connection structure at 0x%x\n", rn, uconn_vldbP);
#endif /* USS_VOL_DB */
/*
* Place the ubik VLDB connection structure in its advertised
* location.
*/
cstruct = uconn_vldbP;
/*
* Success!
*/
initDone = 1;
return (0);
} /*InitThisModule */
int
main(int argc, char **argv)
{
register afs_int32 code;
struct ubik_client *cstruct = 0;
afs_uint32 serverList[MAXSERVERS];
struct rx_connection *serverconns[MAXSERVERS];
struct rx_securityClass *sc;
register afs_int32 i;
afs_int32 temp;
if (argc == 1) {
printf
("uclient: usage is 'uclient -servers ... [-try] [-get] [-inc] [-minc] [-trunc]\n");
exit(0);
}
#ifdef AFS_NT40_ENV
/* initialize winsock */
if (afs_winsockInit() < 0)
return -1;
#endif
/* first parse '-servers <server-1> <server-2> ... <server-n>' from command line */
code = ubik_ParseClientList(argc, argv, serverList);
if (code) {
printf("could not parse server list, code %d\n", code);
exit(1);
}
rx_Init(0);
sc = rxnull_NewClientSecurityObject();
for (i = 0; i < MAXSERVERS; i++) {
if (serverList[i]) {
serverconns[i] =
rx_NewConnection(serverList[i], htons(3000), USER_SERVICE_ID,
sc, 0);
} else {
serverconns[i] = (struct rx_connection *)0;
break;
}
}
/* next, pass list of server rx_connections (in serverconns), and
* a place to put the returned client structure that we'll use in
* all of our rpc calls (via ubik_Calll) */
code = ubik_ClientInit(serverconns, &cstruct);
/* check code from init */
if (code) {
printf("ubik client init failed with code %d\n", code);
exit(1);
}
/* parse command line for our own operations */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-inc")) {
/* use ubik_Call to do the work, finding an up server and handling
* the job of finding a sync site, if need be */
code = ubik_SAMPLE_Inc(cstruct, 0);
printf("return code is %d\n", code);
} else if (!strcmp(argv[i], "-try")) {
code = ubik_SAMPLE_Test(cstruct, 0);
printf("return code is %d\n", code);
} else if (!strcmp(argv[i], "-qget")) {
code = ubik_SAMPLE_QGet(cstruct, 0, &temp);
printf("got quick value %d (code %d)\n", temp, code);
} else if (!strcmp(argv[i], "-get")) {
code = ubik_SAMPLE_Get(cstruct, 0, &temp);
printf("got value %d (code %d)\n", temp, code);
} else if (!strcmp(argv[i], "-trunc")) {
code = ubik_SAMPLE_Trun(cstruct, 0);
printf("return code is %d\n", code);
} else if (!strcmp(argv[i], "-minc")) {
afs_int32 temp;
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;
printf("ubik_client: Running minc...\n");
while (1) {
temp = 0;
code = ubik_SAMPLE_Get(cstruct, 0, &temp);
if (code != 0) {
printf("SAMPLE_Get #1 failed with code %ld\n",
afs_printable_int32_ld(code));
} else {
printf("SAMPLE_Get #1 succeeded, got value %ld\n",
afs_printable_int32_ld(temp));
}
temp = 0;
code = ubik_SAMPLE_Inc(cstruct, 0);
if (code != 0) {
printf("SAMPLE_Inc #1 failed with code %ld\n",
afs_printable_int32_ld(code));
} else {
printf("SAMPLE_Inc #1 succeeded, incremented integer\n");
}
temp = 0;
code = ubik_SAMPLE_Get(cstruct, 0, &temp);
if (code != 0) {
printf("SAMPLE_Get #2 failed with code %ld\n",
afs_printable_int32_ld(code));
} else {
printf("SAMPLE_Get #2 succeeded, got value %ld\n",
afs_printable_int32_ld(temp));
}
temp = 0;
code = ubik_SAMPLE_Inc(cstruct, 0);
if (code != 0)
printf("SAMPLE_Inc #2 failed with code %ld\n",
afs_printable_int32_ld(code));
else
printf("SAMPLE_Inc #2 succeeded, incremented integer\n");
tv.tv_sec = 1;
tv.tv_usec = 0;
#ifdef AFS_PTHREAD_ENV
select(0, 0, 0, 0, &tv);
#else
IOMGR_Select(0, 0, 0, 0, &tv);
#endif
printf("Repeating the SAMPLE operations again...\n");
}
} else if (!strcmp(argv[i], "-mget")) {
afs_int32 temp;
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;
while (1) {
code = ubik_SAMPLE_Get(cstruct, 0, &temp);
printf("got value %d (code %d)\n", temp, code);
code = ubik_SAMPLE_Inc(cstruct, 0);
printf("update return code is %d\n", code);
code = ubik_SAMPLE_Get(cstruct, 0, &temp);
printf("got value %d (code %d)\n", temp, code);
code = ubik_SAMPLE_Get(cstruct, 0, &temp);
printf("got value %d (code %d)\n", temp, code);
tv.tv_sec = 1;
tv.tv_usec = 0;
#ifdef AFS_PTHREAD_ENV
select(0, 0, 0, 0, &tv);
#else
IOMGR_Select(0, 0, 0, 0, &tv);
#endif
}
}
}
return 0;
}
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);
}
static int
internal_client_init(struct afsconf_dir *dir, struct afsconf_cell *info,
int secFlags, struct ubik_client **uclientp,
int (*secproc) (struct rx_securityClass *, afs_int32),
int maxservers, const char *serviceid, int deadtime,
afs_uint32 server, afs_uint32 port, afs_int32 usrvid)
{
int code, i;
afs_int32 scIndex;
struct rx_securityClass *sc;
/* This must change if VLDB_MAXSERVERS becomes larger than MAXSERVERS */
static struct rx_connection *serverconns[MAXSERVERS];
const char *progname;
progname = getprogname();
if (progname == NULL)
progname = "<unknown>";
code = rx_Init(0);
if (code) {
fprintf(stderr, "%s: could not initialize rx.\n", progname);
return code;
}
rx_SetRxDeadTime(deadtime);
code = afsconf_PickClientSecObj(dir, secFlags, info, NULL, &sc,
&scIndex, NULL);
if (code) {
fprintf(stderr, "%s: can't create client security object", progname);
return code;
}
if (scIndex == RX_SECIDX_NULL && !(secFlags & AFSCONF_SECOPTS_NOAUTH)) {
fprintf(stderr,
"%s: Could not get afs tokens, running unauthenticated.\n",
progname);
}
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",
progname, 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", progname);
return code;
}
return 0;
}