static void *
BKGSleep(void *unused)
{
struct volser_trans *tt;
if (TTsleep) {
while (1) {
#ifdef AFS_PTHREAD_ENV
sleep(TTrun);
#else /* AFS_PTHREAD_ENV */
IOMGR_Sleep(TTrun);
#endif
VTRANS_LOCK;
for (tt = TransList(); tt; tt = tt->next) {
VTRANS_OBJ_LOCK(tt);
if ((strcmp(tt->lastProcName, "DeleteVolume") == 0)
|| (strcmp(tt->lastProcName, "Clone") == 0)
|| (strcmp(tt->lastProcName, "ReClone") == 0)
|| (strcmp(tt->lastProcName, "Forward") == 0)
|| (strcmp(tt->lastProcName, "Restore") == 0)
|| (strcmp(tt->lastProcName, "ForwardMulti") == 0)) {
VTRANS_OBJ_UNLOCK(tt);
break;
}
VTRANS_OBJ_UNLOCK(tt);
}
if (tt) {
VTRANS_UNLOCK;
sleep(TTsleep);
} else
VTRANS_UNLOCK;
}
}
return NULL;
}
static void
ares_worker_thread(char *ptr)
{
struct timeval tv, max_tv = { 30, 0 };
fd_set readset, writeset;
int nfds, ret;
while (1) {
FD_ZERO(&readset);
FD_ZERO(&writeset);
nfds = ares_fds(achannel, &readset, &writeset);
if (nfds == 0) {
tv = max_tv;
IOMGR_Sleep(max_tv.tv_sec);
} else {
struct timeval *tvp;
tvp = ares_timeout(achannel, &max_tv, &tv);
ret = IOMGR_Select(nfds, &readset, &writeset, NULL, tvp);
if (ret < 0)
/* XXX some error, lets ignore that for now */;
else if (ret == 0)
/* timeout */;
else
ares_process(achannel, &readset, &writeset);
}
}
}
/* KeepAlive
*
* While dumping the database, keeps the connection alive.
* Every 10 seconds, wake up and ask to read 0 bytes of the database.
* This resets the database's internal timer so that it does not
* prematuraly quit (on asking for new tapes and such).
*
* Use the same udbHandle as writeDbDump so we go to the same server.
*/
void *
KeepAlive(void *unused)
{
charListT charList;
afs_int32 code;
afs_int32 done;
extern struct udbHandleS udbHandle;
while (1) {
#ifdef AFS_PTHREAD_ENV
sleep(5);
#else
IOMGR_Sleep(5);
#endif
charList.charListT_val = 0;
charList.charListT_len = 0;
code =
ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
UF_SINGLESERVER, 0, 0, &charList, &done);
if (code || done)
break;
}
return 0;
}
static void
heapcleaner (char *arg)
{
const void *head;
struct timeval tv;
while (1) {
while ((head = heap_head (heap_ccpairs)) == NULL)
LWP_WaitProcess (heap_ccpairs);
while ((head = heap_head (heap_ccpairs)) != NULL) {
struct ropa_ccpair *cc = (struct ropa_ccpair *)head;
gettimeofday (&tv, NULL);
if (tv.tv_sec < cc->expire) {
unsigned long t = cc->expire - tv.tv_sec;
IOMGR_Sleep (t);
} else {
/* XXX should this be fixed?
listdel (cc->cb->ccpairs, cc->cb_li);
cc->cb_li = NULL; */
break_ccpair (cc, TRUE); /* will remove it from the heap */
}
}
}
}
static void
MrSleepy(void *foo)
{
printf("[mrsleepy] I'm going to bed\n");
while (1) {
IOMGR_Sleep(1);
printf("[mrsleepy] yawn\n");
}
}
void *
dumpWatcher(void *unused)
{
afs_int32 code;
while (1) { /*w */
/* printf("dumpWatcher\n"); */
ObtainWriteLock(&dumpSyncPtr->ds_lock);
if (dumpSyncPtr->statusFlags == 0) {
/* dump has finished */
goto exit;
}
/* check time to live */
if (time(0) > dumpSyncPtr->timeToLive) { /*i */
/* dump has exceeded the allocated time - terminate it */
LogError(0, "Database dump timeout exceeded: %s",
ctime(&dumpSyncPtr->timeToLive));
LogError(0, "Terminating database dump\n");
close(dumpSyncPtr->pipeFid[0]);
close(dumpSyncPtr->pipeFid[1]);
#ifdef AFS_PTHREAD_ENV
assert(pthread_cancel(dumpSyncPtr->dumperPid) == 0);
#else
code = LWP_DestroyProcess(dumpSyncPtr->dumperPid);
if (code)
LogError(code, "dumpWatcher: failed to kill dump thread\n");
#endif
if (dumpSyncPtr->ut) {
code = ubik_AbortTrans(dumpSyncPtr->ut);
if (code)
LogError(code, "Aborting dump transaction\n");
}
memset(dumpSyncPtr, 0, sizeof(*dumpSyncPtr));
goto exit;
}
/*i */
ReleaseWriteLock(&dumpSyncPtr->ds_lock);
#ifdef AFS_PTHREAD_ENV
sleep(5);
#else
IOMGR_Sleep(5);
#endif
} /*w */
exit:
ReleaseWriteLock(&dumpSyncPtr->ds_lock);
/* printf("dumpWatcher exit\n"); */
return (0);
}
static void
freeEnterprise(void *foo)
{
PROCESS *pid = (PROCESS *) foo;
while(1) {
IOMGR_Sleep(1);
printf("[enterpri] Raise salery\n");
IOMGR_Cancel(*pid);
}
}
static void *
FiveMinuteCheckLWP(void *unused)
{
printf("start 5 min check lwp\n");
while (1) {
IOMGR_Sleep(fiveminutes);
/* close the log so it can be removed */
ReOpenLog(AFSDIR_SERVER_KALOG_FILEPATH); /* no trunc, just append */
}
return NULL;
}
void *
ih_sync_thread(void *dummy) {
while(1) {
#ifdef AFS_PTHREAD_ENV
sleep(10);
#else /* AFS_PTHREAD_ENV */
IOMGR_Sleep(60);
#endif /* AFS_PTHREAD_ENV */
ih_sync_all();
}
return NULL;
}
static void
SelectProducer(void *foo)
{
char *str = (char *) foo;
int len ;
if (str == NULL)
str = "foo";
len = strlen (str) ;
while(1) {
IOMGR_Sleep(1) ;
printf("[selprodu] %s\n", str);
}
}
void *
ih_sync_thread(void *dummy) {
afs_pthread_setname_self("ih_syncer");
while(1) {
#ifdef AFS_PTHREAD_ENV
sleep(10);
#else /* AFS_PTHREAD_ENV */
IOMGR_Sleep(60);
#endif /* AFS_PTHREAD_ENV */
ih_sync_all();
}
return NULL;
}
static long
RepeatLoadTest(struct clientParms *parms, struct rx_connection *conn)
{
long code;
long count;
if (parms->repeatInterval == 0) {
if (parms->repeatCount == 0)
parms->repeatCount = 1;
} else {
if (parms->repeatCount == 0)
parms->repeatCount = 0x7fffffff;
}
if (parms->printTiming) {
int types;
types =
(parms->fastCalls ? 1 : 0) + (parms->slowCalls ? 1 : 0) +
(parms->copiousCalls ? 1 : 0);
if (types > 1)
fprintf(stderr,
"Combined timings of several types of calls may not be meaningful.\n");
if (types == 0)
/* do timings of copious calls by default */
parms->copiousCalls = 10;
}
for (count = 0; count < parms->repeatCount; count++) {
code = RunLoadTest(parms, conn);
if (code)
return code;
if (parms->repeatInterval) {
u_long i = parms->repeatInterval;
u_long now = time(0);
u_long next = (now + i - 1) / i * i; /* round up to next interval */
while (now < next) {
#ifdef AFS_PTHREAD_ENV
sleep(next - now);
#else
IOMGR_Sleep(next - now);
#endif
now = time(0);
}
}
}
return code;
}
int
bc_LockText(udbClientTextP ctPtr)
{
afs_int32 code;
afs_int32 timeout, j = 0;
if (ctPtr->lockHandle != 0)
return (1); /* already locked */
timeout =
((ctPtr->textSize == 0) ? 30 : ((ctPtr->textSize / 50000) + 10));
while (1) {
code =
ubik_BUDB_GetLock(udbHandle.uh_client, 0,
udbHandle.uh_instanceId, ctPtr->textType, timeout,
&ctPtr->lockHandle);
if ((code != BUDB_LOCKED) && (code != BUDB_SELFLOCKED)) {
break;
}
/* Mention something every 30 seconds */
if (++j >= 30) {
afs_com_err(whoami, code,
"; Waiting for db configuration text unlock");
j = 0;
}
#ifdef AFS_PTHREAD_ENV
sleep(1);
#else
IOMGR_Sleep(1);
#endif
}
/* cleanup */
if (code)
ctPtr->lockHandle = 0;
return (code);
}
/* lwp to handle system restarts */
static void *
BozoDaemon(void *unused)
{
afs_int32 now;
/* now initialize the values */
bozo_newKTs = 1;
while (1) {
IOMGR_Sleep(60);
now = FT_ApproxTime();
if (bozo_restdisable) {
bozo_Log("Restricted mode disabled by signal\n");
bozo_restdisable = 0;
}
if (bozo_newKTs) { /* need to recompute restart times */
bozo_newKTs = 0; /* done for a while */
nextRestart = ktime_next(&bozo_nextRestartKT, BOZO_MINSKIP);
nextDay = ktime_next(&bozo_nextDayKT, BOZO_MINSKIP);
}
/* see if we should do a restart */
if (now > nextRestart) {
SBOZO_ReBozo(0); /* doesn't come back */
}
/* see if we should restart a server */
if (now > nextDay) {
nextDay = ktime_next(&bozo_nextDayKT, BOZO_MINSKIP);
/* call the bnode restartp function, and restart all that require it */
bnode_ApplyInstance(bdrestart, 0);
}
}
return NULL;
}
static int
Main(struct cmd_syndesc *as, void *arock)
{
int code;
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
char newCell[MAXKTCREALMLEN];
char *cell;
long serverList[MAXSERVERS];
extern struct passwd *getpwuid();
struct passwd *pw;
struct ktc_encryptionKey key;
char passwd[BUFSIZ];
int cellSpecified;
int i;
int verbose = (as->parms[1].items != 0);
int hostUsage = (as->parms[2].items != 0);
int waitReap = (as->parms[4].items != 0);
int doAuth = (as->parms[5].items != 0);
int number; /* number of iterations */
int callsPerSecond; /* to allow conn GC to run */
unsigned long lo, hi; /* mem usage */
unsigned long highWater; /* mem usage after reap period */
unsigned long lastWater; /* mem usage after last msg */
int serversUse[MAXSERVERS]; /* usage of each server */
long serversHost[MAXSERVERS]; /* host addr */
unsigned long startTime;
unsigned long now;
lo = 0;
whoami = as->a0name;
newCell[0] = 0;
if (as->parms[0].items)
number = atoi(as->parms[0].items->data);
else
number = 100;
if (as->parms[3].items)
callsPerSecond = atoi(as->parms[3].items->data);
else
callsPerSecond = 1;
if (doAuth && hostUsage) {
fprintf(stderr,
"Can't report host usage when calling UserAuthenticate\n");
return -1;
}
if (as->parms[12].items) { /* if username specified */
code =
ka_ParseLoginName(as->parms[12].items->data, name, instance,
newCell);
if (code) {
afs_com_err(whoami, code, "parsing user's name '%s'",
as->parms[12].items->data);
return code;
}
if (strlen(newCell) > 0)
cellSpecified = 1;
} else {
/* No explicit name provided: use Unix uid. */
pw = getpwuid(getuid());
if (pw == 0) {
printf("Can't figure out your name from your user id.\n");
return KABADCMD;
}
strncpy(name, pw->pw_name, sizeof(name));
strcpy(instance, "");
strcpy(newCell, "");
}
if (strcmp(as->parms[14].name, "-cell") == 0) {
if (as->parms[14].items) { /* if cell specified */
if (cellSpecified)
printf("Duplicate cell specification not allowed\n");
else
strncpy(newCell, as->parms[14].items->data, sizeof(newCell));
}
}
code = ka_ExpandCell(newCell, newCell, 0 /*local */ );
if (code) {
afs_com_err(whoami, code, "Can't expand cell name");
return code;
}
cell = newCell;
if (as->parms[13].items) { /* if password specified */
strncpy(passwd, as->parms[13].items->data, sizeof(passwd));
memset(as->parms[13].items->data, 0,
strlen(as->parms[13].items->data));
} else {
char msg[sizeof(name) + 15];
if (as->parms[12].items)
strcpy(msg, "Admin Password: "******"Password for %s: ", name);
code = read_pw_string(passwd, sizeof(passwd), msg, 0);
if (code)
code = KAREADPW;
else if (strlen(passwd) == 0)
code = KANULLPASSWORD;
if (code) {
afs_com_err(whoami, code, "reading password");
return code;
}
}
if (as->parms[15].items) {
struct cmd_item *ip;
char *ap[MAXSERVERS + 2];
for (ip = as->parms[15].items, i = 2; ip; ip = ip->next, i++)
ap[i] = ip->data;
ap[0] = "";
ap[1] = "-servers";
code = ubik_ParseClientList(i, ap, serverList);
if (code) {
afs_com_err(whoami, code, "could not parse server list");
return code;
}
ka_ExplicitCell(cell, serverList);
}
if (!doAuth) {
ka_StringToKey(passwd, cell, &key);
memset(passwd, 0, sizeof(passwd));
}
if (hostUsage) {
memset(serversUse, 0, sizeof(serversUse));
memset(serversHost, 0, sizeof(serversHost));
}
startTime = time(0);
for (i = 0; i < number; i++) {
if (doAuth) {
char *reason;
code =
ka_UserAuthenticateLife(0, name, instance, cell, passwd, 0,
&reason);
if (code) {
fprintf(stderr, "Unable to authenticate to AFS because %s.\n",
reason);
return code;
}
} else {
struct ktc_token token;
struct ktc_token *pToken;
struct ubik_client *ubikConn;
struct kaentryinfo tentry;
int c;
code =
ka_GetAdminToken(name, instance, cell, &key, 3600, &token,
1 /*new */ );
if (code) {
afs_com_err(whoami, code, "getting admin token");
return code;
}
pToken = &token;
if (token.ticketLen == 0) {
fprintf("Can't get admin token\n");
return -1;
}
code =
ka_AuthServerConn(cell, KA_MAINTENANCE_SERVICE, pToken,
&ubikConn);
if (code) {
afs_com_err(whoami, code, "Getting AuthServer ubik conn");
return code;
}
if (verbose)
for (c = 0; c < MAXSERVERS; c++) {
struct rx_connection *rxConn =
ubik_GetRPCConn(ubikConn, c);
struct rx_peer *peer;
if (rxConn == 0)
break;
peer = rx_PeerOf(rxConn);
printf("conn to %s:%d secObj:%x\n",
inet_ntoa(rx_HostOf(peer)), ntohs(rx_PortOf(peer)),
rxConn->securityObject);
}
code =
ubik_Call(KAM_GetEntry, ubikConn, 0, name, instance,
KAMAJORVERSION, &tentry);
if (code) {
afs_com_err(whoami, code, "getting information for %s.%s", name,
instance);
return code;
}
for (c = 0; c < MAXSERVERS; c++) {
struct rx_connection *rxConn = ubik_GetRPCConn(ubikConn, c);
int d;
if (rxConn == 0)
break;
if (rxConn->serial > 0) {
long host = rx_HostOf(rx_PeerOf(rxConn));
for (d = 0; d < MAXSERVERS; d++) {
if (serversHost[d] == 0)
serversHost[d] = host;
if (host == serversHost[d]) {
serversUse[d]++;
break;
}
}
}
if (verbose)
printf("serial is %d\n", rxConn->serial);
}
ubik_ClientDestroy(ubikConn);
}
now = time(0);
if (!lo)
lo = sbrk(0);
if (i && ((i & 0x3f) == 0)) {
unsigned long this = sbrk(0);
printf(" mem after %d: lo=%x, cur=%x => %d (@ %d)\n", i, lo,
this, this - lo, (this - lo) / i);
if (highWater && (lastWater != this)) {
lastWater = this;
printf(" core leaking (after %d) should be %x, is %x\n", i,
highWater, this);
}
}
if ((highWater == 0) && ((now - startTime) > 61)) {
highWater = sbrk(0);
lastWater = highWater;
printf(" mem highWater mark (after %d) should be %x\n", i,
highWater);
}
if (callsPerSecond) {
long target;
if (callsPerSecond > 0)
target = i / callsPerSecond;
else /* if negative interpret as seconds per call */
target = i * (-callsPerSecond);
target = (startTime + target) - now;
if (target > 0)
IOMGR_Sleep(target);
}
}
void
handleWrite(clientHandle_t * ch, selcmd_t * sc)
{
int i;
fd_set *rfds, *wfds, *efds;
char *buf;
int code;
int scode;
char c;
int nbytes;
rfds = IOMGR_AllocFDSet();
wfds = IOMGR_AllocFDSet();
efds = IOMGR_AllocFDSet();
assert(rfds && wfds && efds);
if (sc->sc_delay > 0) {
IOMGR_Sleep(sc->sc_delay);
}
Log("(handleWrite 0x%x) waking after %d second sleep.\n", ch->ch_pid,
sc->sc_delay);
if (sc->sc_flags & SC_WAIT_OOB)
sendOOB(ch->ch_fd);
buf = (char *)malloc(sc->sc_info);
assert(buf);
i = 0;
while (1) {
FD_ZERO(rfds);
FD_SET(ch->ch_fd, rfds);
FD_ZERO(efds);
FD_SET(ch->ch_fd, efds);
FD_ZERO(wfds);
scode =
IOMGR_Select(ch->ch_fd + 1, rfds, wfds, efds,
(struct timeval *)0);
assert(scode > 0);
if (FD_ISSET(ch->ch_fd, rfds)) {
assert(i < sc->sc_info);
code = read(ch->ch_fd, &buf[i], 1);
i++;
write_I++;
if (code != 1) {
Log("code =%d\n", code);
assert(code == 1);
}
/* Test for valid fds */
assertNullFDSet(ch->ch_fd, rfds);
assertNullFDSet(-1, wfds);
assertNullFDSet(-1, efds);
if (c == END_DATA || i >= sc->sc_info) {
break;
}
}
}
Log("Read %d bytes of data.\n", sc->sc_info);
nbytes = write(ch->ch_fd, buf, sc->sc_info);
assert(nbytes == sc->sc_info);
Log("Wrote data back to client.\n");
IOMGR_FreeFDSet(rfds);
IOMGR_FreeFDSet(wfds);
IOMGR_FreeFDSet(efds);
}
main(int ac, char **av)
{
int i;
int on = 1;
short port = -1; /* host order. */
int setFD = 0;
struct sockaddr_in saddr;
int acceptFD;
clientHandle_t *clientHandle;
int code;
int addr_len;
PROCESS pid;
fd_set *rfds, *wfds, *efds;
int sockFD;
program = av[0];
if (ac < 2)
Usage();
/* lwp_debug = 1; */
signal(SIGIO, sigIO);
for (i = 1; i < ac; i++) {
if (!strcmp("-fd", av[i])) {
if (++i >= ac) {
printf("Missing number for -fd option.\n");
Usage();
}
setFD = atoi(av[i]);
if (setFD <= 2) {
printf("%d: file descriptor must be at least 3.\n", setFD);
Usage();
}
} else {
if (port == -1) {
port = atoi(av[i]);
if (port <= 0) {
printf("%s: port must be at least 1\n", av[i]);
Usage();
}
} else {
printf("%s: Unknown argument.\n", av[i]);
}
}
}
if (port == -1) {
printf("Missing port.\n");
Usage();
}
if (!setFD) {
setFD = 31;
printf("Using default socket of %d.\n", setFD);
}
OpenFDs(setFD);
IOMGR_Initialize();
/* Setup server processes */
for (i = 0; i < MAX_THREADS; i++) {
if (LWP_CreateProcess
(handleRequest, 32768, LWP_NORMAL_PRIORITY,
(char *)&clientHandles[i], "HandleRequestThread", &pid) < 0) {
printf("%s: Failed to start all LWP's\n", program);
exit(1);
}
clientHandles[i].ch_pid = pid;
}
sockFD = socket(AF_INET, SOCK_STREAM, 0);
if (sockFD < 0) {
perror("socket");
exit(1);
}
Log("Using socket at file descriptor %d.\n", sockFD);
if (setsockopt(sockFD, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on))
< 0) {
perror("setsockopt: ");
exit(1);
}
memset((void *)&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = ntohs(port);
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sockFD, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
perror("bind: ");
exit(1);
}
rfds = IOMGR_AllocFDSet();
wfds = IOMGR_AllocFDSet();
efds = IOMGR_AllocFDSet();
if (!rfds || !wfds || !efds) {
printf("main: Could not alloc fd_set's.\n");
exit(1);
}
listen(sockFD, 100);
while (1) {
FD_ZERO(rfds);
FD_ZERO(wfds);
FD_ZERO(efds);
FD_SET(sockFD, rfds);
FD_SET(sockFD, efds);
Log("Main - going to select.\n");
code =
IOMGR_Select(sockFD + 1, rfds, wfds, efds, (struct timeval *)0);
switch (code) {
case 0: /* Timer, can't happen here. */
case -1:
case -2:
Log("Oops! select returns %d!\n", code);
abort();
default:
if (FD_ISSET(sockFD, efds)) {
recvOOB(sockFD);
assertNullFDSet(sockFD, rfds);
assertNullFDSet(-1, wfds);
assertNullFDSet(sockFD, efds);
}
if (FD_ISSET(sockFD, rfds)) {
while (nThreads > MAX_THREADS) {
IOMGR_Sleep(1);
}
clientHandle = getClientHandle();
addr_len = sizeof(clientHandle->ch_addr);
clientHandle->ch_fd = accept(sockFD, (struct sockaddr *)
&clientHandle->ch_addr,
&addr_len);
if (clientHandle->ch_fd < 0) {
perror("accept: ");
exit(1);
}
Log("Main - signalling LWP 0x%x\n", &clientHandle->ch_state);
LWP_NoYieldSignal(&clientHandle->ch_state);
assertNullFDSet(sockFD, rfds);
assertNullFDSet(-1, wfds);
assertNullFDSet(-1, efds);
break;
}
Die(1, "(main) No data to read.\n");
}
}
}
/*
* Delay the current thread the specified number of seconds.
*/
void
rxi_Delay(int sec)
{
IOMGR_Sleep(sec);
}
static void
pinger (char *arg)
{
for (;;) {
struct timeval tv;
Listitem *item;
ConnCacheEntry *e;
struct in_addr addr;
const char *port_str;
arla_warnx(ADEBCONN, "running pinger");
while (listemptyp (connprobelist))
LWP_WaitProcess (connprobelist);
item = listhead (connprobelist);
e = (ConnCacheEntry *)listdata (item);
assert (e->probe_le == item);
gettimeofday (&tv, NULL);
if (tv.tv_sec < e->probe_next) {
unsigned long t = e->probe_next - tv.tv_sec;
arla_warnx(ADEBCONN,
"pinger: sleeping %lu second(s)", t);
IOMGR_Sleep (t);
continue;
}
listdel (connprobelist, item);
e->probe_le = NULL;
if (e->flags.alivep)
continue;
addr.s_addr = e->host;
port_str = ports_num2name (e->port);
if (port_str != NULL)
arla_warnx (ADEBCONN, "pinger: probing %s/%s",
inet_ntoa(addr), port_str);
else
arla_warnx (ADEBCONN, "pinger: probing %s/%d",
inet_ntoa(addr), e->port);
++e->refcount;
if (e->probe == NULL)
arla_warnx(ADEBWARN, "pinger: probe function is NULL, "
"host: %s cell: %d port: %d",
inet_ntoa(addr), e->cell, e->port);
if (connected_mode == DISCONNECTED) {
arla_warnx(ADEBCONN, "pinger: ignoring host in disconnected mode");
} else if (e->probe && ((*(e->probe))(e->connection) == 0)) {
conn_alive (e);
} else {
re_probe (e);
}
conn_free (e);
}
}
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;
}
afs_int32
init_krb_udp(void)
#endif
{
struct sockaddr_in taddr;
static PROCESS slPid; /* socket listener pid */
static PROCESS checkPid; /* fiveminute check */
afs_int32 code;
char *krb4name; /* kerberos version4 service */
#if MAIN
PROCESS junk;
#endif
struct servent *sp;
static int inited = 0;
afs_int32 kerb_port;
if (inited)
return -1;
inited = 1;
memset(&taddr, 0, sizeof(taddr));
krb4name = "kerberos4";
sp = getservbyname(krb4name, "udp");
taddr.sin_family = AF_INET; /* added for NCR port */
#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
taddr.sin_len = sizeof(struct sockaddr_in);
#endif
if (!sp) {
/* if kerberos-4 is not available, try "kerberos-iv" */
krb4name = "kerberos-iv";
sp = getservbyname(krb4name, "udp");
}
if (!sp) {
/* if kerberos-iv is not available, try "kerberos" */
krb4name = "kerberos";
sp = getservbyname(krb4name, "udp");
}
if (!sp) {
fprintf(stderr,
"kerberos/udp is unknown; check /etc/services. Using port=%d as default\n",
KRB_PORT);
taddr.sin_port = htons(KRB_PORT);
} else {
/* copy the port number */
fprintf(stderr, "%s/udp port=%hu\n", krb4name,
(unsigned short)sp->s_port);
taddr.sin_port = sp->s_port;
}
kerb_port = taddr.sin_port;
sock_kerb = socket(AF_INET, SOCK_DGRAM, 0);
code = bind(sock_kerb, (struct sockaddr *)&taddr, sizeof(taddr));
if (code < 0) {
perror("calling bind");
sock_kerb = -1;
}
sp = getservbyname("kerberos5", "udp");
if (!sp) {
fprintf(stderr,
"kerberos5/udp is unknown; check /etc/services. Using port=%d as default\n",
KRB5_PORT);
taddr.sin_port = htons(KRB5_PORT);
} else {
/* copy the port number */
fprintf(stderr, "kerberos5/udp port=%hu\n",
(unsigned short)sp->s_port);
taddr.sin_port = sp->s_port;
}
if (taddr.sin_port != kerb_port) { /* a different port */
sock_kerb5 = socket(AF_INET, SOCK_DGRAM, 0);
code = bind(sock_kerb5, (struct sockaddr *)&taddr, sizeof(taddr));
if (code < 0) {
perror("calling bind");
sock_kerb5 = -1;
}
}
/* Bail out if we can't bind with any port */
if ((sock_kerb < 0) && (sock_kerb5 < 0))
return -1;
#if MAIN
/* this has already been done */
LWP_InitializeProcessSupport(LWP_NORMAL_PRIORITY, &junk);
IOMGR_Initialize();
#endif
LWP_CreateProcess(SocketListener, /*stacksize */ 16000,
LWP_NORMAL_PRIORITY, (void *)0, "Socket Listener",
&slPid);
/* just to close the log every five minutes */
LWP_CreateProcess(FiveMinuteCheckLWP, 24 * 1024, LWP_MAX_PRIORITY - 2,
(void *)&fiveminutes, "FiveMinuteChecks", &checkPid);
#if MAIN
initialize_ka_error_table();
initialize_rxk_error_table();
while (1) /* don't just stand there, run it */
IOMGR_Sleep(60);
#else
return 0;
#endif
}
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 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;
int sleeptime = 0;
struct AFSCBFids theFids;
struct AFSCBs theCBs;
blksize = 8 * 1024;
while ((ch = getopt(argc, argv, "iouUb:s:")) != -1) {
switch (ch) {
case 'b':
blksize = atoi(optarg);
break;
case 'i':
slcl = 1;
break;
case 'o':
dlcl = 1;
break;
case 's':
sleeptime = atoi(optarg);
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] [-s time] [-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, " -s Set the seconds to sleep before reading/writing data\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, NULL);
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;
}
if (sleeptime > 0) {
#ifdef AFS_PTHREAD_ENV
sleep(sleeptime);
#else
IOMGR_Sleep(sleeptime);
#endif
/* only sleep once */
sleeptime = 0;
}
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)
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)
printf("Error returned from store: %s\n", afs_error_message(storecode));
Finish:
gettimeofday(&finish, NULL);
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);
}
