/*!
* \brief send a Probe to all the network address of this server
*
* \return 0 if success, else return 1
*/
int
DoProbe(struct ubik_server *server)
{
struct rx_connection *conns[UBIK_MAX_INTERFACE_ADDR];
struct rx_connection *connSuccess = 0;
int i, j;
afs_uint32 addr;
char buffer[32];
char hoststr[16];
extern afs_int32 ubikSecIndex;
extern struct rx_securityClass *ubikSecClass;
for (i = 0; (addr = server->addr[i]) && (i < UBIK_MAX_INTERFACE_ADDR);
i++) {
conns[i] =
rx_NewConnection(addr, ubik_callPortal, DISK_SERVICE_ID,
ubikSecClass, ubikSecIndex);
/* user requirement to use only the primary interface */
if (ubikPrimaryAddrOnly) {
i = 1;
break;
}
}
assert(i); /* at least one interface address for this server */
multi_Rx(conns, i) {
multi_DISK_Probe();
if (!multi_error) { /* first success */
addr = server->addr[multi_i]; /* successful interface addr */
if (server->disk_rxcid) /* destroy existing conn */
rx_DestroyConnection(server->disk_rxcid);
if (server->vote_rxcid)
rx_DestroyConnection(server->vote_rxcid);
/* make new connections */
server->disk_rxcid = conns[multi_i];
server->vote_rxcid = rx_NewConnection(addr, ubik_callPortal, VOTE_SERVICE_ID, ubikSecClass, ubikSecIndex); /* for vote reqs */
connSuccess = conns[multi_i];
strcpy(buffer, afs_inet_ntoa_r(server->addr[0], hoststr));
ubik_print
("ubik:server %s is back up: will be contacted through %s\n",
buffer, afs_inet_ntoa_r(addr, hoststr));
multi_Abort;
}
} multi_End_Ignore;
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
}
static int
CommandProc(struct cmd_syndesc *as, void *arock)
{
struct rx_connection *conn;
register char *hostName;
register struct hostent *thp;
afs_int32 port;
struct rx_securityClass *secobj;
int int32p;
afs_int32 addr;
hostName = as->parms[0].items->data;
if (as->parms[1].items)
port = atoi(as->parms[1].items->data);
else
port = 7001;
thp = hostutil_GetHostByName(hostName);
if (!thp) {
printf("cmdebug: can't resolve address for host %s.\n", hostName);
exit(1);
}
memcpy(&addr, thp->h_addr, sizeof(afs_int32));
secobj = rxnull_NewServerSecurityObject();
conn = rx_NewConnection(addr, htons(port), 1, secobj, 0);
if (!conn) {
printf("cmdebug: failed to create connection for host %s\n", hostName);
exit(1);
}
if (as->parms[2].items) int32p = 1;
else int32p = 0;
PrintCacheEntries(conn, int32p);
return 0;
}
/*!
* \brief send a Probe to all the network address of this server
*
* \return 0 if success, else return 1
*/
int
DoProbe(struct ubik_server *server)
{
struct rx_connection *conns[UBIK_MAX_INTERFACE_ADDR];
struct rx_connection *connSuccess = 0;
int i, j, success_i = -1;
afs_uint32 addr;
char buffer[32];
char hoststr[16];
UBIK_ADDR_LOCK;
for (i = 0; (addr = server->addr[i]) && (i < UBIK_MAX_INTERFACE_ADDR);
i++) {
conns[i] =
rx_NewConnection(addr, ubik_callPortal, DISK_SERVICE_ID,
addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
/* user requirement to use only the primary interface */
if (ubikPrimaryAddrOnly) {
i = 1;
break;
}
}
UBIK_ADDR_UNLOCK;
opr_Assert(i); /* at least one interface address for this server */
multi_Rx(conns, i) {
multi_DISK_Probe();
if (!multi_error) { /* first success */
success_i = multi_i;
multi_Abort;
}
} multi_End_Ignore;
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);
}
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);
}
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;
}
struct rx_connection *
aafs_conn_byaddr(struct aafs_cell *cell,
struct sockaddr *so,
socklen_t slen,
short port,
uint32_t service)
{
uint32_t addr;
struct rx_securityClass *secobj;
int secidx;
if (so->sa_family != PF_INET)
return NULL;
addr = ((struct sockaddr_in *)so)->sin_addr.s_addr;
aafs_cell_rx_secclass(cell, &secobj, &secidx);
return rx_NewConnection(addr, port, service, secobj, secidx);
}
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);
}
static ConnCacheEntry *
new_connection (int32_t cell,
uint32_t host,
uint16_t port,
uint16_t service,
nnpfs_pag_t cred,
int securityindex,
int (*probe)(struct rx_connection *),
struct rx_securityClass *securityobject)
{
ConnCacheEntry *e;
assert (probe != NULL);
e = get_free_connection ();
e->cell = cell;
e->host = host;
e->port = port;
e->service = service;
e->flags.alivep = TRUE;
e->flags.old = FALSE;
e->refcount = 0;
e->cred = cred;
e->securityindex = securityindex;
e->probe = probe;
e->connection = rx_NewConnection (host,
htons (port),
service,
securityobject,
securityindex);
if (e->connection == NULL)
arla_errx (1, ADEBERROR, "rx_NewConnection failed");
return e;
}
/*!
* \brief So that intermittent failures that cause connections to die
* don't kill whole ubik connection, refresh them when the connection is in
* error.
*/
struct rx_connection *
ubik_RefreshConn(struct rx_connection *tc)
{
afs_uint32 host;
u_short port;
u_short service;
struct rx_securityClass *sc;
int si;
struct rx_connection *newTc;
host = rx_HostOf(rx_PeerOf(tc));
port = rx_PortOf(rx_PeerOf(tc));
service = rx_ServiceIdOf(tc);
sc = rx_SecurityObjectOf(tc);
si = rx_SecurityClassOf(tc);
/*
* destroy old one after creating new one so that refCount on security
* object cannot reach zero.
*/
newTc = rx_NewConnection(host, port, service, sc, si);
rx_DestroyConnection(tc);
return newTc;
}
static long
RunCallTest(struct clientParms *parms, long host,
struct rx_securityClass *sc, long si)
{
long code;
#ifndef rx_GetPacketCksum
code = RXKST_BADARGS;
afs_com_err(whoami, code,
"Older versions of Rx don't support Get/Set callNumber Vector procedures: can't run this CallTest");
return code;
#else
int i, ch;
struct rx_connection *conn;
long firstCall;
afs_int32 callNumbers[RX_MAXCALLS];
long codes[RX_MAXCALLS];
long retCode = 0; /* ret. if nothing fatal goes wrong */
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID, sc,
si);
if (!conn)
return RXKST_NEWCONNFAILED;
/* First check the basic behaviour of call number handling */
code = rxi_GetCallNumberVector(conn, callNumbers);
if (code)
return code;
for (i = 0; i < RX_MAXCALLS; i++) {
if (callNumbers[i] != 0) {
fprintf(stderr,
"Connection's initial call numbers not zero. call[%d] = %d\n",
i, callNumbers[i]);
return RXKST_BADCALLNUMBERS;
}
}
code = FastCall(conn);
if (code)
return code;
code = rxi_GetCallNumberVector(conn, callNumbers);
if (code)
return code;
firstCall = callNumbers[0];
code = FastCall(conn);
if (code)
return code;
code = rxi_GetCallNumberVector(conn, callNumbers);
if (code)
return code;
if ((callNumbers[0] != firstCall + 1)
&& ((firstCall == 1) || (firstCall == 2))) {
/* The call number after the first call should be one or, more likely,
* two (if the call is still DALLYing). Between first and second call,
* the call number should have incremented by one. */
fprintf(stderr,
"Connection's first channel call number not one. call[%d] = %d\n",
0, callNumbers[0]);
return RXKST_BADCALLNUMBERS;
}
for (i = 1; i < RX_MAXCALLS; i++) {
if (callNumbers[i] != 0) {
fprintf(stderr,
"Connection's other channel call numbers not zero. call[%d] = %d\n",
i, callNumbers[i]);
return RXKST_BADCALLNUMBERS;
}
}
code = MakeMultiChannelCall(conn, 1, 0, codes);
if (code)
return code;
/* Now try to resend a call that's already been executed by finding a
* non-zero call number on a channel other than zero and decrementing it by
* one. This should appear to the server as a retransmitted call. Since
* this is behaving as a broken client different strange behaviors may be
* exhibited by different servers. If the response packet to the original
* call is discarded by the time the "retransmitted" call arrives (perhaps
* due to high server or client load) there is no way for the server to
* respond at all. Further, it seems, that under some cases the connection
* will be kept alive indefinitely even though the server has discarded the
* "retransmitted" call and is making no effort to reexecute the call. To
* handle these, accept either a timeout (-1) or and INCFAILED error here,
* also set the connenction HardDeadTime to punt after a reasonable
* interval. */
/* short dead time since may we expect some trouble */
rx_SetConnHardDeadTime(conn, 30);
code = rxi_GetCallNumberVector(conn, callNumbers);
if (code)
return code;
for (ch = 1; ch < RX_MAXCALLS; ch++)
if (callNumbers[ch] > 1) {
callNumbers[ch]--;
code = rxi_SetCallNumberVector(conn, callNumbers);
if (code)
return code;
break;
}
if (ch >= RX_MAXCALLS) /* didn't find any? all DALLYing? */
return RXKST_BADCALLNUMBERS;
code = MakeMultiChannelCall(conn, 1, RXKST_INCFAILED, codes);
code = CheckCallFailure(conn, codes, code, "retransmitted call");
if (code && !retCode)
retCode = code;
/* Get a fresh connection, becasue if the above failed as it should the
* connection is dead. */
rx_DestroyConnection(conn);
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID, sc,
si);
if (!conn)
return RXKST_NEWCONNFAILED;
/* Similarly, but decrement call number by two which should be completely
* unmistakeable as a broken or malicious client. */
/* short dead time since may we expect some trouble */
rx_SetConnHardDeadTime(conn, 30);
code = MakeMultiChannelCall(conn, 2, 0, codes);
if (code)
return code;
code = rxi_GetCallNumberVector(conn, callNumbers);
if (code)
return code;
for (ch = 1; ch < RX_MAXCALLS; ch++)
if (callNumbers[ch] > 2) {
callNumbers[ch] -= 2;
code = rxi_SetCallNumberVector(conn, callNumbers);
break;
}
if (ch >= RX_MAXCALLS) /* didn't find any? all DALLYing? */
return RXKST_BADCALLNUMBERS;
code = MakeMultiChannelCall(conn, 1, -1, codes);
code = CheckCallFailure(conn, codes, code, "duplicate call");
if (code && !retCode)
retCode = code;
rx_DestroyConnection(conn);
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID, sc,
si);
if (!conn)
return RXKST_NEWCONNFAILED;
/* Next, without waiting for the server to discard its state, we will check
* to see if the Challenge/Response protocol correctly informs the server
* of the client's callNumber state. We do this by artificially increasing
* the call numbers of a new connection for all channels beyond zero,
* making a call on channel zero, then resetting the call number for the
* unused channels back to zero, then making calls on all channels. */
code = rxi_GetCallNumberVector(conn, callNumbers);
if (code)
return code;
for (i = 0; i < RX_MAXCALLS; i++) {
if (callNumbers[i] != 0)
return RXKST_BADCALLNUMBERS;
callNumbers[i] = 51; /* an arbitrary value... */
}
code = rxi_SetCallNumberVector(conn, callNumbers);
if (code)
return code;
code = FastCall(conn); /* use channel 0 */
if (code)
return code;
code = rxi_GetCallNumberVector(conn, callNumbers);
if (code)
return code;
if (callNumbers[0] != 52)
return RXKST_BADCALLNUMBERS;
for (i = 1; i < RX_MAXCALLS; i++) {
if (callNumbers[i] != 51)
return RXKST_BADCALLNUMBERS;
callNumbers[i] = 37; /* back up a ways */
}
code = rxi_SetCallNumberVector(conn, callNumbers);
if (code)
return code;
/* now try calls on all channels... */
code = MakeMultiChannelCall(conn, 1, -1, codes);
code =
CheckCallFailure(conn, codes, code, "alternate channel call replay");
if (code && !retCode)
retCode = code;
rx_DestroyConnection(conn);
return retCode;
#endif /* rx_GetPacketCksum */
}
/*!
* \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;
}
/* takes server in host byte order */
struct afscp_server *
afscp_ServerById(struct afscp_cell *thecell, afsUUID * u)
{
/* impliment uniquifiers? */
int i, code;
struct afscp_server **newlist;
struct afscp_server **newall;
struct afscp_server *ret = NULL;
afsUUID tmp;
bulkaddrs addrs;
struct ListAddrByAttributes attrs;
afs_int32 nentries, uniq;
char s[512];
afsUUID_to_string(u, s, 511);
afs_dprintf(("GetServerByID %s\n", s));
for (i = 0; i < thecell->nservers; i++) {
if (afs_uuid_equal(&thecell->fsservers[i]->id, u)) {
return thecell->fsservers[i];
}
}
if (thecell->nservers >= thecell->srvsalloced) {
if (thecell->srvsalloced)
thecell->srvsalloced = thecell->srvsalloced * 2;
else
thecell->srvsalloced = 4;
newlist = realloc(thecell->fsservers,
thecell->srvsalloced *
sizeof(struct afscp_server *));
if (newlist == NULL) {
return NULL;
}
thecell->fsservers = newlist;
}
ret = malloc(sizeof(struct afscp_server));
if (ret == NULL) {
return NULL;
}
memset(ret, 0, sizeof(struct afscp_server));
thecell->fsservers[thecell->nservers] = ret;
memmove(&ret->id, u, sizeof(afsUUID));
ret->cell = thecell->id;
memset(&tmp, 0, sizeof(tmp));
memset(&addrs, 0, sizeof(addrs));
memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_UUID;
memmove(&attrs.uuid, u, sizeof(afsUUID));
code = ubik_VL_GetAddrsU(thecell->vlservers, 0, &attrs, &tmp,
&uniq, &nentries, &addrs);
if (code != 0) {
return NULL;
}
if (nentries > AFS_MAXHOSTS) {
nentries = AFS_MAXHOSTS;
/* XXX I don't want to do *that* much dynamic allocation */
abort();
}
ret->naddrs = nentries;
for (i = 0; i < nentries; i++) {
ret->addrs[i] = htonl(addrs.bulkaddrs_val[i]);
ret->conns[i] = rx_NewConnection(ret->addrs[i],
htons(AFSCONF_FILEPORT),
1, thecell->security,
thecell->scindex);
}
_xdr_free(_xdr_bulkaddrs, &addrs);
thecell->nservers++;
if (afscp_nservers >= afscp_srvsalloced) {
if (afscp_srvsalloced)
afscp_srvsalloced = afscp_srvsalloced * 2;
else
afscp_srvsalloced = 4;
newall = realloc(allservers,
afscp_srvsalloced * sizeof(struct afscp_server *));
if (newall == NULL) {
return ret;
}
allservers = newall;
}
ret->index = afscp_nservers;
allservers[afscp_nservers++] = ret;
return ret;
}
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
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;
}
/* 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);
}
/**
* Connects to a server by it's server address.
*
* @param sap Server address.
* @param aport Server port.
* @param acell
* @param tu Connect as this user.
* @param force_if_down
* @param create
* @param locktype Specifies type of lock to be used for this function.
*
* @return The new connection.
*/
struct afs_conn *
afs_ConnBySA(struct srvAddr *sap, unsigned short aport, afs_int32 acell,
struct unixuser *tu, int force_if_down, afs_int32 create,
afs_int32 locktype, struct rx_connection **rxconn)
{
int glocked, foundvec;
struct afs_conn *tc = NULL;
struct sa_conn_vector *tcv = NULL;
struct rx_securityClass *csec; /*Security class object */
int isec; /*Security index */
int service;
*rxconn = NULL;
/* find cached connection */
ObtainSharedLock(&afs_xconn, 15);
foundvec = 0;
for (tcv = sap->conns; tcv; tcv = tcv->next) {
if (tcv->user == tu && tcv->port == aport) {
/* return most eligible conn */
if (!foundvec)
foundvec = 1;
UpgradeSToWLock(&afs_xconn, 37);
tc = find_preferred_connection(tcv, create);
ConvertWToSLock(&afs_xconn);
break;
}
}
if (!tc && !create) {
/* Not found and can't create a new one. */
ReleaseSharedLock(&afs_xconn);
return NULL;
}
if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {
afs_warnuser("afs_ConnBySA: disconnected\n");
ReleaseSharedLock(&afs_xconn);
return NULL;
}
if (!foundvec && create) {
/* No such connection vector exists. Create one and splice it in.
* Make sure the server record has been marked as used (for the purposes
* of calculating up & down times, it's now considered to be an
* ``active'' server). Also make sure the server's lastUpdateEvalTime
* gets set, marking the time of its ``birth''.
*/
UpgradeSToWLock(&afs_xconn, 37);
new_conn_vector(tcv);
tcv->user = tu;
tcv->port = aport;
tcv->srvr = sap;
tcv->next = sap->conns;
sap->conns = tcv;
/* all struct afs_conn ptrs come from here */
tc = find_preferred_connection(tcv, create);
afs_ActivateServer(sap);
ConvertWToSLock(&afs_xconn);
} /* end of if (!tcv) */
if (!tc) {
/* Not found and no alternatives. */
ReleaseSharedLock(&afs_xconn);
return NULL;
}
if (tu->states & UTokensBad) {
/* we may still have an authenticated RPC connection here,
* we'll have to create a new, unauthenticated, connection.
* Perhaps a better way to do this would be to set
* conn->forceConnectFS on all conns when the token first goes
* bad, but that's somewhat trickier, due to locking
* constraints (though not impossible).
*/
if (tc->id && (rx_SecurityClassOf(tc->id) != 0)) {
tc->forceConnectFS = 1; /* force recreation of connection */
}
tu->states &= ~UHasTokens; /* remove the authentication info */
}
glocked = ISAFS_GLOCK();
if (tc->forceConnectFS) {
UpgradeSToWLock(&afs_xconn, 38);
csec = (struct rx_securityClass *)0;
if (tc->id) {
if (glocked)
AFS_GUNLOCK();
rx_SetConnSecondsUntilNatPing(tc->id, 0);
rx_DestroyConnection(tc->id);
if (glocked)
AFS_GLOCK();
}
/*
* Stupid hack to determine if using vldb service or file system
* service.
*/
if (aport == sap->server->cell->vlport)
service = 52;
else
service = 1;
isec = 0;
csec = afs_pickSecurityObject(tc, &isec);
if (glocked)
AFS_GUNLOCK();
tc->id = rx_NewConnection(sap->sa_ip, aport, service, csec, isec);
if (glocked)
AFS_GLOCK();
if (service == 52) {
rx_SetConnHardDeadTime(tc->id, afs_rx_harddead);
}
/* set to a RX_CALL_TIMEOUT error to allow MTU retry to trigger */
rx_SetServerConnIdleDeadErr(tc->id, RX_CALL_DEAD);
rx_SetConnIdleDeadTime(tc->id, afs_rx_idledead);
/*
* Only do this for the base connection, not per-user.
* Will need to be revisited if/when CB gets security.
*/
if ((isec == 0) && (service != 52) && !(tu->states & UTokensBad) &&
(tu->viceId == UNDEFVID)
#ifndef UKERNEL /* ukernel runs as just one uid anyway */
&& (tu->uid == 0)
#endif
)
rx_SetConnSecondsUntilNatPing(tc->id, 20);
tc->forceConnectFS = 0; /* apparently we're appropriately connected now */
if (csec)
rxs_Release(csec);
ConvertWToSLock(&afs_xconn);
} /* end of if (tc->forceConnectFS)*/
*rxconn = tc->id;
rx_GetConnection(*rxconn);
ReleaseSharedLock(&afs_xconn);
return tc;
}
static void
do_client(const char *server, short port, char *filename, afs_int32 command,
afs_int32 times, afs_int32 bytes, afs_int32 sendbytes, afs_int32 readbytes,
int dumpstats, int nojumbo, int maxmtu, int maxwsize, int minpeertimeout,
int udpbufsz, int nostats, int hotthread, int threads)
{
struct rx_connection *conn;
afs_uint32 addr;
struct rx_securityClass *secureobj;
int secureindex;
int ret;
char stamp[2048];
struct client_data *params;
#ifdef AFS_PTHREAD_ENV
int i;
pthread_t thread[MAX_THREADS];
pthread_attr_t tattr;
void *status;
#endif
params = calloc(1, sizeof(struct client_data));
#ifdef AFS_NT40_ENV
if (afs_winsockInit() < 0) {
printf("Can't initialize winsock.\n");
exit(1);
}
#endif
if (hotthread)
rx_EnableHotThread();
if (nostats)
rx_enable_stats = 0;
addr = str2addr(server);
rx_SetUdpBufSize(udpbufsz);
ret = rx_Init(0);
if (ret)
errx(1, "rx_Init failed");
if (nojumbo)
rx_SetNoJumbo();
if (maxmtu)
rx_SetMaxMTU(maxmtu);
if (maxwsize) {
rx_SetMaxReceiveWindow(maxwsize);
rx_SetMaxSendWindow(maxwsize);
}
if (minpeertimeout)
rx_SetMinPeerTimeout(minpeertimeout);
get_sec(0, &secureobj, &secureindex);
switch (command) {
case RX_PERF_RPC:
sprintf(stamp, "RPC: threads\t%d, times\t%d, write bytes\t%d, read bytes\t%d",
threads, times, sendbytes, readbytes);
break;
case RX_PERF_RECV:
sprintf(stamp, "RECV: threads\t%d, times\t%d, bytes\t%d",
threads, times, bytes);
break;
case RX_PERF_SEND:
sprintf(stamp, "SEND: threads\t%d, times\t%d, bytes\t%d",
threads, times, bytes);
break;
case RX_PERF_FILE:
sprintf(stamp, "FILE %s: threads\t%d, times\t%d, bytes\t%d",
filename, threads, times, bytes);
break;
}
conn = rx_NewConnection(addr, htons(port), RX_SERVER_ID, secureobj, secureindex);
if (conn == NULL)
errx(1, "failed to contact server");
#ifdef AFS_PTHREAD_ENV
pthread_attr_init(&tattr);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
#endif
params->conn = conn;
params->filename = filename;
params->command = command;
params->times = times;
params->bytes = bytes;
params->sendbytes = sendbytes;
params->readbytes = readbytes;
start_timer();
#ifdef AFS_PTHREAD_ENV
for ( i=0; i<threads; i++) {
pthread_create(&thread[i], &tattr, client_thread, params);
if ( (i + 1) % RX_MAXCALLS == 0 ) {
conn = rx_NewConnection(addr, htons(port), RX_SERVER_ID, secureobj, secureindex);
if (conn != NULL) {
struct client_data *new_params = malloc(sizeof(struct client_data));
memcpy(new_params, params, sizeof(struct client_data));
new_params->conn = conn;
params = new_params;
}
}
}
#else
client_thread(params);
#endif
#ifdef AFS_PTHREAD_ENV
for ( i=0; i<threads; i++)
pthread_join(thread[i], &status);
#endif
switch (command) {
case RX_PERF_RPC:
end_and_print_timer(stamp, (long long)threads*times*(sendbytes+readbytes));
break;
case RX_PERF_RECV:
case RX_PERF_SEND:
case RX_PERF_FILE:
end_and_print_timer(stamp, (long long)threads*times*bytes);
break;
}
DBFPRINT(("done for good\n"));
if (dumpstats) {
rx_PrintStats(stdout);
rx_PrintPeerStats(stdout, rx_PeerOf(conn));
}
rx_Finalize();
#ifdef AFS_PTHREAD_ENV
pthread_attr_destroy(&tattr);
#endif
free(params);
}
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;
}
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);
}
/**
* Connects to a server by it's server address.
*
* @param sap Server address.
* @param aport Server port.
* @param acell
* @param tu Connect as this user.
* @param force_if_down
* @param create
* @param locktype Specifies type of lock to be used for this function.
*
* @return The new connection.
*/
struct afs_conn *
afs_ConnBySA(struct srvAddr *sap, unsigned short aport, afs_int32 acell,
struct unixuser *tu, int force_if_down, afs_int32 create,
afs_int32 locktype)
{
struct afs_conn *tc = 0;
struct rx_securityClass *csec; /*Security class object */
int isec; /*Security index */
int service;
if (!sap || ((sap->sa_flags & SRVR_ISDOWN) && !force_if_down)) {
/* sa is known down, and we don't want to force it. */
return NULL;
}
ObtainSharedLock(&afs_xconn, 15);
/* Get conn by port and user. */
for (tc = sap->conns; tc; tc = tc->next) {
if (tc->user == tu && tc->port == aport) {
break;
}
}
if (!tc && !create) {
/* Not found and can't create a new one. */
ReleaseSharedLock(&afs_xconn);
return NULL;
}
if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {
afs_warnuser("afs_ConnBySA: disconnected\n");
ReleaseSharedLock(&afs_xconn);
return NULL;
}
if (!tc) {
/* No such connection structure exists. Create one and splice it in.
* Make sure the server record has been marked as used (for the purposes
* of calculating up & down times, it's now considered to be an
* ``active'' server). Also make sure the server's lastUpdateEvalTime
* gets set, marking the time of its ``birth''.
*/
UpgradeSToWLock(&afs_xconn, 37);
tc = (struct afs_conn *)afs_osi_Alloc(sizeof(struct afs_conn));
memset(tc, 0, sizeof(struct afs_conn));
tc->user = tu;
tc->port = aport;
tc->srvr = sap;
tc->refCount = 0; /* bumped below */
tc->forceConnectFS = 1;
tc->id = (struct rx_connection *)0;
tc->next = sap->conns;
sap->conns = tc;
afs_ActivateServer(sap);
ConvertWToSLock(&afs_xconn);
} /* end of if (!tc) */
tc->refCount++;
if (tu->states & UTokensBad) {
/* we may still have an authenticated RPC connection here,
* we'll have to create a new, unauthenticated, connection.
* Perhaps a better way to do this would be to set
* conn->forceConnectFS on all conns when the token first goes
* bad, but that's somewhat trickier, due to locking
* constraints (though not impossible).
*/
if (tc->id && (rx_SecurityClassOf(tc->id) != 0)) {
tc->forceConnectFS = 1; /* force recreation of connection */
}
tu->vid = UNDEFVID; /* forcibly disconnect the authentication info */
}
if (tc->forceConnectFS) {
UpgradeSToWLock(&afs_xconn, 38);
csec = (struct rx_securityClass *)0;
if (tc->id) {
AFS_GUNLOCK();
rx_DestroyConnection(tc->id);
AFS_GLOCK();
}
/*
* Stupid hack to determine if using vldb service or file system
* service.
*/
if (aport == sap->server->cell->vlport)
service = 52;
else
service = 1;
isec = 0;
csec = afs_pickSecurityObject(tc, &isec);
AFS_GUNLOCK();
tc->id = rx_NewConnection(sap->sa_ip, aport, service, csec, isec);
AFS_GLOCK();
if (service == 52) {
rx_SetConnHardDeadTime(tc->id, afs_rx_harddead);
}
/* set to a RX_CALL_TIMEOUT error to allow MTU retry to trigger */
rx_SetServerConnIdleDeadErr(tc->id, RX_CALL_DEAD);
rx_SetConnIdleDeadTime(tc->id, afs_rx_idledead);
rx_SetMsgsizeRetryErr(tc->id, RX_MSGSIZE);
/*
* Only do this for the base connection, not per-user.
* Will need to be revisited if/when CB gets security.
*/
if ((isec == 0) && (service != 52) && !(tu->states & UTokensBad) &&
(tu->vid == UNDEFVID))
rx_SetConnSecondsUntilNatPing(tc->id, 20);
tc->forceConnectFS = 0; /* apparently we're appropriately connected now */
if (csec)
rxs_Release(csec);
ConvertWToSLock(&afs_xconn);
} /* end of if (tc->forceConnectFS)*/
ReleaseSharedLock(&afs_xconn);
return tc;
}
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);
}
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;
}
/* takes server in host byte order */
struct afscp_server *
afscp_ServerByAddr(struct afscp_cell *thecell, afs_uint32 addr)
{
/* implement uniquifiers? */
int i, j;
struct afscp_server **newlist;
struct afscp_server **newall;
struct afscp_server *ret = NULL;
afsUUID uuid;
bulkaddrs addrs;
struct ListAddrByAttributes attrs;
afs_int32 nentries, code, uniq;
if (thecell == NULL)
return ret; /* cannot continue without thecell */
for (i = 0; i < thecell->nservers; i++) {
ret = thecell->fsservers[i];
for (j = 0; j < ret->naddrs; j++)
if (ret->addrs[j] == htonl(addr)) {
return ret;
}
}
if (thecell->nservers >= thecell->srvsalloced) {
if (thecell->srvsalloced)
thecell->srvsalloced = thecell->srvsalloced * 2;
else
thecell->srvsalloced = 4;
newlist = realloc(thecell->fsservers,
thecell->srvsalloced * sizeof(struct afscp_server));
if (newlist == NULL) {
return NULL;
}
thecell->fsservers = newlist;
}
ret = malloc(sizeof(struct afscp_server));
if (ret == NULL) {
return NULL;
}
memset(ret, 0, sizeof(struct afscp_server));
thecell->fsservers[thecell->nservers] = ret;
ret->cell = thecell->id;
memset(&uuid, 0, sizeof(uuid));
memset(&addrs, 0, sizeof(addrs));
memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_IPADDR;
attrs.ipaddr = addr;
code = ubik_VL_GetAddrsU(thecell->vlservers, 0, &attrs, &uuid,
&uniq, &nentries, &addrs);
if (code != 0) {
memset(&ret->id, 0, sizeof(uuid));
ret->naddrs = 1;
ret->addrs[0] = htonl(addr);
ret->conns[0] = rx_NewConnection(ret->addrs[0],
htons(AFSCONF_FILEPORT),
1, thecell->security,
thecell->scindex);
} else {
char s[512];
afsUUID_to_string(&uuid, s, 511);
afs_dprintf(("GetServerByAddr 0x%x -> uuid %s\n", addr, s));
if (nentries > AFS_MAXHOSTS) {
nentries = AFS_MAXHOSTS;
/* XXX I don't want to do *that* much dynamic allocation */
abort();
}
memmove(&ret->id, &uuid, sizeof(afsUUID));
ret->naddrs = nentries;
for (i = 0; i < nentries; i++) {
ret->addrs[i] = htonl(addrs.bulkaddrs_val[i]);
ret->conns[i] = rx_NewConnection(ret->addrs[i],
htons(AFSCONF_FILEPORT),
1, thecell->security,
thecell->scindex);
}
_xdr_free(_xdr_bulkaddrs, &addrs);
}
thecell->nservers++;
if (afscp_nservers >= afscp_srvsalloced) {
if (afscp_srvsalloced)
afscp_srvsalloced = afscp_srvsalloced * 2;
else
afscp_srvsalloced = 4;
newall = realloc(allservers,
afscp_srvsalloced * sizeof(struct afscp_server *));
if (newall == NULL) {
return ret;
}
allservers = newall;
}
ret->index = afscp_nservers;
allservers[afscp_nservers++] = ret;
return ret;
}
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 */
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 */
