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