static ConnCacheEntry *
add_connection(int32_t cell,
uint32_t host,
uint16_t port,
uint16_t service,
int (*probe)(struct rx_connection *),
CredCacheEntry *ce)
{
ConnCacheEntry *e;
struct rx_securityClass *securityobj;
int securityindex;
nnpfs_pag_t cred;
if (ce) {
securityindex = ce->securityindex;
cred = ce->cred;
switch (ce->type) {
#ifdef KERBEROS
case CRED_KRB4 : {
struct cred_rxkad *cred = (struct cred_rxkad *)ce->cred_data;
securityobj = rxkad_NewClientSecurityObject(conn_rxkad_level,
cred->ct.HandShakeKey,
cred->ct.AuthHandle,
cred->ticket_len,
cred->ticket);
break;
}
#endif
case CRED_NONE :
securityobj = rxnull_NewClientSecurityObject ();
break;
default :
errx(1, "Unknown credentials type %d\n", ce->type);
}
} else {
securityobj = rxnull_NewClientSecurityObject ();
securityindex = 0;
cred = 0;
}
e = new_connection (cell, host, port, service,
cred, securityindex, probe, securityobj);
hashtabadd (connhtab, (void *)e);
++nactive_connections;
return e;
}
struct rx_securityClass *
get_sc(char *cellname)
{
#if 0
char realm[REALM_SZ];
CREDENTIALS c;
#endif
return rxnull_NewClientSecurityObject();
#if 0
ucstring(realm, cellname, REALM_SZ);
if (krb_get_cred("afs", "", realm, &c)) {
if (get_ad_tkt("afs", "", realm, DEFAULT_TKT_LIFE)) {
return NULL;
} else {
if (krb_get_cred("afs", "", realm, &c)) {
return NULL;
}
}
}
return rxkad_NewClientSecurityObject(rxkad_clear, c.session, c.kvno,
c.ticket_st.length, c.ticket_st.dat);
#endif
}
/**
* Pick a security object to use for a connection to a given server,
* by a given user
*
* @param[in] conn
* The AFS connection for which the security object is required
* @param[out] secLevel
* The security level of the returned object
*
* @return
* An rx security object. This function is guaranteed to return
* an object, although that object may be rxnull (with a secLevel
* of 0)
*/
static struct rx_securityClass *
afs_pickSecurityObject(struct afs_conn *conn, int *secLevel)
{
struct rx_securityClass *secObj = NULL;
union tokenUnion *token;
/* Do we have tokens ? */
if (conn->parent->user->states & UHasTokens) {
token = afs_FindToken(conn->parent->user->tokens, RX_SECIDX_KAD);
if (token) {
*secLevel = RX_SECIDX_KAD;
/* kerberos tickets on channel 2 */
secObj = rxkad_NewClientSecurityObject(
cryptall ? rxkad_crypt : rxkad_clear,
(struct ktc_encryptionKey *)
token->rxkad.clearToken.HandShakeKey,
token->rxkad.clearToken.AuthHandle,
token->rxkad.ticketLen, token->rxkad.ticket);
/* We're going to use this token, so populate the viced */
conn->parent->user->viceId = token->rxkad.clearToken.ViceId;
}
}
if (secObj == NULL) {
*secLevel = 0;
secObj = rxnull_NewClientSecurityObject();
}
return secObj;
}
static int
notify_client (struct ropa_client *c, AFSCBFids *fids, AFSCBs *cbs)
{
#ifdef NO_CALLBACKS
return 0;
#else
int i, ret;
if (c->conn) {
ret = RXAFSCB_CallBack (c->conn, fids, cbs);
if (ret == 0)
return ret;
}
for (i = 0; i < c->numberOfInterfaces ; i++) {
uint16_t port = c->port;
DIAGNOSTIC_CHECK_ADDR(&c->addr[i]);
c->conn = rx_NewConnection (c->addr[i].addr_in,
port,
CM_SERVICE_ID,
rxnull_NewClientSecurityObject(),
0);
mlog_log (MDEBROPA, "notify_client: notifying %x", c->addr[i].addr_in);
ret = RXAFSCB_CallBack (c->conn, fids, cbs);
if (ret)
rx_DestroyConnection (c->conn);
else
break;
/* XXX warn */
}
return ret;
#endif
}
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;
}
static int
_GetNullSecurityObject(struct afscp_cell *cell)
{
cell->security = (struct rx_securityClass *)rxnull_NewClientSecurityObject();
cell->scindex = RX_SECIDX_NULL;
return 0;
}
/*!
* Pick a security class to use for an outgoing connection
*
* This function selects an RX security class to use for an outgoing
* connection, based on the set of security flags provided.
*
* @param[in] dir
* The configuration directory structure for this cell. If NULL,
* no classes requiring local configuration will be returned.
* @param[in] flags
* A set of flags to determine the properties of the security class which
* is selected
* - AFSCONF_SECOPTS_NOAUTH - return an anonymous secirty class
* - AFSCONF_SECOPTS_LOCALAUTH - use classes which have local key
* material available.
* - AFSCONF_SECOPTS_ALWAYSENCRYPT - use classes in encrypting, rather
* than authentication or integrity modes.
* - AFSCONF_SECOPTS_FALLBACK_NULL - if no suitable class can be found,
* then fallback to the rxnull security class.
* @param[in] info
* The cell information structure for the current cell. If this is NULL,
* then use a version locally obtained using the cellName.
* @param[in] cellName
* The cellName to use when obtaining cell information (may be NULL if
* info is specified)
* @param[out] sc
* The selected security class
* @param[out] scIndex
* The index of the selected security class
* @param[out] expires
* The expiry time of the tokens used to construct the class. Will be
* NEVER_DATE if the class has an unlimited lifetime. If NULL, the
* function won't store the expiry date.
*
* @return
* Returns 0 on success, or a com_err error code on failure.
*/
afs_int32
afsconf_PickClientSecObj(struct afsconf_dir *dir, afsconf_secflags flags,
struct afsconf_cell *info,
char *cellName, struct rx_securityClass **sc,
afs_int32 *scIndex, time_t *expires) {
struct afsconf_cell localInfo;
afs_int32 code = 0;
*sc = NULL;
*scIndex = RX_SECIDX_NULL;
if (expires)
expires = 0;
if ( !(flags & AFSCONF_SECOPTS_NOAUTH) ) {
if (!dir)
return AFSCONF_NOCELLDB;
if (flags & AFSCONF_SECOPTS_LOCALAUTH) {
code = afsconf_GetLatestKey(dir, 0, 0);
if (code)
goto out;
if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT)
code = afsconf_ClientAuthSecure(dir, sc, scIndex);
else
code = afsconf_ClientAuth(dir, sc, scIndex);
if (code)
goto out;
if (expires)
*expires = NEVERDATE;
} else {
if (info == NULL) {
code = afsconf_GetCellInfo(dir, cellName, NULL, &localInfo);
if (code)
goto out;
info = &localInfo;
}
code = afsconf_ClientAuthToken(info, flags, sc, scIndex, expires);
if (code && !(flags & AFSCONF_SECOPTS_FALLBACK_NULL))
goto out;
/* If we didn't get a token, we'll just run anonymously */
code = 0;
}
}
if (*sc == NULL) {
*sc = rxnull_NewClientSecurityObject();
*scIndex = RX_SECIDX_NULL;
if (expires)
*expires = NEVERDATE;
}
out:
return code;
}
/* return a null security object if nothing else can be done */
static afs_int32
QuickAuth(struct rx_securityClass **astr, afs_int32 *aindex)
{
register struct rx_securityClass *tc;
tc = rxnull_NewClientSecurityObject();
*astr = tc;
*aindex = RX_SECIDX_NULL;
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 void
get_sec(int serverp, struct rx_securityClass **sec, int *secureindex)
{
if (serverp) {
*sec = rxnull_NewServerSecurityObject();
*secureindex = 1;
} else {
*sec = rxnull_NewClientSecurityObject();
*secureindex = 0;
}
}
int
main(int argc, char **argv)
{
struct rx_securityClass *rxsc;
struct rx_connection *tconn;
afs_int32 code;
rx_Init(0);
rxsc = rxnull_NewClientSecurityObject();
tconn =
rx_NewConnection(htonl(0x7f000001), htons(BC_MESSAGEPORT), 1, rxsc,
0);
code = BC_Print(tconn, 1, 2, argv[1]);
printf("Done, code %d\n", code);
exit(0);
}
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;
}
/**
* Pick a security object to use for a connection to a given server,
* by a given user
*
* @param[in] conn
* The AFS connection for which the security object is required
* @param[out] secLevel
* The security level of the returned object
*
* @return
* An rx security object. This function is guaranteed to return
* an object, although that object may be rxnull (with a secLevel
* of 0)
*/
static struct rx_securityClass *
afs_pickSecurityObject(struct afs_conn *conn, int *secLevel)
{
struct rx_securityClass *secObj = NULL;
/* Do we have tokens ? */
if (conn->user->vid != UNDEFVID) {
*secLevel = 2;
/* kerberos tickets on channel 2 */
secObj = rxkad_NewClientSecurityObject(
cryptall ? rxkad_crypt : rxkad_clear,
(struct ktc_encryptionKey *)conn->user->ct.HandShakeKey,
conn->user->ct.AuthHandle,
conn->user->stLen, conn->user->stp);
}
if (secObj == NULL) {
*secLevel = 0;
secObj = rxnull_NewClientSecurityObject();
}
return secObj;
}
static int
CommandProc(struct cmd_syndesc *as, void *arock)
{
char *hostName, *portName, *times;
afs_int32 hostAddr;
register afs_int32 i, j, code;
short port;
int int32p;
time_t now, then, diff, newtime;
struct hostent *th;
struct rx_connection *tconn;
struct rx_securityClass *sc;
struct ubik_debug udebug;
struct ubik_sdebug usdebug;
int oldServer = 0; /* are we talking to a pre 3.5 server? */
afs_int32 isClone = 0;
int32p = (as->parms[2].items ? 1 : 0);
if (as->parms[0].items)
hostName = as->parms[0].items->data;
else
hostName = NULL;
if (as->parms[1].items)
portName = as->parms[1].items->data;
else
portName = NULL;
/* lookup host */
if (hostName) {
th = hostutil_GetHostByName(hostName);
if (!th) {
printf("udebug: host %s not found in host table\n", hostName);
exit(1);
}
memcpy(&hostAddr, th->h_addr, sizeof(afs_int32));
} else
hostAddr = htonl(0x7f000001); /* IP localhost */
if (!portName)
port = htons(3000); /* default */
else {
port = PortNumber(portName);
if (port < 0)
port = PortName(portName);
if (port < 0) {
printf("udebug: can't resolve port name %s\n", portName);
exit(1);
}
port = htons(port);
}
rx_Init(0);
sc = rxnull_NewClientSecurityObject();
tconn = rx_NewConnection(hostAddr, port, VOTE_SERVICE_ID, sc, 0);
/* now do the main call */
code = VOTE_XDebug(tconn, &udebug, &isClone);
if (code)
code = VOTE_Debug(tconn, &udebug);
if (code == RXGEN_OPCODE) {
oldServer = 1; /* talking to a pre 3.5 server */
memset(&udebug, 0, sizeof(udebug));
code = VOTE_DebugOld(tconn, &udebug);
}
if (code) {
printf("return code %d from VOTE_Debug\n", code);
exit(0);
}
now = time(0);
then = udebug.now;
/* now print the main info */
times = ctime(&then);
times[24] = 0;
if (!oldServer) {
printf("Host's addresses are: ");
for (j = 0; udebug.interfaceAddr[j] && (j < UBIK_MAX_INTERFACE_ADDR);
j++)
printf("%s ", afs_inet_ntoa(htonl(udebug.interfaceAddr[j])));
printf("\n");
}
printf("Host's %s time is %s\n", afs_inet_ntoa(hostAddr), times);
times = ctime(&now);
times[24] = 0;
diff = now - udebug.now;
printf("Local time is %s (time differential %d secs)\n", times, (int)diff);
if (abs((int)diff) >= MAXSKEW)
printf("****clock may be bad\n");
/* UBIK skips the voting if 1 server - so we fudge it here */
if (udebug.amSyncSite && (udebug.nServers == 1)) {
udebug.lastYesHost = hostAddr;
udebug.lastYesTime = udebug.now;
udebug.lastYesState = 1;
udebug.lastYesClaim = udebug.now;
udebug.syncVersion.epoch = udebug.localVersion.epoch;
udebug.syncVersion.counter = udebug.localVersion.counter;
}
/* sockaddr is always in net-order */
if (udebug.lastYesHost == 0xffffffff) {
printf("Last yes vote not cast yet \n");
} else {
diff = udebug.now - udebug.lastYesTime;
printf("Last yes vote for %s was %d secs ago (%ssync site); \n",
afs_inet_ntoa(udebug.lastYesHost), (int)diff,
((udebug.lastYesState) ? "" : "not "));
diff = udebug.now - udebug.lastYesClaim;
newtime = now - diff;
times = ctime(&newtime);
times[24] = 0;
printf("Last vote started %d secs ago (at %s)\n", (int)diff, times);
}
printf("Local db version is %d.%d\n", udebug.localVersion.epoch,
udebug.localVersion.counter);
if (udebug.amSyncSite) {
if (udebug.syncSiteUntil == 0x7fffffff) {
printf("I am sync site forever (%d server%s)\n", udebug.nServers,
((udebug.nServers > 1) ? "s" : ""));
} else {
diff = udebug.syncSiteUntil - udebug.now;
newtime = now + diff;
times = ctime(&newtime);
times[24] = 0;
printf
("I am sync site until %d secs from now (at %s) (%d server%s)\n",
(int)diff, times, udebug.nServers,
((udebug.nServers > 1) ? "s" : ""));
}
printf("Recovery state %x\n", udebug.recoveryState);
if (udebug.activeWrite) {
printf("I am currently managing write trans %d.%d\n",
udebug.epochTime, udebug.tidCounter);
}
} else {
if (isClone)
printf("I am a clone and never can become sync site\n");
else
printf("I am not sync site\n");
diff = udebug.now - udebug.lowestTime;
printf("Lowest host %s was set %d secs ago\n",
afs_inet_ntoa(htonl(udebug.lowestHost)),
(int)diff);
diff = udebug.now - udebug.syncTime;
printf("Sync host %s was set %d secs ago\n",
afs_inet_ntoa(htonl(udebug.syncHost)),
(int)diff);
}
printf("Sync site's db version is %d.%d\n", udebug.syncVersion.epoch,
udebug.syncVersion.counter);
printf("%d locked pages, %d of them for write\n", udebug.lockedPages,
udebug.writeLockedPages);
if (udebug.anyReadLocks)
printf("There are read locks held\n");
if (udebug.anyWriteLocks)
printf("There are write locks held\n");
if (udebug.currentTrans) {
if (udebug.writeTrans)
printf("There is an active write transaction\n");
else
printf("There is at least one active read transaction\n");
printf("Transaction tid is %d.%d\n", udebug.syncTid.epoch,
udebug.syncTid.counter);
}
if (udebug.epochTime) {
diff = udebug.now - udebug.epochTime;
newtime = now - diff;
times = ctime(&newtime);
times[24] = 0;
printf
("Last time a new db version was labelled was:\n\t %d secs ago (at %s)\n",
(int)diff, times);
}
if (int32p || udebug.amSyncSite) {
/* now do the subcalls */
for (i = 0;; i++) {
isClone = 0;
code = VOTE_XSDebug(tconn, i, &usdebug, &isClone);
if (code < 0) {
if (oldServer) { /* pre 3.5 server */
memset(&usdebug, 0, sizeof(usdebug));
code = VOTE_SDebugOld(tconn, i, &usdebug);
} else
code = VOTE_SDebug(tconn, i, &usdebug);
}
if (code > 0)
break; /* done */
if (code < 0) {
printf("error code %d from VOTE_SDebug\n", code);
break;
}
/* otherwise print the structure */
printf("\nServer (%s", afs_inet_ntoa(htonl(usdebug.addr)));
for (j = 0;
((usdebug.altAddr[j]) && (j < UBIK_MAX_INTERFACE_ADDR - 1));
j++)
printf(" %s", afs_inet_ntoa(htonl(usdebug.altAddr[j])));
printf("): (db %d.%d)", usdebug.remoteVersion.epoch,
usdebug.remoteVersion.counter);
if (isClone)
printf(" is only a clone!");
printf("\n");
if (usdebug.lastVoteTime == 0) {
printf(" last vote never rcvd \n");
} else {
diff = udebug.now - usdebug.lastVoteTime;
newtime = now - diff;
times = ctime(&newtime);
times[24] = 0;
printf(" last vote rcvd %d secs ago (at %s),\n", (int)diff,
times);
}
if (usdebug.lastBeaconSent == 0) {
printf(" last beacon never sent \n");
} else {
diff = udebug.now - usdebug.lastBeaconSent;
newtime = now - diff;
times = ctime(&newtime);
times[24] = 0;
printf
(" last beacon sent %d secs ago (at %s), last vote was %s\n",
(int)diff, times, ((usdebug.lastVote) ? "yes" : "no"));
}
printf(" dbcurrent=%d, up=%d beaconSince=%d\n",
usdebug.currentDB, usdebug.up, usdebug.beaconSinceDown);
}
}
return (0);
}
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;
}
static struct ropa_client *
client_query (uint32_t host, uint16_t port)
{
struct ropa_client *c, *c_new;
int ret;
c = client_query_notalkback(host, port);
if (c == NULL) {
interfaceAddr remote;
struct rx_connection *conn = NULL;
c = obtain_client();
assert (c->state == ROPAC_FREE && c->li == NULL);
c->state = ROPAC_LOOKUP_U;
c->flags |= ROPAF_LOOKUP;
client_init (c, host, port, NULL, NULL);
conn = rx_NewConnection (host, port, CM_SERVICE_ID,
rxnull_NewClientSecurityObject(),
0);
if (conn == NULL) {
free(c);
return NULL;
}
retry:
switch (c->state) {
case ROPAC_DEAD:
c->li = listaddtail (lru_clients, c);
ret = ENETDOWN;
break;
case ROPAC_LOOKUP_U:
ret = RXAFSCB_WhoAreYou (conn, &remote);
if (ret == RXGEN_OPCODE) {
c->state = ROPAC_LOOKUP;
goto retry;
} else if (ret == RX_CALL_DEAD) {
c->state = ROPAC_DEAD;
goto retry;
} else {
struct ropa_client ckey;
ckey.uuid = remote.uuid;
c_new = hashtabsearch (ht_clients_uuid, &ckey);
if (c_new == NULL) {
client_init (c, host, port, &remote.uuid, NULL);
ret = RXAFSCB_InitCallBackState3(conn, &server_uuid);
} else {
client_update_interfaces (c_new, host, port, &remote);
disconnect_client (c);
c = c_new;
listdel(lru_clients, c->li);
c->li = NULL;
}
}
break;
case ROPAC_LOOKUP: {
afsUUID uuid;
ret = RXAFSCB_InitCallBackState(conn);
if (ret == RX_CALL_DEAD) {
c->state = ROPAC_DEAD;
goto retry;
}
uuid_init_simple (&uuid, host);
client_init (c, host, port, &uuid, NULL);
break;
}
default:
exit(-1);
}
rx_DestroyConnection (conn);
if ((c->flags & ROPAF_WAITING) != 0)
LWP_NoYieldSignal (c);
c->flags &= ~(ROPAF_LOOKUP|ROPAF_WAITING);
if (ret) {
assert (c->li != NULL);
return NULL;
}
assert (c->li == NULL);
c->li = listaddhead (lru_clients, c);
} else { /* c != NULL */
if ((c->flags & ROPAF_LOOKUP) != 0) {
c->flags |= ROPAF_WAITING;
LWP_WaitProcess (c);
}
assert (c->li != NULL);
}
return c;
}
int
xstat_fs_Init(int a_numServers, struct sockaddr_in *a_socketArray,
int a_ProbeFreqInSecs, int (*a_ProbeHandler) (void), int a_flags,
int a_numCollections, afs_int32 * a_collIDP)
{
static char rn[] = "xstat_fs_Init"; /*Routine name */
afs_int32 code; /*Return value */
static struct rx_securityClass *CBsecobj; /*Callback security object */
struct rx_securityClass *secobj; /*Client security object */
struct rx_service *rxsrv_afsserver; /*Server for AFS */
int arg_errfound; /*Argument error found? */
int curr_srv; /*Current server idx */
struct xstat_fs_ConnectionInfo *curr_conn; /*Ptr to current conn */
char *hostNameFound; /*Ptr to returned host name */
int conn_err; /*Connection error? */
int collIDBytes; /*Num bytes in coll ID array */
char hoststr[16];
/*
* If we've already been called, snicker at the bozo, gently
* remind him of his doubtful heritage, and return success.
*/
if (xstat_fs_initflag) {
fprintf(stderr, "[%s] Called multiple times!\n", rn);
return (0);
} else
xstat_fs_initflag = 1;
/*
* Check the parameters for bogosities.
*/
arg_errfound = 0;
if (a_numServers <= 0) {
fprintf(stderr, "[%s] Illegal number of servers: %d\n", rn,
a_numServers);
arg_errfound = 1;
}
if (a_socketArray == (struct sockaddr_in *)0) {
fprintf(stderr, "[%s] Null server socket array argument\n", rn);
arg_errfound = 1;
}
if (a_ProbeFreqInSecs <= 0) {
fprintf(stderr, "[%s] Illegal probe frequency: %d\n", rn,
a_ProbeFreqInSecs);
arg_errfound = 1;
}
if (a_ProbeHandler == (int (*)())0) {
fprintf(stderr, "[%s] Null probe handler function argument\n", rn);
arg_errfound = 1;
}
if (a_numCollections <= 0) {
fprintf(stderr, "[%s] Illegal collection count argument: %d\n", rn,
a_numServers);
arg_errfound = 1;
}
if (a_collIDP == NULL) {
fprintf(stderr, "[%s] Null collection ID array argument\n", rn);
arg_errfound = 1;
}
if (arg_errfound)
return (-1);
/*
* Record our passed-in info.
*/
xstat_fs_debug = (a_flags & XSTAT_FS_INITFLAG_DEBUGGING);
xstat_fs_oneShot = (a_flags & XSTAT_FS_INITFLAG_ONE_SHOT);
xstat_fs_numServers = a_numServers;
xstat_fs_Handler = a_ProbeHandler;
xstat_fs_ProbeFreqInSecs = a_ProbeFreqInSecs;
xstat_fs_numCollections = a_numCollections;
collIDBytes = xstat_fs_numCollections * sizeof(afs_int32);
xstat_fs_collIDP = malloc(collIDBytes);
memcpy(xstat_fs_collIDP, a_collIDP, collIDBytes);
if (xstat_fs_debug) {
printf("[%s] Asking for %d collection(s): ", rn,
xstat_fs_numCollections);
for (curr_srv = 0; curr_srv < xstat_fs_numCollections; curr_srv++)
printf("%d ", *(xstat_fs_collIDP + curr_srv));
printf("\n");
}
/*
* Get ready in case we have to do a cleanup - basically, zero
* everything out.
*/
code = xstat_fs_CleanupInit();
if (code)
return (code);
/*
* Allocate the necessary data structures and initialize everything
* else.
*/
xstat_fs_ConnInfo = malloc(a_numServers
* sizeof(struct xstat_fs_ConnectionInfo));
if (xstat_fs_ConnInfo == (struct xstat_fs_ConnectionInfo *)0) {
fprintf(stderr,
"[%s] Can't allocate %d connection info structs (%" AFS_SIZET_FMT " bytes)\n",
rn, a_numServers,
(a_numServers * sizeof(struct xstat_fs_ConnectionInfo)));
return (-1); /*No cleanup needs to be done yet */
}
/*
* Initialize the Rx subsystem, just in case nobody's done it.
*/
if (xstat_fs_debug)
printf("[%s] Initializing Rx\n", rn);
code = rx_Init(0);
if (code) {
fprintf(stderr, "[%s] Fatal error in rx_Init()\n", rn);
return (-1);
}
if (xstat_fs_debug)
printf("[%s] Rx initialized\n", rn);
/*
* Create a null Rx server security object, to be used by the
* Callback listener.
*/
CBsecobj = (struct rx_securityClass *)
rxnull_NewServerSecurityObject();
if (CBsecobj == (struct rx_securityClass *)0) {
fprintf(stderr,
"[%s] Can't create callback listener's security object.\n",
rn);
xstat_fs_Cleanup(1); /*Delete already-malloc'ed areas */
return (-1);
}
if (xstat_fs_debug)
printf("[%s] Callback server security object created\n", rn);
/*
* Create a null Rx client security object, to be used by the
* probe LWP.
*/
secobj = rxnull_NewClientSecurityObject();
if (secobj == (struct rx_securityClass *)0) {
fprintf(stderr,
"[%s] Can't create probe LWP client security object.\n", rn);
xstat_fs_Cleanup(1); /*Delete already-malloc'ed areas */
return (-1);
}
if (xstat_fs_debug)
printf("[%s] Probe LWP client security object created\n", rn);
curr_conn = xstat_fs_ConnInfo;
conn_err = 0;
for (curr_srv = 0; curr_srv < a_numServers; curr_srv++) {
/*
* Copy in the socket info for the current server, resolve its
* printable name if possible.
*/
if (xstat_fs_debug) {
char hoststr[16];
printf("[%s] Copying in the following socket info:\n", rn);
printf("[%s] IP addr %s, port %d\n", rn,
afs_inet_ntoa_r((a_socketArray + curr_srv)->sin_addr.s_addr,hoststr),
ntohs((a_socketArray + curr_srv)->sin_port));
}
memcpy(&(curr_conn->skt), a_socketArray + curr_srv,
sizeof(struct sockaddr_in));
hostNameFound =
hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr);
if (hostNameFound == NULL) {
fprintf(stderr,
"[%s] Can't map Internet address %s to a string name\n",
rn, afs_inet_ntoa_r(curr_conn->skt.sin_addr.s_addr,hoststr));
curr_conn->hostName[0] = '\0';
} else {
strcpy(curr_conn->hostName, hostNameFound);
if (xstat_fs_debug)
printf("[%s] Host name for server index %d is %s\n", rn,
curr_srv, curr_conn->hostName);
}
/*
* Make an Rx connection to the current server.
*/
if (xstat_fs_debug)
printf
("[%s] Connecting to srv idx %d, IP addr %s, port %d, service 1\n",
rn, curr_srv, afs_inet_ntoa_r(curr_conn->skt.sin_addr.s_addr,hoststr),
ntohs(curr_conn->skt.sin_port));
curr_conn->rxconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */
curr_conn->skt.sin_port, /*Server port */
1, /*AFS service # */
secobj, /*Security obj */
0); /*# of above */
if (curr_conn->rxconn == (struct rx_connection *)0) {
fprintf(stderr,
"[%s] Can't create Rx connection to server '%s' (%s)\n",
rn, curr_conn->hostName, afs_inet_ntoa_r(curr_conn->skt.sin_addr.s_addr,hoststr));
conn_err = 1;
}
if (xstat_fs_debug)
printf("[%s] New connection at %" AFS_PTR_FMT "\n", rn, curr_conn->rxconn);
/*
* Bump the current xstat_fs connection to set up.
*/
curr_conn++;
} /*for curr_srv */
/*
* Create the AFS callback service (listener).
*/
if (xstat_fs_debug)
printf("[%s] Creating AFS callback listener\n", rn);
rxsrv_afsserver = rx_NewService(0, /*Use default port */
1, /*Service ID */
"afs", /*Service name */
&CBsecobj, /*Ptr to security object(s) */
1, /*# of security objects */
RXAFSCB_ExecuteRequest); /*Dispatcher */
if (rxsrv_afsserver == (struct rx_service *)0) {
fprintf(stderr, "[%s] Can't create callback Rx service/listener\n",
rn);
xstat_fs_Cleanup(1); /*Delete already-malloc'ed areas */
return (-1);
}
if (xstat_fs_debug)
printf("[%s] Callback listener created\n", rn);
/*
* Start up the AFS callback service.
*/
if (xstat_fs_debug)
printf("[%s] Starting up callback listener.\n", rn);
rx_StartServer(0); /*Don't donate yourself to LWP pool */
/*
* Start up the probe LWP.
*/
if (xstat_fs_debug)
printf("[%s] Creating the probe LWP\n", rn);
code = LWP_CreateProcess(xstat_fs_LWP, /*Function to start up */
LWP_STACK_SIZE, /*Stack size in bytes */
1, /*Priority */
(void *)0, /*Parameters */
"xstat_fs Worker", /*Name to use */
&probeLWP_ID); /*Returned LWP process ID */
if (code) {
fprintf(stderr, "[%s] Can't create xstat_fs LWP! Error is %d\n", rn,
code);
xstat_fs_Cleanup(1); /*Delete already-malloc'ed areas */
return (code);
}
if (xstat_fs_debug)
printf("[%s] Probe LWP process structure located at %" AFS_PTR_FMT "\n", rn,
probeLWP_ID);
/*
* Return the final results.
*/
if (conn_err)
return (-2);
else
return (0);
}
int
fsprobe_Init(int a_numServers, struct sockaddr_in *a_socketArray,
int a_ProbeFreqInSecs, int (*a_ProbeHandler)(void),
int a_debug)
{ /*fsprobe_Init */
static char rn[] = "fsprobe_Init"; /*Routine name */
register afs_int32 code; /*Return value */
static struct rx_securityClass *CBsecobj; /*Callback security object */
struct rx_securityClass *secobj; /*Client security object */
struct rx_service *rxsrv_afsserver; /*Server for AFS */
int arg_errfound; /*Argument error found? */
int curr_srv; /*Current server idx */
struct fsprobe_ConnectionInfo *curr_conn; /*Ptr to current conn */
char *hostNameFound; /*Ptr to returned host name */
int conn_err; /*Connection error? */
int PortToUse; /*Callback port to use */
/*
* If we've already been called, snicker at the bozo, gently
* remind him of his doubtful heritage, and return success.
*/
if (fsprobe_initflag) {
fprintf(stderr, "[%s] Called multiple times!\n", rn);
return (0);
} else
fsprobe_initflag = 1;
/*
* Check the parameters for bogosities.
*/
arg_errfound = 0;
if (a_numServers <= 0) {
fprintf(stderr, "[%s] Illegal number of servers: %d\n", rn,
a_numServers);
arg_errfound = 1;
}
if (a_socketArray == (struct sockaddr_in *)0) {
fprintf(stderr, "[%s] Null server socket array argument\n", rn);
arg_errfound = 1;
}
if (a_ProbeFreqInSecs <= 0) {
fprintf(stderr, "[%s] Illegal probe frequency: %d\n", rn,
a_ProbeFreqInSecs);
arg_errfound = 1;
}
if (a_ProbeHandler == (int (*)())0) {
fprintf(stderr, "[%s] Null probe handler function argument\n", rn);
arg_errfound = 1;
}
if (arg_errfound)
return (-1);
/*
* Record our passed-in info.
*/
fsprobe_debug = a_debug;
fsprobe_numServers = a_numServers;
fsprobe_Handler = a_ProbeHandler;
fsprobe_ProbeFreqInSecs = a_ProbeFreqInSecs;
/*
* Get ready in case we have to do a cleanup - basically, zero
* everything out.
*/
fsprobe_CleanupInit();
/*
* Allocate the necessary data structures and initialize everything
* else.
*/
fsprobe_ConnInfo = (struct fsprobe_ConnectionInfo *)
malloc(a_numServers * sizeof(struct fsprobe_ConnectionInfo));
if (fsprobe_ConnInfo == (struct fsprobe_ConnectionInfo *)0) {
fprintf(stderr,
"[%s] Can't allocate %d connection info structs (%"AFS_SIZET_FMT" bytes)\n",
rn, a_numServers,
(a_numServers * sizeof(struct fsprobe_ConnectionInfo)));
return (-1); /*No cleanup needs to be done yet */
}
#if 0
else
fprintf(stderr, "[%s] fsprobe_ConnInfo allocated (%d bytes)\n", rn,
a_numServers * sizeof(struct fsprobe_ConnectionInfo));
#endif /* 0 */
fsprobe_statsBytes = a_numServers * sizeof(struct ProbeViceStatistics);
fsprobe_Results.stats = (struct ProbeViceStatistics *)
malloc(fsprobe_statsBytes);
if (fsprobe_Results.stats == NULL) {
fprintf(stderr,
"[%s] Can't allocate %d statistics structs (%d bytes)\n", rn,
a_numServers, fsprobe_statsBytes);
fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */
return (-1);
} else if (fsprobe_debug)
fprintf(stderr, "[%s] fsprobe_Results.stats allocated (%d bytes)\n",
rn, fsprobe_statsBytes);
fsprobe_probeOKBytes = a_numServers * sizeof(int);
fsprobe_Results.probeOK = (int *)malloc(fsprobe_probeOKBytes);
if (fsprobe_Results.probeOK == (int *)0) {
fprintf(stderr,
"[%s] Can't allocate %d probeOK array entries (%d bytes)\n",
rn, a_numServers, fsprobe_probeOKBytes);
fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */
return (-1);
} else if (fsprobe_debug)
fprintf(stderr, "[%s] fsprobe_Results.probeOK allocated (%d bytes)\n",
rn, fsprobe_probeOKBytes);
fsprobe_Results.probeNum = 0;
fsprobe_Results.probeTime = 0;
memset(fsprobe_Results.stats, 0,
(a_numServers * sizeof(struct ProbeViceStatistics)));
/*
* Initialize the Rx subsystem, just in case nobody's done it.
*/
if (fsprobe_debug)
fprintf(stderr, "[%s] Initializing Rx\n", rn);
PortToUse = FSPROBE_CBPORT;
do {
code = rx_Init(htons(PortToUse));
if (code) {
if (code == RX_ADDRINUSE) {
if (fsprobe_debug)
fprintf(stderr,
"[%s] Callback port %d in use, advancing\n", rn,
PortToUse);
PortToUse++;
} else {
fprintf(stderr, "[%s] Fatal error in rx_Init()\n", rn);
return (-1);
}
}
} while (code);
if (fsprobe_debug)
fprintf(stderr, "[%s] Rx initialized on port %d\n", rn, PortToUse);
/*
* Create a null Rx server security object, to be used by the
* Callback listener.
*/
CBsecobj = rxnull_NewServerSecurityObject();
if (CBsecobj == (struct rx_securityClass *)0) {
fprintf(stderr,
"[%s] Can't create null security object for the callback listener.\n",
rn);
fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */
return (-1);
}
if (fsprobe_debug)
fprintf(stderr, "[%s] Callback server security object created\n", rn);
/*
* Create a null Rx client security object, to be used by the
* probe LWP.
*/
secobj = rxnull_NewClientSecurityObject();
if (secobj == (struct rx_securityClass *)0) {
fprintf(stderr,
"[%s] Can't create client security object for probe LWP.\n",
rn);
fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */
return (-1);
}
if (fsprobe_debug)
fprintf(stderr, "[%s] Probe LWP client security object created\n",
rn);
curr_conn = fsprobe_ConnInfo;
conn_err = 0;
for (curr_srv = 0; curr_srv < a_numServers; curr_srv++) {
/*
* Copy in the socket info for the current server, resolve its
* printable name if possible.
*/
if (fsprobe_debug) {
fprintf(stderr, "[%s] Copying in the following socket info:\n",
rn);
fprintf(stderr, "[%s] IP addr 0x%x, port %d\n", rn,
(a_socketArray + curr_srv)->sin_addr.s_addr,
(a_socketArray + curr_srv)->sin_port);
}
memcpy(&(curr_conn->skt), a_socketArray + curr_srv,
sizeof(struct sockaddr_in));
hostNameFound =
hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr);
if (hostNameFound == NULL) {
fprintf(stderr,
"[%s] Can't map Internet address %u to a string name\n",
rn, curr_conn->skt.sin_addr.s_addr);
curr_conn->hostName[0] = '\0';
} else {
strcpy(curr_conn->hostName, hostNameFound);
if (fsprobe_debug)
fprintf(stderr, "[%s] Host name for server index %d is %s\n",
rn, curr_srv, curr_conn->hostName);
}
/*
* Make an Rx connection to the current server.
*/
if (fsprobe_debug)
fprintf(stderr,
"[%s] Connecting to srv idx %d, IP addr 0x%x, port %d, service 1\n",
rn, curr_srv, curr_conn->skt.sin_addr.s_addr,
curr_conn->skt.sin_port);
curr_conn->rxconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */
curr_conn->skt.sin_port, /*Server port */
1, /*AFS service num */
secobj, /*Security object */
0); /*Number of above */
if (curr_conn->rxconn == (struct rx_connection *)0) {
fprintf(stderr,
"[%s] Can't create Rx connection to server %s (%u)\n",
rn, curr_conn->hostName, curr_conn->skt.sin_addr.s_addr);
conn_err = 1;
}
if (fsprobe_debug)
fprintf(stderr, "[%s] New connection at %p\n", rn,
curr_conn->rxconn);
/*
* Make an Rx connection to the current volume server.
*/
if (fsprobe_debug)
fprintf(stderr,
"[%s] Connecting to srv idx %d, IP addr 0x%x, port %d, service 1\n",
rn, curr_srv, curr_conn->skt.sin_addr.s_addr,
htons(7005));
curr_conn->rxVolconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */
htons(AFSCONF_VOLUMEPORT), /*Volume Server port */
VOLSERVICE_ID, /*AFS service num */
secobj, /*Security object */
0); /*Number of above */
if (curr_conn->rxVolconn == (struct rx_connection *)0) {
fprintf(stderr,
"[%s] Can't create Rx connection to volume server %s (%u)\n",
rn, curr_conn->hostName, curr_conn->skt.sin_addr.s_addr);
conn_err = 1;
} else {
int i, cnt;
memset(&curr_conn->partList, 0, sizeof(struct partList));
curr_conn->partCnt = 0;
i = XListPartitions(curr_conn->rxVolconn, &curr_conn->partList,
&cnt);
if (!i) {
curr_conn->partCnt = cnt;
}
}
if (fsprobe_debug)
fprintf(stderr, "[%s] New connection at %p\n", rn,
curr_conn->rxVolconn);
/*
* Bump the current fsprobe connection to set up.
*/
curr_conn++;
} /*for curr_srv */
/*
* Create the AFS callback service (listener).
*/
if (fsprobe_debug)
fprintf(stderr, "[%s] Creating AFS callback listener\n", rn);
rxsrv_afsserver = rx_NewService(0, /*Use default port */
1, /*Service ID */
"afs", /*Service name */
&CBsecobj, /*Ptr to security object(s) */
1, /*Number of security objects */
RXAFSCB_ExecuteRequest); /*Dispatcher */
if (rxsrv_afsserver == (struct rx_service *)0) {
fprintf(stderr, "[%s] Can't create callback Rx service/listener\n",
rn);
fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */
return (-1);
}
if (fsprobe_debug)
fprintf(stderr, "[%s] Callback listener created\n", rn);
/*
* Start up the AFS callback service.
*/
if (fsprobe_debug)
fprintf(stderr, "[%s] Starting up callback listener.\n", rn);
rx_StartServer(0 /*Don't donate yourself to LWP pool */ );
/*
* Start up the probe LWP.
*/
if (fsprobe_debug)
fprintf(stderr, "[%s] Creating the probe LWP\n", rn);
code = LWP_CreateProcess(fsprobe_LWP, /*Function to start up */
LWP_STACK_SIZE, /*Stack size in bytes */
1, /*Priority */
(void *)0, /*Parameters */
"fsprobe Worker", /*Name to use */
&probeLWP_ID); /*Returned LWP process ID */
if (code) {
fprintf(stderr, "[%s] Can't create fsprobe LWP! Error is %d\n", rn,
code);
fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */
return (code);
}
if (fsprobe_debug)
fprintf(stderr, "[%s] Probe LWP process structure located at %p\n",
rn, probeLWP_ID);
#if 0
/*
* Do I need to do this?
*/
if (fsprobe_debug)
fprintf(stderr, "[%s] Calling osi_Wakeup()\n", rn);
osi_Wakeup(&rxsrv_afsserver); /*Wake up anyone waiting for it */
#endif /* 0 */
/*
* Return the final results.
*/
if (conn_err)
return (-2);
else
return (0);
} /*fsprobe_Init */
long
rxkst_StartClient(struct clientParms *parms)
{
long code;
long host;
long scIndex;
struct rx_securityClass *sc;
whoami = parms->whoami; /* set this global variable */
host = GetServer(parms->server);
if (parms->authentication >= 0) {
long kvno = 0;
char ticket[MAXKTCTICKETLEN];
int ticketLen;
struct ktc_encryptionKey Ksession;
if (parms->useTokens)
code =
GetToken(&kvno, &Ksession, &ticketLen, ticket, parms->cell);
else
code =
GetTicket(&kvno, &Ksession, &ticketLen, ticket, parms->cell);
if (code)
return code;
/* next, we have ticket, kvno and session key, authenticate the conn */
sc = (struct rx_securityClass *)
rxkad_NewClientSecurityObject(parms->authentication, &Ksession,
kvno, ticketLen, ticket);
assert(sc);
scIndex = RX_SECIDX_KAD;
} else {
/* unauthenticated connection */
sc = rxnull_NewClientSecurityObject();
assert(sc);
scIndex = RX_SECIDX_NULL;
}
code = 0;
if (!code && parms->callTest) {
code = RunCallTest(parms, host, sc, scIndex);
}
if (!code && parms->hijackTest) {
code = RunHijackTest(parms, host, sc, scIndex);
}
if (!code
&& (parms->printTiming || parms->fastCalls || parms->slowCalls
|| parms->copiousCalls)) {
struct rx_connection *conn;
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID,
sc, scIndex);
if (conn) {
code = RepeatLoadTest(parms, conn);
rx_DestroyConnection(conn);
} else
code = RXKST_NEWCONNFAILED;
}
if (!code && parms->stopServer) {
struct rx_connection *conn;
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID,
sc, scIndex);
if (conn) {
code = RXKST_Kill(conn);
if (code) {
afs_com_err(whoami, code, "trying to stop server");
}
rx_DestroyConnection(conn);
} else
code = RXKST_NEWCONNFAILED;
}
if (parms->printStats) {
rx_PrintStats(stdout);
#if 0
/* use rxdebug style iteration here */
rx_PrintPeerStats(stdout, rx_PeerOf(conn));
#endif
}
rxs_Release(sc);
rx_Finalize();
if (code) {
afs_com_err(parms->whoami, code, "test fails");
exit(13);
} else {
printf("Test Okay\n");
if (!parms->noExit)
exit(0);
}
return 0;
}
int
main(int argc, char **argv)
{
char *hostname;
struct hostent *hostent;
afs_uint32 host;
int logstdout = 0;
struct rx_connection *conn;
struct rx_call *call;
struct rx_peer *peer;
int err = 0;
int nCalls = 1, nBytes = 1;
int bufferSize = 4000000;
char *buffer;
char *sendFile = 0;
int setFD = 0;
int jumbo = 0;
#if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV)
setlinebuf(stdout);
rxi_syscallp = test_syscall;
#endif
argv++;
argc--;
while (argc && **argv == '-') {
if (strcmp(*argv, "-silent") == 0)
print = 0;
if (strcmp(*argv, "-jumbo") == 0)
jumbo = 1;
else if (strcmp(*argv, "-nc") == 0)
nCalls = atoi(*++argv), argc--;
else if (strcmp(*argv, "-nb") == 0)
nBytes = atoi(*++argv), argc--;
else if (strcmp(*argv, "-np") == 0)
rx_nPackets = atoi(*++argv), argc--;
else if (!strcmp(*argv, "-nsf"))
rxi_nSendFrags = atoi(*++argv), argc--;
else if (!strcmp(*argv, "-nrf"))
rxi_nRecvFrags = atoi(*++argv), argc--;
else if (strcmp(*argv, "-twind") == 0)
rx_initSendWindow = atoi(*++argv), argc--;
else if (strcmp(*argv, "-rwind") == 0)
rx_initReceiveWindow = atoi(*++argv), argc--;
else if (strcmp(*argv, "-rxlog") == 0)
rxlog = 1;
else if (strcmp(*argv, "-logstdout") == 0)
logstdout = 1;
else if (strcmp(*argv, "-eventlog") == 0)
eventlog = 1;
else if (strcmp(*argv, "-drop") == 0) {
#ifdef RXDEBUG
rx_intentionallyDroppedPacketsPer100 = atoi(*++argv), argc--;
#else
fprintf(stderr, "ERROR: Compiled without RXDEBUG\n");
#endif
}
else if (strcmp(*argv, "-burst") == 0) {
burst = atoi(*++argv), argc--;
burstTime.sec = atoi(*++argv), argc--;
burstTime.usec = atoi(*++argv), argc--;
} else if (strcmp(*argv, "-retry") == 0) {
retryTime.sec = atoi(*++argv), argc--;
retryTime.usec = atoi(*++argv), argc--;
} else if (strcmp(*argv, "-timeout") == 0)
timeout = atoi(*++argv), argc--;
else if (strcmp(*argv, "-fill") == 0)
fillPackets++;
else if (strcmp(*argv, "-file") == 0)
sendFile = *++argv, argc--;
else if (strcmp(*argv, "-timereadvs") == 0)
timeReadvs = 1;
else if (strcmp(*argv, "-wait") == 0) {
/* Wait time between calls--to test lastack code */
waitTime.sec = atoi(*++argv), argc--;
waitTime.usec = atoi(*++argv), argc--;
} else if (strcmp(*argv, "-compute") == 0) {
/* Simulated "compute" time for each call--to test acknowledgement protocol. This is simulated by doing an iomgr_select: imperfect, admittedly. */
computeTime.sec = atoi(*++argv), argc--;
computeTime.usec = atoi(*++argv), argc--;
} else if (strcmp(*argv, "-fd") == 0) {
/* Open at least this many fd's. */
setFD = atoi(*++argv), argc--;
} else {
err = 1;
break;
}
argv++, argc--;
}
if (err || argc != 1)
Quit("usage: rx_ctest [-silent] [-rxlog] [-eventlog] [-nc NCALLS] [-np NPACKETS] hostname");
hostname = *argv++, argc--;
if (rxlog || eventlog) {
if (logstdout)
debugFile = stdout;
else
debugFile = fopen("rx_ctest.db", "w");
if (debugFile == NULL)
Quit("Couldn't open rx_ctest.db");
if (rxlog)
rx_debugFile = debugFile;
if (eventlog)
rxevent_debugFile = debugFile;
}
signal(SIGINT, intSignal); /*Changed to sigquit since dbx is broken right now */
#ifndef AFS_NT40_ENV
signal(SIGQUIT, quitSignal);
#endif
#ifdef AFS_NT40_ENV
if (afs_winsockInit() < 0) {
printf("Can't initialize winsock.\n");
exit(1);
}
rx_EnableHotThread();
#endif
rx_SetUdpBufSize(256 * 1024);
if (!jumbo)
rx_SetNoJumbo();
hostent = gethostbyname(hostname);
if (!hostent)
Abort("host %s not found", hostname);
if (hostent->h_length != 4)
Abort("host address is disagreeable length (%d)", hostent->h_length);
memcpy((char *)&host, hostent->h_addr, sizeof(host));
if (setFD > 0)
OpenFD(setFD);
if (rx_Init(0) != 0) {
printf("RX failed to initialize, exiting.\n");
exit(2);
}
if (setFD > 0) {
printf("rx_socket=%d\n", rx_socket);
}
printf("Using %d packet buffers\n", rx_nPackets);
conn =
rx_NewConnection(host, htons(2500), 3,
rxnull_NewClientSecurityObject(), 0);
if (!conn)
Abort("unable to make a new connection");
/* Set initial parameters. This is (currently) not the approved interface */
peer = rx_PeerOf(conn);
if (burst)
peer->burstSize = peer->burst = burst;
if (!clock_IsZero(&burstTime))
peer->burstWait = burstTime;
if (!clock_IsZero(&retryTime))
peer->rtt = _8THMSEC(&retryTime);
if (sendFile)
SendFile(sendFile, conn);
else {
buffer = (char *)osi_Alloc(bufferSize);
while (nCalls--) {
struct clock startTime;
struct timeval t;
int nbytes;
int nSent;
int bytesSent = 0;
int bytesRead = 0;
call = rx_NewCall(conn);
if (!call)
Abort("unable to make a new call");
clock_GetTime(&startTime);
for (bytesSent = 0; bytesSent < nBytes; bytesSent += nSent) {
int tryCount;
tryCount =
(bufferSize >
nBytes - bytesSent) ? nBytes - bytesSent : bufferSize;
nSent = rx_Write(call, buffer, tryCount);
if (nSent == 0)
break;
}
for (bytesRead = 0; (nbytes = rx_Read(call, buffer, bufferSize));
bytesRead += nbytes) {
};
if (print)
printf("Received %d characters in response\n", bytesRead);
err = rx_EndCall(call, 0);
if (err)
printf("Error %d returned from rpc call\n", err);
else {
struct clock totalTime;
float elapsedTime;
clock_GetTime(&totalTime);
clock_Sub(&totalTime, &startTime);
elapsedTime = clock_Float(&totalTime);
fprintf(stderr,
"Sent %d bytes in %0.3f seconds: %0.0f bytes per second\n",
bytesSent, elapsedTime, bytesSent / elapsedTime);
}
if (!clock_IsZero(&computeTime)) {
t.tv_sec = computeTime.sec;
t.tv_usec = computeTime.usec;
if (select(0, 0, 0, 0, &t) != 0)
Quit("Select didn't return 0");
}
if (!clock_IsZero(&waitTime)) {
struct timeval t;
t.tv_sec = waitTime.sec;
t.tv_usec = waitTime.usec;
#ifdef AFS_PTHREAD_ENV
select(0, 0, 0, 0, &t);
#else
IOMGR_Sleep(t.tv_sec);
#endif
}
if (debugFile)
rx_PrintPeerStats(debugFile, rx_PeerOf(conn));
rx_PrintPeerStats(stdout, rx_PeerOf(conn));
}
}
Quit("testclient: done!\n");
return 0;
}
int
main(int argc, char **argv)
{
char scell[MAXCELLCHARS], dcell[MAXCELLCHARS];
afs_uint32 ssrv, dsrv;
char *databuffer, *srcf = NULL, *destd = NULL, *destf = NULL, *destpath = NULL;
struct stat statbuf;
struct AFSStoreStatus sst;
struct AFSFetchStatus fst, dfst;
struct AFSVolSync vs;
struct AFSCallBack scb, dcb;
struct AFSFid sf, dd, df;
int filesz = 0;
int ch, blksize, bytesremaining, bytes;
struct timeval start, finish;
struct timezone tz;
struct rx_securityClass *ssc = 0, *dsc = 0;
int sscindex, dscindex;
struct rx_connection *sconn = NULL, *dconn = NULL;
struct rx_call *scall = NULL, *dcall = NULL;
int code = 0, fetchcode, storecode, printcallerrs = 0;
int slcl = 0, dlcl = 0, unlock = 0;
int sfd = 0, dfd = 0, unauth = 0;
struct AFSCBFids theFids;
struct AFSCBs theCBs;
blksize = 8 * 1024;
while ((ch = getopt(argc, argv, "iouUb:")) != -1) {
switch (ch) {
case 'b':
blksize = atoi(optarg);
break;
case 'i':
slcl = 1;
break;
case 'o':
dlcl = 1;
break;
case 'u':
unauth = 1;
break;
case 'U':
unlock = 1;
break;
default:
printf("Unknown option '%c'\n", ch);
exit(1);
}
}
if (argc - optind + unlock < 2) {
fprintf(stderr,
"Usage: afscp [-i|-o]] [-b xfersz] [-u] [-U] source [dest]\n");
fprintf(stderr, " -b Set block size\n");
fprintf(stderr, " -i Source is local (copy into AFS)\n");
fprintf(stderr, " -o Dest is local (copy out of AFS)\n");
fprintf(stderr, " -u Run unauthenticated\n");
fprintf(stderr, " -U Send an unlock request for source. (dest path not required)\n");
fprintf(stderr, "source and dest can be paths or specified as:\n");
fprintf(stderr, " @afs:cellname:servername:volume:vnode:uniq\n");
exit(1);
}
srcf = argv[optind++];
if (!unlock) {
destpath = argv[optind++];
destd = strdup(destpath);
if (!destd) {
perror("strdup");
exit(1);
}
if ((destf = strrchr(destd, '/'))) {
*destf++ = 0;
} else {
destf = destd;
destd = ".";
}
} else if (slcl) {
fprintf(stderr, "-i and -U cannot be used together\n");
}
if (!slcl && statfile(srcf, scell, &ssrv, &sf)) {
fprintf(stderr, "Cannot get attributes of %s\n", srcf);
exit(1);
}
if (!unlock && !dlcl && statfile(destd, dcell, &dsrv, &dd)) {
fprintf(stderr, "Cannot get attributes of %s\n", destd);
exit(1);
}
if ((databuffer = malloc(blksize)) == NULL) {
perror("malloc");
exit(1);
}
if (do_rx_Init())
exit(1);
if (start_cb_server()) {
printf("Cannot start callback service\n");
goto Fail_rx;
}
if (!slcl) {
sscindex = scindex_RXKAD;
if (unauth || (ssc = get_sc(scell)) == NULL) {
ssc = rxnull_NewClientSecurityObject();
sscindex = scindex_NULL;
/*printf("Cannot get authentication for cell %s; running unauthenticated\n", scell); */
}
sscindex = scindex_NULL;
if ((sconn =
rx_NewConnection(ssrv, htons(AFSCONF_FILEPORT), 1, ssc,
sscindex))
== NULL) {
struct in_addr s;
s.s_addr = ssrv;
printf("Cannot initialize rx connection to source server (%s)\n",
inet_ntoa(s));
goto Fail_sc;
}
}
if (!dlcl && !unlock) {
if (!slcl && ssrv == dsrv) {
dconn = sconn;
dsc = NULL;
} else {
if (slcl || strcmp(scell, dcell)) {
dscindex = scindex_RXKAD;
if (unauth || (dsc = get_sc(dcell)) == NULL) {
dsc = rxnull_NewClientSecurityObject();
dscindex = scindex_NULL;
/*printf("Cannot get authentication for cell %s; running unauthenticated\n", dcell); */
}
dscindex = scindex_NULL;
} else {
dsc = ssc;
dscindex = sscindex;
}
if ((dconn =
rx_NewConnection(dsrv, htons(AFSCONF_FILEPORT), 1, dsc,
dscindex))
== NULL) {
struct in_addr s;
s.s_addr = dsrv;
printf
("Cannot initialize rx connection to dest server (%s)\n",
inet_ntoa(s));
goto Fail_sconn;
}
}
}
memset(&sst, 0, sizeof(struct AFSStoreStatus));
if (dlcl && !unlock) {
dfd = open(destpath, O_RDWR | O_CREAT | O_EXCL, 0666);
if (dfd < 0 && errno == EEXIST) {
printf("%s already exists, overwriting\n", destpath);
dfd = open(destpath, O_RDWR | O_TRUNC, 0666);
if (dfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", destpath,
afs_error_message(errno));
goto Fail_dconn;
}
} else if (dfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", destpath,
afs_error_message(errno));
goto Fail_dconn;
}
} else if (!unlock) {
if ((code =
RXAFS_CreateFile(dconn, &dd, destf, &sst, &df, &fst, &dfst, &dcb,
&vs))) {
if (code == EEXIST) {
printf("%s already exits, overwriting\n", destpath);
if (statfile(destpath, dcell, &dsrv, &df))
fprintf(stderr, "Cannot get attributes of %s\n",
destpath);
else
code = 0;
} else {
printf("Cannot create %s (%s)\n", destpath,
afs_error_message(code));
if (code)
goto Fail_dconn;
}
}
}
if (slcl) {
sfd = open(srcf, O_RDONLY, 0);
if (sfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", srcf,
afs_error_message(errno));
goto Fail_dconn;
}
if (fstat(sfd, &statbuf) < 0) {
fprintf(stderr, "Cannot stat %s (%s)\n", srcf,
afs_error_message(errno));
close(sfd);
goto Fail_dconn;
}
} else {
if ((code = RXAFS_FetchStatus(sconn, &sf, &fst, &scb, &vs))) {
printf("Cannot fetchstatus of %d.%d (%s)\n", sf.Volume, sf.Vnode,
afs_error_message(code));
goto Fail_dconn;
}
}
if (slcl) {
filesz = statbuf.st_size;
} else {
filesz = fst.Length;
}
printcallerrs = 0;
fetchcode = 0;
storecode = 0;
if (!slcl && !unlock)
scall = rx_NewCall(sconn);
if (!dlcl && !unlock)
dcall = rx_NewCall(dconn);
gettimeofday(&start, &tz);
if (unlock) {
if (fst.lockCount) {
printf("Sending 1 unlock for %s (%d locks)\n", srcf, fst.lockCount);
if ((code = RXAFS_ReleaseLock(sconn, &sf, &vs))) {
printf("Unable to unlock %s (%s)\n", srcf,
afs_error_message(code));
}
} else {
printf("No locks for %s\n", srcf);
}
fetchcode = code;
goto Finish;
}
if (!slcl) {
if ((code = StartRXAFS_FetchData(scall, &sf, 0, filesz))) {
printf("Unable to fetch data from %s (%s)\n", srcf,
afs_error_message(code));
goto Fail_call;
}
}
if (!dlcl) {
if (slcl) {
sst.Mask = AFS_SETMODTIME | AFS_SETMODE;
sst.ClientModTime = statbuf.st_mtime;
sst.UnixModeBits =
statbuf.st_mode & ~(S_IFMT | S_ISUID | S_ISGID);
} else {
sst.Mask = AFS_SETMODTIME | AFS_SETMODE;
sst.ClientModTime = fst.ClientModTime;
sst.UnixModeBits =
fst.UnixModeBits & ~(S_IFMT | S_ISUID | S_ISGID);
}
if ((code =
StartRXAFS_StoreData(dcall, &df, &sst, 0, filesz, filesz))) {
printf("Unable to store data to %s (%s)\n", destpath,
afs_error_message(code));
goto Fail_call;
}
}
if (slcl) {
bytesremaining = statbuf.st_size;
} else {
rx_Read(scall, (char *)&bytesremaining, sizeof(afs_int32));
bytesremaining = ntohl(bytesremaining);
}
while (bytesremaining > 0) {
/*printf("%d bytes remaining\n",bytesremaining); */
if (slcl) {
if ((bytes =
read(sfd, databuffer, min(blksize, bytesremaining))) <= 0) {
fetchcode = errno;
break;
}
} else {
if ((bytes =
rx_Read(scall, databuffer,
min(blksize, bytesremaining))) <= 0)
break;
}
if (dlcl) {
if (write(dfd, databuffer, bytes) != bytes) {
storecode = errno;
break;
}
} else {
if (rx_Write(dcall, databuffer, bytes) != bytes)
break;
}
bytesremaining -= bytes;
/*printf("%d bytes copied\n",bytes); */
}
if (bytesremaining > 0) {
printf("Some network error occured while copying data\n");
goto Fail_call;
}
if (!slcl)
fetchcode = EndRXAFS_FetchData(scall, &fst, &scb, &vs);
if (!dlcl)
storecode = EndRXAFS_StoreData(dcall, &fst, &vs);
printcallerrs = 1;
Fail_call:
if (slcl) {
if (close(sfd) && !fetchcode)
fetchcode = errno;
} else {
fetchcode = rx_EndCall(scall, fetchcode);
}
if (fetchcode && printcallerrs)
printf("Error returned from fetch: %s\n", afs_error_message(fetchcode));
if (dlcl) {
if (close(dfd) && !storecode)
storecode = errno;
} else if (!unlock) {
storecode = rx_EndCall(dcall, storecode);
}
if (storecode && printcallerrs)
printf("Error returned from store: %s\n", afs_error_message(storecode));
Finish:
gettimeofday(&finish, &tz);
if (!slcl) {
theFids.AFSCBFids_len = 1;
theFids.AFSCBFids_val = &sf;
theCBs.AFSCBs_len = 1;
theCBs.AFSCBs_val = &scb;
scb.CallBackType = CB_DROPPED;
if ((code = RXAFS_GiveUpCallBacks(sconn, &theFids, &theCBs)))
printf("Could not give up source callback: %s\n",
afs_error_message(code));
}
if (!dlcl) {
theFids.AFSCBFids_len = 1;
theFids.AFSCBFids_val = &df;
theCBs.AFSCBs_len = 1;
theCBs.AFSCBs_val = &dcb;
dcb.CallBackType = CB_DROPPED;
if ((code = RXAFS_GiveUpCallBacks(dconn, &theFids, &theCBs)))
printf("Could not give up target callback: %s\n",
afs_error_message(code));
}
if (code == 0)
code = storecode;
if (code == 0)
code = fetchcode;
Fail_dconn:
if (!dlcl && !unlock && (slcl || dconn != sconn))
rx_DestroyConnection(dconn);
Fail_sconn:
if (!slcl)
rx_DestroyConnection(sconn);
Fail_sc:
if (dsc && dsc != ssc)
RXS_Close(dsc);
if (ssc)
RXS_Close(ssc);
Fail_rx:
rx_Finalize();
free(databuffer);
if (printcallerrs && !unlock) {
double rate, size, time;
if (finish.tv_sec == start.tv_sec) {
printf("Copied %d bytes in %d microseconds\n", filesz,
(int)(finish.tv_usec - start.tv_usec));
} else {
printf("Copied %d bytes in %d seconds\n", filesz,
(int)(finish.tv_sec - start.tv_sec));
}
size = filesz / 1024.0;
time =
finish.tv_sec - start.tv_sec + (finish.tv_usec -
start.tv_usec) / 1e+06;
rate = size / time;
printf("Transfer rate %g Kbytes/sec\n", rate);
}
exit(code != 0);
}
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 init_fs_channel(rpc_test_request_ctx **octx, char *cb_if,
char *listen_addr_s, char *prefix, char *fs_addr_s,
afs_uint32 flags)
{
char cmd[512];
rpc_test_request_ctx *ctx;
afs_int32 code = 0;
#ifdef AFS_NT40_ENV
afs_int32 sslen = sizeof(struct sockaddr);
#endif
ctx = *octx = (rpc_test_request_ctx *) malloc(sizeof(rpc_test_request_ctx));
memset(ctx, 0, sizeof(rpc_test_request_ctx));
/* initialize a local mutex */
code = pthread_mutex_init(&ctx->mtx, &rpc_test_params.mtx_attrs);
/* lock package before rx setup--which has global deps, atm */
pthread_mutex_lock(&rpc_test_params.mtx);
ctx->cno = rpc_test_params.next_cno++;
ctx->flags = flags;
/* afscbint (server) */
sprintf(ctx->cb_svc_name, "cb_%d", ctx->cno);
sprintf(ctx->cb_if_s, cb_if);
sprintf(ctx->cb_listen_addr_s, listen_addr_s);
sprintf(ctx->cb_prefix_s, prefix);
sprintf(ctx->fs_addr_s, fs_addr_s);
#if defined(RPC_TEST_ADD_ADDRESSES)
#if defined(AFS_LINUX26_ENV)
sprintf(cmd, "ip addr add %s/%s dev %s label %s", listen_addr_s, prefix,
cb_if, cb_if);
code = system(cmd);
#endif
#endif /* RPC_TEST_ADD_ADDRESSES */
/* lock this */
pthread_mutex_lock(&ctx->mtx);
/* set up rx */
ctx->cb_port = rpc_test_params.cb_next_port++;
ctx->cb_listen_addr.numberOfInterfaces = 1;
#ifdef AFS_NT40_ENV
code = WSAStringToAddressA(listen_addr_s, AF_INET, NULL,
(struct sockaddr*) &(ctx->cb_listen_addr), &sslen);
#else
code = inet_pton(AF_INET, listen_addr_s,
(void*) &(ctx->cb_listen_addr.addr_in[0]));
#endif
code = init_callback_service(ctx /* LOCKED, && rpc_test_params->mtx LOCKED */);
/* fsint (client) */
#ifdef AFS_NT40_ENV
code = WSAStringToAddressA(fs_addr_s, AF_INET, NULL,
(struct sockaddr*) &(ctx->fs_addr.addr_in[0]), &sslen);
#else
code = inet_pton(AF_INET, fs_addr_s, (void*) &(ctx->fs_addr.addr_in[0]));
#endif
ctx->sc = rxnull_NewClientSecurityObject();
ctx->sc_index = RX_SECIDX_NULL;
ctx->conn = rx_NewConnection(ctx->fs_addr.addr_in[0], (int) htons(fs_port),
1, ctx->sc, ctx->sc_index);
/* unlock this */
pthread_mutex_unlock(&ctx->mtx);
out:
return (code);
} /* init_fs_channel */
void
afspag_Init(afs_int32 nfs_server_addr)
{
struct clientcred ccred;
struct rmtbulk idata, odata;
afs_int32 code, err, addr, obuf;
int i;
afs_uuid_create(&afs_cb_interface.uuid);
AFS_GLOCK();
afs_InitStats();
rx_Init(htons(7001));
AFS_STATCNT(afs_ResourceInit);
AFS_RWLOCK_INIT(&afs_xuser, "afs_xuser");
AFS_RWLOCK_INIT(&afs_xpagcell, "afs_xpagcell");
AFS_RWLOCK_INIT(&afs_xpagsys, "afs_xpagsys");
AFS_RWLOCK_INIT(&afs_icl_lock, "afs_icl_lock");
afs_resourceinit_flag = 1;
afs_nfs_server_addr = nfs_server_addr;
for (i = 0; i < MAXNUMSYSNAMES; i++) {
afs_sysnamelist[i] = afs_osi_Alloc(MAXSYSNAME);
osi_Assert(afs_sysnamelist[i] != NULL);
}
afs_sysname = afs_sysnamelist[0];
strcpy(afs_sysname, SYS_NAME);
afs_sysnamecount = 1;
afs_sysnamegen++;
srv_secobj = rxnull_NewServerSecurityObject();
stats_svc = rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats", &srv_secobj,
1, RXSTATS_ExecuteRequest);
pagcb_svc = rx_NewService(0, PAGCB_SERVICEID, "pagcb", &srv_secobj,
1, PAGCB_ExecuteRequest);
rx_StartServer(0);
clt_secobj = rxnull_NewClientSecurityObject();
rmtsys_conn = rx_NewConnection(nfs_server_addr, htons(7009),
RMTSYS_SERVICEID, clt_secobj, 0);
#ifdef RXK_LISTENER_ENV
afs_start_thread(rxk_Listener, "Rx Listener");
#endif
afs_start_thread((void *)(void *)rx_ServerProc, "Rx Server Thread");
afs_start_thread(afs_rxevent_daemon, "Rx Event Daemon");
afs_start_thread(afs_Daemon, "AFS PAG Daemon");
afs_icl_InitLogs();
AFS_GUNLOCK();
/* If it's reachable, tell the translator to nuke our creds.
* We should be more agressive about making sure this gets done,
* even if the translator is unreachable when we boot.
*/
addr = obuf = err = 0;
idata.rmtbulk_len = sizeof(addr);
idata.rmtbulk_val = (char *)&addr;
odata.rmtbulk_len = sizeof(obuf);
odata.rmtbulk_val = (char *)&obuf;
memset(&ccred, 0, sizeof(ccred));
code = RMTSYS_Pioctl(rmtsys_conn, &ccred, NIL_PATHP, 0x4F01, 0,
&idata, &odata, &err);
} /*afs_ResourceInit */
