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;
}
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);
}
long
rxkst_StartClient(struct clientParms *parms)
{
long code;
long host;
long scIndex;
struct rx_securityClass *sc;
whoami = parms->whoami; /* set this global variable */
host = GetServer(parms->server);
if (parms->authentication >= 0) {
long kvno = 0;
char ticket[MAXKTCTICKETLEN];
int ticketLen;
struct ktc_encryptionKey Ksession;
if (parms->useTokens)
code =
GetToken(&kvno, &Ksession, &ticketLen, ticket, parms->cell);
else
code =
GetTicket(&kvno, &Ksession, &ticketLen, ticket, parms->cell);
if (code)
return code;
/* next, we have ticket, kvno and session key, authenticate the conn */
sc = (struct rx_securityClass *)
rxkad_NewClientSecurityObject(parms->authentication, &Ksession,
kvno, ticketLen, ticket);
assert(sc);
scIndex = RX_SECIDX_KAD;
} else {
/* unauthenticated connection */
sc = rxnull_NewClientSecurityObject();
assert(sc);
scIndex = RX_SECIDX_NULL;
}
code = 0;
if (!code && parms->callTest) {
code = RunCallTest(parms, host, sc, scIndex);
}
if (!code && parms->hijackTest) {
code = RunHijackTest(parms, host, sc, scIndex);
}
if (!code
&& (parms->printTiming || parms->fastCalls || parms->slowCalls
|| parms->copiousCalls)) {
struct rx_connection *conn;
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID,
sc, scIndex);
if (conn) {
code = RepeatLoadTest(parms, conn);
rx_DestroyConnection(conn);
} else
code = RXKST_NEWCONNFAILED;
}
if (!code && parms->stopServer) {
struct rx_connection *conn;
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID,
sc, scIndex);
if (conn) {
code = RXKST_Kill(conn);
if (code) {
afs_com_err(whoami, code, "trying to stop server");
}
rx_DestroyConnection(conn);
} else
code = RXKST_NEWCONNFAILED;
}
if (parms->printStats) {
rx_PrintStats(stdout);
#if 0
/* use rxdebug style iteration here */
rx_PrintPeerStats(stdout, rx_PeerOf(conn));
#endif
}
rxs_Release(sc);
rx_Finalize();
if (code) {
afs_com_err(parms->whoami, code, "test fails");
exit(13);
} else {
printf("Test Okay\n");
if (!parms->noExit)
exit(0);
}
return 0;
}
