perftcpdns.c revision 8fcf2413e99597b6690b6a352aa12842f9be27e5
/*
* Copyright (C) 2013, 2014 Internet Systems Consortium, Inc. ("ISC")
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
* REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* TCP DNS perf tool
*
* main parameters are -r<rate> and <server>
* standard options are 4|6 (IPv4|IPv6), rate computations, terminaisons,
* EDNS0, NOERROR|NXDOMAIN, template (for your own query), diags,
* alternate server port and UDP version.
*
* To help to crush kernels (unfortunately both client and server :-)
* this version of the tool is multi-threaded:
* - the master thread inits, monitors the activity each millisecond,
* and report results when finished
* - the connecting thread computes the date of the next connection,
* creates a socket, makes it non blocking, binds it if wanted,
* connects it and pushes it on the output epoll queue
* - the sending thread gets by epoll connected sockets, timeouts
* embryonic connections, sends queries and pushes sockets on
* the input epoll queue
* - the receiving thread gets by epoll sockets with a pending
* response, receives responses, timeouts unanswered queries,
* and recycles (by closing them) all sockets.
*
* Rate computation details:
* - the target rate is in query+response per second.
* - rating is done by the connecting thread.
* - of course the tool is always late so the target rate is never
* reached. BTW there is no attempt to internally adjust the
* effective rate to the target one: this must be by tuning
* the rate related parameters, first the -r<rate> itself.
* - at the beginning of the connecting thread iteration loop
* (second "loops" counter) the date of the due (aka next) connect()
* call is computed from the last one with 101% of the rate.
* - the due date is compared with the current date (aka now).
* - if the due is before, lateconn counter is incremented, else
* the thread sleeps for the difference,
* - the next step is to reget the current date, if it is still
* before the due date (e.g., because the sleep was interrupted)
* the first shortwait counter is incremented.
* - if it is after (common case) the number of connect calls is
* computed from the difference between now and due divided by rate,
* rounded to the next number,
* - this number of connect() calls is bounded by the -a<aggressiveness>
* parameter to avoid too many back to back new connection attempts.
* - the compconn counter is incremented, errors (other than EINPROGRESS
* from not blocking connect()) are printed. When an error is
* related to a local limit (e.g., EMFILE, EADDRNOTAVAIL or the
* internal ENOMEM) the locallimit counter is incremented.
*/
#ifdef __linux__
#define _GNU_SOURCE
#endif
#include <sys/types.h>
#include <sys/epoll.h>
#include <sys/prctl.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <netdb.h>
#include <pthread.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
/* DNS defines */
#define NS_TYPE_A 1
#define NS_TYPE_NS 2
#define NS_TYPE_CNAME 5
#define NS_TYPE_SOA 6
#define NS_TYPE_NULL 10
#define NS_TYPE_PTR 12
#define NS_TYPE_MX 15
#define NS_TYPE_TXT 16
#define NS_TYPE_AAAA 28
#define NS_TYPE_OPT 41
#define NS_TYPE_DS 43
#define NS_TYPE_RRSIG 46
#define NS_TYPE_NSEC 47
#define NS_TYPE_DNSKEY 48
#define NS_TYPE_NSEC3 50
#define NS_TYPE_NSEC3PARAM 51
#define NS_TYPE_TSIG 250
#define NS_TYPE_IXFR 251
#define NS_TYPE_AXFR 252
#define NS_TYPE_ANY 255
#define NS_CLASS_IN 1
#define NS_CLASS_ANY 255
#define NS_OFF_ID 0
#define NS_OFF_FLAGS 2
#define NS_OFF_QDCOUNT 4
#define NS_OFF_ANCOUNT 6
#define NS_OFF_NSCOUNT 8
#define NS_OFF_ARCOUNT 10
#define NS_OFF_QUESTION 12
#define NS_FLAG_QR 0x8000U
#define NS_FLAG_AA 0x0400U
#define NS_FLAG_TC 0x0200U
#define NS_FLAG_RD 0x0100U
#define NS_FLAG_RA 0x0080U
#define NS_FLAG_AD 0x0020U
#define NS_FLAG_CD 0x0010U
#define NS_XFLAG_DO 0x8000U
#define NS_OPCODE_MASK 0x7000U
#define NS_OPCODE_QUERY 0
#define NS_RCODE_MASK 0x000fU
#define NS_RCODE_NOERROR 0
#define NS_RCODE_FORMERR 1
#define NS_RCODE_SERVFAIL 2
#define NS_RCODE_NXDOMAIN 3
#define NS_RCODE_NOIMP 4
#define NS_RCODE_REFUSED 5
#define NS_RCODE_LAST 6
/* chaining macros */
#define ISC_INIT(head, headl) do { \
(head) = -1; \
(headl) = &(head); \
} while (0)
#define ISC_INSERT(head, headl, elm) do { \
(elm)->next = -1; \
(elm)->prev = (headl); \
*(headl) = (elm) - xlist; \
(headl) = &((elm)->next); \
} while (0)
#define ISC_REMOVE(headl, elm) do { \
if ((elm)->next != -1) \
xlist[(elm)->next].prev = (elm)->prev; \
else \
(headl) = (elm)->prev; \
*(elm)->prev = (elm)->next; \
} while (0)
/*
* Data structures
*/
/*
* exchange:
* - per exchange values:
* * order (for debugging)
* * id
* * random (for debugging)
* * time-stamps
*
* sent/rcvd chain, "next to be received" on entry cache.
*/
struct exchange { /* per exchange structure */
int sock; /* socket descriptor */
int next, *prev; /* chaining */
#define X_FREE 0
#define X_CONN 1
#define X_READY 2
#define X_SENT 3
int state; /* state */
uint16_t id; /* ID */
uint64_t order; /* number of this exchange */
struct timespec ts0, ts1, ts2, ts3; /* timespecs */
};
struct exchange *xlist; /* exchange list */
int xlast; /* number of exchanges */
int xconn, *xconnl; /* connecting list */
int xready, *xreadyl; /* connected list */
int xsent, *xsentl; /* sent list */
int xfree, *xfreel; /* free list */
int xused; /* next to be used list */
pthread_mutex_t mtxconn, mtxsent, mtxfree; /* mutexes */
uint64_t xccount; /* connected counters */
uint64_t xscount; /* sent counters */
uint64_t xrcount; /* received counters */
/*
* statictics counters and accumulators
*/
uint64_t recverr, tooshort, locallimit; /* error counters */
uint64_t loops[4], shortwait[3]; /* rate stats */
uint64_t lateconn, compconn; /* rate stats (cont) */
uint64_t badconn, collconn, badsent, collsent; /* rate stats (cont) */
uint64_t badid, notresp; /* bad response counters */
uint64_t rcodes[NS_RCODE_LAST + 1]; /* rcode counters */
double dmin = 999999999.; /* minimum delay */
double dmax = 0.; /* maximum delay */
double dsum = 0.; /* delay sum */
double dsumsq = 0.; /* square delay sum */
/*
* command line parameters
*/
int edns0; /* EDNS0 DO flag */
int ipversion = 0; /* IP version */
int rate; /* rate in connections per second */
int noreport; /* disable auto reporting */
int report; /* delay between two reports */
uint32_t range; /* randomization range */
uint32_t maxrandom; /* maximum random value */
int basecnt; /* base count */
char *base[2]; /* bases */
int gotnumreq = -1; /* numreq[0] was set */
int numreq[2]; /* number of exchanges */
int period; /* test period */
int gotlosttime = -1; /* losttime[0] was set */
double losttime[2] = {.5, 1.}; /* delay for a timeout */
int gotmaxloss = -1; /* max{p}loss[0] was set */
int maxloss[2]; /* maximum number of losses */
double maxploss[2] = {0., 0.}; /* maximum percentage */
char *localname; /* local address or interface */
int aggressiveness = 1; /* back to back connections */
int seeded; /* is a seed provided */
unsigned int seed; /* randomization seed */
char *templatefile; /* template file name */
int rndoffset = -1; /* template offset (random) */
char *diags; /* diagnostic selectors */
char *servername; /* server */
int ixann; /* ixann NXDOMAIN */
int udp; /* use UDP in place of TCP */
int minport, maxport, curport; /* port range */
/*
* global variables
*/
struct sockaddr_storage localaddr; /* local socket address */
struct sockaddr_storage serveraddr; /* server socket address */
in_port_t port = 53; /* server socket port */
int epoll_ifd, epoll_ofd; /* epoll file descriptors */
#ifndef EVENTS_CNT
#define EVENTS_CNT 16
#endif
struct epoll_event ievents[EVENTS_CNT]; /* polled input events */
struct epoll_event oevents[EVENTS_CNT]; /* polled output events */
int interrupted, fatal; /* to finish flags */
uint8_t obuf[4098], ibuf[4098]; /* I/O buffers */
char tbuf[4098]; /* template buffer */
struct timespec boot; /* the date of boot */
struct timespec last; /* the date of last connect */
struct timespec due; /* the date of next connect */
struct timespec dreport; /* the date of next reporting */
struct timespec finished; /* the date of finish */
/*
* template
*/
size_t length_query;
uint8_t template_query[4096];
size_t random_query;
/*
* threads
*/
pthread_t master, connector, sender, receiver;
/*
* initialize data structures handling exchanges
*/
void
inits(void)
{
int idx;
ISC_INIT(xconn, xconnl);
ISC_INIT(xready, xreadyl);
ISC_INIT(xsent, xsentl);
ISC_INIT(xfree, xfreel);
if ((pthread_mutex_init(&mtxconn, NULL) != 0) ||
(pthread_mutex_init(&mtxsent, NULL) != 0) ||
(pthread_mutex_init(&mtxfree, NULL) != 0)) {
fprintf(stderr, "pthread_mutex_init failed\n");
exit(1);
}
epoll_ifd = epoll_create(EVENTS_CNT);
if (epoll_ifd < 0) {
perror("epoll_create(input)");
exit(1);
}
epoll_ofd = epoll_create(EVENTS_CNT);
if (epoll_ofd < 0) {
perror("epoll_create(output)");
exit(1);
}
xlist = (struct exchange *) malloc(xlast * sizeof(struct exchange));
if (xlist == NULL) {
perror("malloc(exchanges)");
exit(1);
}
memset(xlist, 0, xlast * sizeof(struct exchange));
for (idx = 0; idx < xlast; idx++)
xlist[idx].sock = xlist[idx].next = -1;
}
/*
* build a TCP DNS QUERY
*/
void
build_template_query(void)
{
uint8_t *p = template_query;
uint16_t v;
/* flags */
p += NS_OFF_FLAGS;
v = NS_FLAG_RD;
*p++ = v >> 8;
*p++ = v & 0xff;
/* qdcount */
v = 1;
*p++ = v >> 8;
*p++ = v & 0xff;
/* ancount */
v = 0;
*p++ = v >> 8;
*p++ = v & 0xff;
/* nscount */
v = 0;
*p++ = v >> 8;
*p++ = v & 0xff;
/* arcount */
v = edns0;
*p++ = v >> 8;
*p++ = v & 0xff;
/* icann.link (or ixann.link) */
*p++ = 5;
*p++ = 'i';
if (ixann == 0)
*p++ = 'c';
else
*p++ = 'x';
*p++ = 'a';
*p++ = 'n';
*p++ = 'n';
*p++ = 4;
*p++ = 'l';
*p++ = 'i';
*p++ = 'n';
*p++ = 'k';
*p++ = 0;
/* type A/AAAA */
if (ipversion == 4)
v = NS_TYPE_A;
else
v = NS_TYPE_AAAA;
*p++ = v >> 8;
*p++ = v & 0xff;
/* class IN */
v = NS_CLASS_IN;
*p++ = v >> 8;
*p++ = v & 0xff;
/* EDNS0 OPT with DO */
if (edns0) {
/* root name */
*p++ = 0;
/* type OPT */
v = NS_TYPE_OPT;
*p++ = v >> 8;
*p++ = v & 0xff;
/* class UDP length */
v = 4096;
*p++ = v >> 8;
*p++ = v & 0xff;
/* extended rcode 0 */
*p++ = 0;
/* version 0 */
*p++ = 0;
/* extended flags DO */
v = NS_XFLAG_DO;
*p++ = v >> 8;
*p++ = v & 0xff;
/* rdlength */
v = 0;
*p++ = v >> 8;
*p++ = v & 0xff;
}
/* length */
length_query = p - template_query;
}
/*
* get a TCP DNS client QUERY template
* from the file given in the command line (-T<template-file>)
* and rnd offset (-O<random-offset>)
*/
void
get_template_query(void)
{
uint8_t *p = template_query;
int fd, cc, i, j;
fd = open(templatefile, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "open(%s): %s\n",
templatefile, strerror(errno));
exit(2);
}
cc = read(fd, tbuf, sizeof(tbuf));
(void) close(fd);
if (cc < 0) {
fprintf(stderr, "read(%s): %s\n",
templatefile, strerror(errno));
exit(1);
}
if (cc < NS_OFF_QUESTION + 6) {
fprintf(stderr,"file '%s' too small\n", templatefile);
exit(2);
}
if (cc > 4096) {
fprintf(stderr,"file '%s' too large\n", templatefile);
exit(2);
}
j = 0;
for (i = 0; i < cc; i++) {
if (isspace((int) tbuf[i]))
continue;
if (!isxdigit((int) tbuf[i])) {
fprintf(stderr,
"illegal char[%d]='%c' in file '%s'\n",
i, (int) tbuf[i], templatefile);
exit(2);
}
tbuf[j] = tbuf[i];
j++;
}
cc = j;
if ((cc & 1) != 0) {
fprintf(stderr,
"odd number of hexadecimal digits in file '%s'\n",
templatefile);
exit(2);
}
length_query = cc >> 1;
for (i = 0; i < cc; i += 2)
(void) sscanf(tbuf + i, "%02hhx", &p[i >> 1]);
if (rndoffset >= 0)
random_query = (size_t) rndoffset;
if (random_query > length_query) {
fprintf(stderr,
"random (at %zu) outside the template (length %zu)?\n",
random_query, length_query);
exit(2);
}
}
#if 0
/*
* randomize the value of the given field:
* - offset of the field
* - random seed (used as it when suitable)
* - returns the random value which was used
*/
uint32_t
randomize(size_t offset, uint32_t r)
{
uint32_t v;
if (range == 0)
return 0;
if (range == UINT32_MAX)
return r;
if (maxrandom != 0)
while (r >= maxrandom)
r = (uint32_t) random();
r %= range + 1;
v = r;
v += obuf[offset];
obuf[offset] = v;
if (v < 256)
return r;
v >>= 8;
v += obuf[offset - 1];
obuf[offset - 1] = v;
if (v < 256)
return r;
v >>= 8;
v += obuf[offset - 2];
obuf[offset - 2] = v;
if (v < 256)
return r;
v >>= 8;
v += obuf[offset - 3];
obuf[offset - 3] = v;
return r;
}
#endif
/*
* flush/timeout connect
*/
void
flushconnect(void)
{
struct exchange *x;
struct timespec now;
int idx = xconn;
int cnt = 10;
double waited;
if (clock_gettime(CLOCK_REALTIME, &now) < 0) {
perror("clock_gettime(flushconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
while (--cnt >= 0) {
if (idx < 0)
return;
x = xlist + idx;
idx = x->next;
if (x->state != X_CONN)
abort();
/* check for a timed-out connection */
waited = now.tv_sec - x->ts0.tv_sec;
waited += (now.tv_nsec - x->ts0.tv_nsec) / 1e9;
if (waited < losttime[0])
return;
/* garbage collect timed-out connections */
if (pthread_mutex_lock(&mtxconn) != 0) {
fprintf(stderr, "pthread_mutex_lock(flushconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
ISC_REMOVE(xconnl, x);
if (pthread_mutex_unlock(&mtxconn) != 0) {
fprintf(stderr, "pthread_mutex_unlock(flushconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
(void) close(x->sock);
x->sock = -1;
collconn++;
if (pthread_mutex_lock(&mtxfree) != 0) {
fprintf(stderr, "pthread_mutex_lock(flushconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
x->state = X_FREE;
ISC_INSERT(xfree, xfreel, x);
if (pthread_mutex_unlock(&mtxfree) != 0) {
fprintf(stderr, "pthread_mutex_unlock(flushconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
}
}
/*
* poll connected
*/
void
pollconnect(int topoll)
{
struct exchange *x;
int evn, idx, err;
socklen_t len = sizeof(int);
for (evn = 0; evn < topoll; evn++) {
idx = oevents[evn].data.fd;
x = xlist + idx;
if (x->state != X_CONN)
continue;
if (oevents[evn].events == 0)
continue;
if (pthread_mutex_lock(&mtxconn) != 0) {
fprintf(stderr, "pthread_mutex_lock(pollconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
ISC_REMOVE(xconnl, x);
if (pthread_mutex_unlock(&mtxconn) != 0) {
fprintf(stderr, "pthread_mutex_unlock(pollconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
oevents[evn].events = 0;
if ((getsockopt(x->sock, SOL_SOCKET, SO_ERROR,
&err, &len) < 0) ||
(err != 0)) {
(void) close(x->sock);
x->sock = -1;
badconn++;
if (pthread_mutex_lock(&mtxfree) != 0) {
fprintf(stderr,
"pthread_mutex_lock(pollconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
x->state = X_FREE;
ISC_INSERT(xfree, xfreel, x);
if (pthread_mutex_unlock(&mtxfree) != 0) {
fprintf(stderr,
"pthread_mutex_unlock(pollconnect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
continue;
}
x->state = X_READY;
ISC_INSERT(xready, xreadyl, x);
}
}
/*
* send the TCP DNS QUERY
*/
int
sendquery(struct exchange *x)
{
ssize_t ret;
size_t off;
if (udp)
off = 0;
else {
off = 2;
/* message length */
obuf[0] = length_query >> 8;
obuf[1]= length_query & 0xff;
}
/* message from template */
memcpy(obuf + off, template_query, length_query);
/* ID */
memcpy(obuf + off + NS_OFF_ID, &x->id, 2);
#if 0
/* random */
if (random_query > 0)
x->rnd = randomize(random_query + off, x->rnd);
#endif
/* timestamp */
errno = 0;
ret = clock_gettime(CLOCK_REALTIME, &x->ts2);
if (ret < 0) {
perror("clock_gettime(send)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -errno;
}
ret = send(x->sock, obuf, length_query + off, 0);
if ((size_t) ret == length_query + off)
return 0;
return -errno;
}
/*
* poll ready and send
*/
void
pollsend(void)
{
struct exchange *x;
int idx = xready;
struct epoll_event ev;
memset(&ev, 0, sizeof(ev));
ev.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
for (;;) {
if (idx < 0)
return;
x = xlist + idx;
ev.data.fd = idx;
idx = x->next;
ISC_REMOVE(xreadyl, x);
if (sendquery(x) < 0) {
(void) close(x->sock);
x->sock = -1;
badsent++;
if (pthread_mutex_lock(&mtxfree) != 0) {
fprintf(stderr,
"pthread_mutex_lock(pollsend)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
x->state = X_FREE;
ISC_INSERT(xfree, xfreel, x);
if (pthread_mutex_unlock(&mtxfree) != 0) {
fprintf(stderr,
"pthread_mutex_unlock(pollsend)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
continue;
}
xscount++;
if (pthread_mutex_lock(&mtxsent) != 0) {
fprintf(stderr, "pthread_mutex_lock(pollsend)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
x->state = X_SENT;
ISC_INSERT(xsent, xsentl, x);
if (pthread_mutex_unlock(&mtxsent) != 0) {
fprintf(stderr, "pthread_mutex_unlock(pollsend)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
if (epoll_ctl(epoll_ifd, EPOLL_CTL_ADD, x->sock, &ev) < 0) {
perror("epoll_ctl(add input)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
}
}
/*
* receive a TCP DNS RESPONSE
*/
void
receiveresp(struct exchange *x)
{
struct timespec now;
ssize_t cc;
size_t off;
uint16_t v;
double delta;
cc = recv(x->sock, ibuf, sizeof(ibuf), 0);
if (cc < 0) {
if ((errno == EAGAIN) ||
(errno == EWOULDBLOCK) ||
(errno == EINTR) ||
(errno == ECONNRESET)) {
recverr++;
return;
}
perror("recv");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
if (udp)
off = 0;
else
off = 2;
/* enforce a reasonable length */
if ((size_t) cc < length_query + off) {
tooshort++;
return;
}
/* must match the ID */
if (memcmp(ibuf + off + NS_OFF_ID, &x->id, 2) != 0) {
badid++;
return;
}
/* must be a response */
memcpy(&v, ibuf + off + NS_OFF_FLAGS, 2);
v = ntohs(v);
if ((v & NS_FLAG_QR) == 0) {
notresp++;
return;
}
if (clock_gettime(CLOCK_REALTIME, &now) < 0) {
perror("clock_gettime(receive)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
/* got it: update stats */
xrcount++;
x->ts3 = now;
delta = x->ts3.tv_sec - x->ts2.tv_sec;
delta += (x->ts3.tv_nsec - x->ts2.tv_nsec) / 1e9;
if (delta < dmin)
dmin = delta;
if (delta > dmax)
dmax = delta;
dsum += delta;
dsumsq += delta * delta;
v &= NS_RCODE_MASK;
if (v >= NS_RCODE_LAST)
v = NS_RCODE_LAST;
rcodes[v] += 1;
}
/*
* flush/timeout receive
*/
void
flushrecv(void)
{
struct exchange *x;
struct timespec now;
int idx = xsent;
int cnt = 5;
double waited;
if (clock_gettime(CLOCK_REALTIME, &now) < 0) {
perror("clock_gettime(receive)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
while (--cnt >= 0) {
if (idx < 0)
return;
x = xlist + idx;
idx = x->next;
if (x->state != X_SENT)
abort();
/* check for a timed-out exchange */
waited = now.tv_sec - x->ts2.tv_sec;
waited += (now.tv_nsec - x->ts2.tv_nsec) / 1e9;
if (waited < losttime[1])
return;
/* garbage collect timed-out exchange */
if (pthread_mutex_lock(&mtxsent) != 0) {
fprintf(stderr, "pthread_mutex_lock(flushrecv)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
ISC_REMOVE(xsentl, x);
if (pthread_mutex_unlock(&mtxsent) != 0) {
fprintf(stderr, "pthread_mutex_unlock(flushrecv)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
(void) close(x->sock);
x->sock = -1;
collsent++;
if (pthread_mutex_lock(&mtxfree) != 0) {
fprintf(stderr, "pthread_mutex_lock(flushrecv)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
x->state = X_FREE;
ISC_INSERT(xfree, xfreel, x);
if (pthread_mutex_unlock(&mtxfree) != 0) {
fprintf(stderr, "pthread_mutex_unlock(flushrecv)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
}
}
/*
* poll receive
*/
void
pollrecv(int topoll)
{
struct exchange *x;
int evn, idx;
for (evn = 0; evn < topoll; evn++) {
idx = ievents[evn].data.fd;
x = xlist + idx;
if (x->state != X_SENT)
continue;
if (ievents[evn].events == 0)
continue;
if (pthread_mutex_lock(&mtxsent) != 0) {
fprintf(stderr, "pthread_mutex_lock(pollrecv)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
ISC_REMOVE(xsentl, x);
if (pthread_mutex_unlock(&mtxsent) != 0) {
fprintf(stderr, "pthread_mutex_unlock(pollrecv)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
receiveresp(x);
ievents[evn].events = 0;
(void) close(x->sock);
x->sock = -1;
if (pthread_mutex_lock(&mtxfree) != 0) {
fprintf(stderr, "pthread_mutex_lock(pollrecv)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
x->state = X_FREE;
ISC_INSERT(xfree, xfreel, x);
if (pthread_mutex_unlock(&mtxfree) != 0) {
fprintf(stderr, "pthread_mutex_unlock(pollrecv)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return;
}
}
}
/*
* get the TCP DNS socket descriptor (IPv4)
*/
int
getsock4(void)
{
int sock;
int flags;
errno = 0;
if (udp)
sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
else
sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock < 0)
return -errno;
/* make the socket descriptor not blocking */
flags = fcntl(sock, F_GETFL, 0);
if (flags == -1) {
(void) close(sock);
return -errno;
}
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
(void) close(sock);
return -errno;
}
/* bind if wanted */
if (localname != NULL) {
if (curport) {
struct sockaddr_in *l4;
l4 = (struct sockaddr_in *) &localaddr;
l4->sin_port = htons((uint16_t) curport);
curport++;
if (curport > maxport)
curport = minport;
}
if (bind(sock,
(struct sockaddr *) &localaddr,
sizeof(struct sockaddr_in)) < 0) {
(void) close(sock);
return -errno;
}
}
/* connect */
if (connect(sock,
(struct sockaddr *) &serveraddr,
sizeof(struct sockaddr_in)) < 0) {
if (errno != EINPROGRESS) {
(void) close(sock);
return -errno;
}
}
return sock;
}
/*
* connect the TCP DNS QUERY (IPv4)
*/
int
connect4(void)
{
struct exchange *x;
int ret;
int idx;
struct epoll_event ev;
ret = clock_gettime(CLOCK_REALTIME, &last);
if (ret < 0) {
perror("clock_gettime(connect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -errno;
}
if (xfree >= 0) {
idx = xfree;
x = xlist + idx;
ret = pthread_mutex_lock(&mtxfree);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_lock(connect4)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
ISC_REMOVE(xfreel, x);
ret = pthread_mutex_unlock(&mtxfree);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_unlock(connect4)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
} else if (xused < xlast) {
idx = xused;
x = xlist + idx;
xused++;
} else
return -ENOMEM;
if ((x->state != X_FREE) || (x->sock != -1))
abort();
memset(x, 0, sizeof(*x));
memset(&ev, 0, sizeof(ev));
x->next = -1;
x->prev = NULL;
x->ts0 = last;
x->sock = getsock4();
if (x->sock < 0) {
int result = x->sock;
x->sock = -1;
ret = pthread_mutex_lock(&mtxfree);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_lock(connect4)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
ISC_INSERT(xfree, xfreel, x);
ret = pthread_mutex_unlock(&mtxfree);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_unlock(connect4)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
return result;
}
ret = pthread_mutex_lock(&mtxconn);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_lock(connect4)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
x->state = X_CONN;
ISC_INSERT(xconn, xconnl, x);
ret = pthread_mutex_unlock(&mtxconn);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_unlock(connect4)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
ev.events = EPOLLOUT | EPOLLET | EPOLLONESHOT;
ev.data.fd = idx;
if (epoll_ctl(epoll_ofd, EPOLL_CTL_ADD, x->sock, &ev) < 0) {
perror("epoll_ctl(add output)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -errno;
}
x->order = xccount++;
x->id = (uint16_t) random();
#if 0
if (random_query > 0)
x->rnd = (uint32_t) random();
#endif
return idx;
}
/*
* get the TCP DNS socket descriptor (IPv6)
*/
int
getsock6(void)
{
int sock;
int flags;
errno = 0;
if (udp)
sock = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
else
sock = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
if (sock < 0)
return -errno;
/* make the socket descriptor not blocking */
flags = fcntl(sock, F_GETFL, 0);
if (flags == -1) {
(void) close(sock);
return -errno;
}
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
(void) close(sock);
return -errno;
}
/* bind if wanted */
if (localname != NULL) {
if (curport) {
struct sockaddr_in6 *l6;
l6 = (struct sockaddr_in6 *) &localaddr;
l6->sin6_port = htons((uint16_t) curport);
curport++;
if (curport > maxport)
curport = minport;
}
if (bind(sock,
(struct sockaddr *) &localaddr,
sizeof(struct sockaddr_in6)) < 0) {
(void) close(sock);
return -errno;
}
}
/* connect */
if (connect(sock,
(struct sockaddr *) &serveraddr,
sizeof(struct sockaddr_in6)) < 0) {
if (errno != EINPROGRESS) {
(void) close(sock);
return -errno;
}
}
return sock;
}
/*
* connect the TCP DNS QUERY (IPv6)
*/
int
connect6(void)
{
struct exchange *x;
int ret;
int idx;
struct epoll_event ev;
ret = clock_gettime(CLOCK_REALTIME, &last);
if (ret < 0) {
perror("clock_gettime(connect)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -errno;
}
if (xfree >= 0) {
idx = xfree;
x = xlist + idx;
ret = pthread_mutex_lock(&mtxfree);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_lock(connect6)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
ISC_REMOVE(xfreel, x);
ret = pthread_mutex_unlock(&mtxfree);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_unlock(connect6)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
} else if (xused < xlast) {
idx = xused;
x = xlist + idx;
xused++;
} else
return -ENOMEM;
memset(x, 0, sizeof(*x));
memset(&ev, 0, sizeof(ev));
x->next = -1;
x->prev = NULL;
x->ts0 = last;
x->sock = getsock6();
if (x->sock < 0) {
int result = x->sock;
x->sock = -1;
ret = pthread_mutex_lock(&mtxfree);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_lock(connect6)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
ISC_INSERT(xfree, xfreel, x);
ret = pthread_mutex_unlock(&mtxfree);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_unlock(connect6)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
return result;
}
ret = pthread_mutex_lock(&mtxconn);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_lock(connect6)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
x->state = X_CONN;
ISC_INSERT(xconn, xconnl, x);
ret = pthread_mutex_unlock(&mtxconn);
if (ret != 0) {
fprintf(stderr, "pthread_mutex_unlock(connect6)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -ret;
}
ev.events = EPOLLOUT | EPOLLET | EPOLLONESHOT;
ev.data.fd = idx;
if (epoll_ctl(epoll_ofd, EPOLL_CTL_ADD, x->sock, &ev) < 0) {
perror("epoll_ctl(add output)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
return -errno;
}
x->order = xccount++;
x->id = (uint16_t) random();
#if 0
if (random_query > 0)
x->rnd = (uint32_t) random();
#endif
return idx;
}
/*
* connector working routine
*/
void *
connecting(void *dummy)
{
struct timespec now, ts;
int ret;
int i;
char name[16];
dummy = dummy;
/* set conn-name */
memset(name, 0, sizeof(name));
ret = prctl(PR_GET_NAME, name, 0, 0, 0);
if (ret < 0)
perror("prctl(PR_GET_NAME)");
else {
memmove(name + 5, name, 11);
memcpy(name, "conn-", 5);
ret = prctl(PR_SET_NAME, name, 0, 0, 0);
if (ret < 0)
perror("prctl(PR_SET_NAME");
}
for (;;) {
if (fatal)
break;
loops[1]++;
/* compute the delay for the next connection */
if (clock_gettime(CLOCK_REALTIME, &now) < 0) {
perror("clock_gettime(connecting)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
break;
}
due = last;
if (rate == 1)
due.tv_sec += 1;
else
due.tv_nsec += 1010000000 / rate;
while (due.tv_nsec >= 1000000000) {
due.tv_sec += 1;
due.tv_nsec -= 1000000000;
}
ts = due;
ts.tv_sec -= now.tv_sec;
ts.tv_nsec -= now.tv_nsec;
while (ts.tv_nsec < 0) {
ts.tv_sec -= 1;
ts.tv_nsec += 1000000000;
}
/* the connection was already due? */
if (ts.tv_sec < 0) {
ts.tv_sec = ts.tv_nsec = 0;
lateconn++;
} else {
/* wait until */
ret = clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL);
if (ret != 0) {
if (ret == EINTR)
continue;
fprintf(stderr, "clock_nanosleep: %s\n",
strerror(ret));
fatal = 1;
(void) pthread_kill(master, SIGTERM);
break;
}
}
/* compute how many connections to open */
if (clock_gettime(CLOCK_REALTIME, &now) < 0) {
perror("clock_gettime(connecting)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
break;
}
if ((now.tv_sec > due.tv_sec) ||
((now.tv_sec == due.tv_sec) &&
(now.tv_nsec >= due.tv_nsec))) {
double toconnect;
toconnect = (now.tv_nsec - due.tv_nsec) / 1e9;
toconnect += now.tv_sec - due.tv_sec;
toconnect *= rate;
toconnect++;
if (toconnect > (double) aggressiveness)
i = aggressiveness;
else
i = (int) toconnect;
compconn += i;
/* open connections */
while (i-- > 0) {
if (ipversion == 4)
ret = connect4();
else
ret = connect6();
if (ret < 0) {
if ((ret == -EAGAIN) ||
(ret == -EWOULDBLOCK) ||
(ret == -ENOBUFS) ||
(ret == -ENFILE) ||
(ret == -EMFILE) ||
(ret == -EADDRNOTAVAIL) ||
(ret == -ENOMEM))
locallimit++;
fprintf(stderr,
"connect: %s\n",
strerror(-ret));
break;
}
}
} else
/* there was no connection to open */
shortwait[0]++;
}
return NULL;
}
/*
* sender working routine
*/
void *
sending(void *dummy)
{
int ret;
int nfds;
char name[16];
dummy = dummy;
/* set send-name */
memset(name, 0, sizeof(name));
ret = prctl(PR_GET_NAME, name, 0, 0, 0);
if (ret < 0)
perror("prctl(PR_GET_NAME)");
else {
memmove(name + 5, name, 11);
memcpy(name, "send-", 5);
ret = prctl(PR_SET_NAME, name, 0, 0, 0);
if (ret < 0)
perror("prctl(PR_SET_NAME");
}
for (;;) {
if (fatal)
break;
loops[2]++;
/* epoll_wait() */
memset(oevents, 0, sizeof(oevents));
nfds = epoll_wait(epoll_ofd, oevents, EVENTS_CNT, 1);
if (nfds < 0) {
if (errno == EINTR)
continue;
perror("epoll_wait(output)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
break;
}
/* connection(s) to finish */
if (nfds == 0)
shortwait[1]++;
else
pollconnect(nfds);
if (fatal)
break;
flushconnect();
if (fatal)
break;
/* packet(s) to send */
pollsend();
if (fatal)
break;
}
return NULL;
}
/*
* receiver working routine
*/
void *
receiving(void *dummy)
{
int ret;
int nfds;
char name[16];
dummy = dummy;
/* set recv-name */
memset(name, 0, sizeof(name));
ret = prctl(PR_GET_NAME, name, 0, 0, 0);
if (ret < 0)
perror("prctl(PR_GET_NAME)");
else {
memmove(name + 5, name, 11);
memcpy(name, "recv-", 5);
ret = prctl(PR_SET_NAME, name, 0, 0, 0);
if (ret < 0)
perror("prctl(PR_SET_NAME");
}
for (;;) {
if (fatal)
break;
loops[3]++;
/* epoll_wait() */
memset(ievents, 0, sizeof(ievents));
nfds = epoll_wait(epoll_ifd, ievents, EVENTS_CNT, 1);
if (nfds < 0) {
if (errno == EINTR)
continue;
perror("epoll_wait(input)");
fatal = 1;
(void) pthread_kill(master, SIGTERM);
break;
}
/* packet(s) to receive */
if (nfds == 0)
shortwait[2]++;
else
pollrecv(nfds);
if (fatal)
break;
flushrecv();
if (fatal)
break;
}
return NULL;
}
/*
* get the server socket address from the command line:
* - flags: inherited from main, 0 or AI_NUMERICHOST (for literals)
*/
void
getserveraddr(const int flags)
{
struct addrinfo hints, *res;
int ret;
memset(&hints, 0, sizeof(hints));
if (ipversion == 4)
hints.ai_family = AF_INET;
else
hints.ai_family = AF_INET6;
if (udp) {
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
} else {
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
}
hints.ai_flags = AI_ADDRCONFIG | flags;
ret = getaddrinfo(servername, NULL, &hints, &res);
if (ret != 0) {
fprintf(stderr, "bad server=%s: %s\n",
servername, gai_strerror(ret));
exit(2);
}
if (res->ai_next != NULL) {
fprintf(stderr, "ambiguous server=%s\n", servername);
exit(2);
}
memcpy(&serveraddr, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
if (ipversion == 4)
((struct sockaddr_in *)&serveraddr)->sin_port = htons(port);
else
((struct sockaddr_in6 *)&serveraddr)->sin6_port = htons(port);
}
/*
* get the local socket address from the command line
*/
void
getlocaladdr(void)
{
struct addrinfo hints, *res;
int ret;
memset(&hints, 0, sizeof(hints));
if (ipversion == 4)
hints.ai_family = AF_INET;
else
hints.ai_family = AF_INET6;
if (udp) {
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
} else {
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
}
hints.ai_flags = AI_ADDRCONFIG;
ret = getaddrinfo(localname, NULL, &hints, &res);
if (ret != 0) {
fprintf(stderr,
"bad -l<local-addr=%s>: %s\n",
localname,
gai_strerror(ret));
exit(2);
}
/* refuse multiple addresses */
if (res->ai_next != NULL) {
fprintf(stderr,
"ambiguous -l<local-addr=%s>\n",
localname);
exit(2);
}
memcpy(&localaddr, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
}
/*
* intermediate reporting
* (note: an in-transit packet can be reported as lost)
*/
void
reporting(void)
{
dreport.tv_sec += report;
if (xccount != 0) {
printf("connect: %llu, sent: %llu, received: %llu "
"(embryonics: %lld, drops: %lld)",
(unsigned long long) xccount,
(unsigned long long) xscount,
(unsigned long long) xrcount,
(long long) (xccount - xscount),
(long long) (xscount - xrcount));
if (xrcount != 0) {
double avg;
avg = dsum / xrcount;
printf(" average: %.3f ms", avg * 1e3);
}
}
printf("\n");
}
/*
* SIGCHLD handler
*/
void
reapchild(int sig)
{
int status;
sig = sig;
while (wait3(&status, WNOHANG, NULL) > 0)
/* continue */;
}
/*
* SIGINT handler
*/
void
interrupt(int sig)
{
sig = sig;
interrupted = 1;
}
/*
* SIGTERM handler
*/
void
terminate(int sig)
{
sig = sig;
fatal = 1;
}
/*
* '-v' handler
*/
void
version(void)
{
fprintf(stderr, "version 0.01\n");
}
/*
* usage (from the wiki)
*/
void
usage(void)
{
fprintf(stderr, "%s",
"perftcpdns [-huvX0] [-4|-6] [-r<rate>] [-t<report>] [-p<test-period>]\n"
" [-n<num-request>]* [-d<lost-time>]* [-D<max-loss>]* [-T<template-file>]\n"
" [-l<local-addr>] [-L<local-port>]* [-a<aggressiveness>] [-s<seed>]\n"
" [-M<memory>] [-x<diagnostic-selector>] [-P<port>] server\n"
"\f\n"
"The server argument is the name/address of the DNS server to contact.\n"
"\n"
"Options:\n"
"-0: Add EDNS0 option with DO flag.\n"
"-4: TCP/IPv4 operation (default). This is incompatible with the -6 option.\n"
"-6: TCP/IPv6 operation. This is incompatible with the -4 option.\n"
"-a<aggressiveness>: When the target sending rate is not yet reached,\n"
" control how many connections are initiated before the next pause.\n"
"-d<lost-time>: Specify the time after which a connection or a query is\n"
" treated as having been lost. The value is given in seconds and\n"
" may contain a fractional component. The default is 1 second.\n"
"-h: Print this help.\n"
"-l<local-addr>: Specify the local hostname/address to use when\n"
" communicating with the server.\n"
"-L<local-port>: Specify the (minimal and maximal) local port number\n"
"-M<memory>: Size of the tables (default 60000)\n"
"-P<port>: Specify an alternate (i.e., not 53) port\n"
"-r<rate>: Initiate <rate> TCP DNS connections per second. A periodic\n"
" report is generated showing the number of exchanges which were not\n"
" completed, as well as the average response latency. The program\n"
" continues until interrupted, at which point a final report is\n"
" generated.\n"
"-s<seed>: Specify the seed for randomization, making it repeatable.\n"
"-t<report>: Delay in seconds between two periodic reports.\n"
"-T<template-file>: The name of a file containing the template to use\n"
" as a stream of hexadecimal digits.\n"
"-u: Use UDP in place of TCP.\n"
"-v: Report the version number of this program.\n"
"-X: change default template to get NXDOMAIN responses.\n"
"-x<diagnostic-selector>: Include extended diagnostics in the output.\n"
" <diagnostic-selector> is a string of single-keywords specifying\n"
" the operations for which verbose output is desired. The selector\n"
" keyletters are:\n"
" * 'a': print the decoded command line arguments\n"
" * 'e': print the exit reason\n"
" * 'i': print rate processing details\n"
" * 'T': when finished, print templates\n"
"\n"
"Stopping conditions:\n"
"-D<max-loss>: Abort the test if more than <max-loss> connections or\n"
" queries have been lost. If <max-loss> includes the suffix '%', it\n"
" specifies a maximum percentage of losses before stopping.\n"
" In this case, testing of the threshold begins after 10\n"
" connections/responses have been expected to be accepted/received.\n"
"-n<num-request>: Initiate <num-request> transactions. No report is\n"
" generated until all transactions have been initiated/waited-for,\n"
" after which a report is generated and the program terminates.\n"
"-p<test-period>: Send requests for the given test period, which is\n"
" specified in the same manner as -d. This can be used as an\n"
" alternative to -n, or both options can be given, in which case the\n"
" testing is completed when either limit is reached.\n"
"\n"
"Errors:\n"
"- locallimit: reached to local system limits when sending a message.\n"
"- badconn: connection failed (from getsockopt(SO_ERROR))\n"
"- collconn: connect() timed out\n"
"- badsent: send() failed\n"
"- callsent: timed out waiting from a response\n"
"- recverr: recv() system call failed\n"
"- tooshort: received a too short message\n"
"- badid: the id mismatches between the query and the response\n"
"- notresp: doesn't receive a response\n"
"Rate stats:\n"
"- loops: number of thread loop iterations\n"
"- shortwait: no direct activity in a thread iteration\n"
"- compconn: computed number of connect() calls\n"
"- lateconn: connect() already dued when computing delay to the next one\n"
"\n"
"Exit status:\n"
"The exit status is:\n"
"0 on complete success.\n"
"1 for a general error.\n"
"2 if an error is found in the command line arguments.\n"
"3 if there are no general failures in operation, but one or more\n"
" exchanges are not successfully completed.\n");
}
/*
* main function / entry point
*/
int
main(const int argc, char * const argv[])
{
int opt, flags = 0, ret, i;
long long r;
char *pc;
double d;
extern char *optarg;
extern int optind;
#define OPTIONS "hv46u0XM:r:t:R:b:n:p:d:D:l:L:a:s:T:O:x:P:"
/* decode options */
while ((opt = getopt(argc, argv, OPTIONS)) != -1)
switch (opt) {
case 'h':
usage();
exit(0);
case 'u':
udp = 1;
break;
case 'v':
version();
exit(0);
case '0':
edns0 = 1;
break;
case '4':
if (ipversion == 6) {
fprintf(stderr, "IP version already set to 6\n");
usage();
exit(2);
}
ipversion = 4;
break;
case '6':
if (ipversion == 4) {
fprintf(stderr, "IP version already set to 4\n");
usage();
exit(2);
}
ipversion = 6;
break;
case 'X':
ixann = 1;
break;
case 'M':
xlast = atoi(optarg);
if (xlast <= 1000) {
fprintf(stderr, "memory must be greater than 1000\n");
usage();
exit(2);
}
break;
case 'r':
rate = atoi(optarg);
if (rate <= 0) {
fprintf(stderr, "rate must be a positive integer\n");
usage();
exit(2);
}
break;
case 't':
report = atoi(optarg);
if (report <= 0) {
fprintf(stderr, "report must be a positive integer\n");
usage();
exit(2);
}
break;
case 'R':
r = atoll(optarg);
if (r < 0) {
fprintf(stderr,
"range must not be a negative integer\n");
usage();
exit(2);
}
range = (uint32_t) r;
if ((range != 0) && (range != UINT32_MAX)) {
uint32_t s = range + 1;
uint64_t b = UINT32_MAX + 1, m;
m = (b / s) * s;
if (m == b)
maxrandom = 0;
else
maxrandom = (uint32_t) m;
}
break;
case 'b':
if (basecnt > 1) {
fprintf(stderr, "too many bases\n");
usage();
exit(2);
}
base[basecnt] = optarg;
/* decodebase(); */
basecnt++;
break;
case 'n':
noreport = 1;
gotnumreq++;
if (gotnumreq > 1) {
fprintf(stderr, "too many num-request's\n");
usage();
exit(2);
}
numreq[gotnumreq] = atoi(optarg);
if ((numreq[gotnumreq] < 0) ||
((numreq[gotnumreq] == 0) && (gotnumreq == 1))) {
fprintf(stderr,
"num-request must be a positive integer\n");
usage();
exit(2);
}
break;
case 'p':
noreport = 1;
period = atoi(optarg);
if (period <= 0) {
fprintf(stderr,
"test-period must be a positive integer\n");
usage();
exit(2);
}
break;
case 'd':
gotlosttime++;
if (gotlosttime > 1) {
fprintf(stderr, "too many lost-time's\n");
usage();
exit(2);
}
d = atof(optarg);
if ((d < 0.) || ((d == 0.) && (gotlosttime == 1))) {
fprintf(stderr,
"lost-time must be a positive number\n");
usage();
exit(2);
}
if (d > 0.)
losttime[gotlosttime] = d;
break;
case 'D':
noreport = 1;
gotmaxloss++;
if (gotmaxloss > 1) {
fprintf(stderr, "too many max-loss's\n");
usage();
exit(2);
}
pc = strchr(optarg, '%');
if (pc != NULL) {
*pc = '\0';
maxploss[gotmaxloss] = atof(optarg);
if ((maxploss[gotmaxloss] < 0) ||
(maxploss[gotmaxloss] >= 100)) {
fprintf(stderr,
"invalid max-loss percentage\n");
usage();
exit(2);
}
} else {
maxloss[gotmaxloss] = atoi(optarg);
if ((maxloss[gotmaxloss] < 0) ||
((maxloss[gotmaxloss] == 0) &&
(gotmaxloss == 1))) {
fprintf(stderr,
"max-loss must be a "
"positive integer\n");
usage();
exit(2);
}
}
break;
case 'l':
localname = optarg;
break;
case 'L':
i = atoi(optarg);
if ((i <= 0) || (i >65535)) {
fprintf(stderr,
"local-port must be a small positive integer\n");
usage();
exit(2);
}
if (maxport != 0) {
fprintf(stderr, "too many local-port's\n");
usage();
exit(2);
}
if (curport == 0)
minport = curport = i;
else
maxport = i;
break;
case 'a':
aggressiveness = atoi(optarg);
if (aggressiveness <= 0) {
fprintf(stderr,
"aggressiveness must be a positive integer\n");
usage();
exit(2);
}
break;
case 's':
seeded = 1;
seed = (unsigned int) atol(optarg);
break;
case 'T':
if (templatefile != NULL) {
fprintf(stderr, "template-file is already set\n");
usage();
exit(2);
}
templatefile = optarg;
break;
case 'O':
rndoffset = atoi(optarg);
if (rndoffset < 14) {
fprintf(stderr,
"random-offset must be greater than 14\n");
usage();
exit(2);
}
break;
case 'x':
diags = optarg;
break;
case 'P':
i = atoi(optarg);
if ((i <= 0) || (i > 65535)) {
fprintf(stderr,
"port must be a positive short integer\n");
usage();
exit(2);
}
port = (in_port_t) i;
break;
default:
usage();
exit(2);
}
/* adjust some global variables */
if (ipversion == 0)
ipversion = 4;
if (rate == 0)
rate = 100;
if (xlast == 0)
xlast = 60000;
if (noreport == 0)
report = 1;
if ((curport != 0) && (maxport == 0))
maxport = 65535;
/* when required, print the internal view of the command line */
if ((diags != NULL) && (strchr(diags, 'a') != NULL)) {
if (udp)
printf("UDP ");
printf("IPv%d", ipversion);
printf(" rate=%d", rate);
if (edns0 != 0)
printf(" EDNS0");
if (report != 0)
printf(" report=%d", report);
if (range != 0) {
if (strchr(diags, 'r') != NULL)
printf(" range=0..%d [0x%x]",
range,
(unsigned int) maxrandom);
else
printf(" range=0..%d", range);
}
if (basecnt != 0)
for (i = 0; i < basecnt; i++)
printf(" base[%d]='%s'", i, base[i]);
if (gotnumreq >= 0) {
if ((numreq[0] == 0) && (numreq[1] != 0))
printf(" num-request=*,%d", numreq[1]);
if ((numreq[0] != 0) && (numreq[1] == 0))
printf(" num-request=%d,*", numreq[0]);
if ((numreq[0] != 0) && (numreq[1] != 0))
printf(" num-request=%d,%d",
numreq[0], numreq[1]);
}
if (period != 0)
printf(" test-period=%d", period);
printf(" lost-time=%g,%g", losttime[0], losttime[1]);
if (gotmaxloss == 0) {
if (maxloss[0] != 0)
printf(" max-loss=%d,*", maxloss[0]);
if (maxploss[0] != 0.)
printf(" max-loss=%2.2f%%,*", maxploss[0]);
} else if (gotmaxloss == 1) {
if (maxloss[0] != 0)
printf(" max-loss=%d,", maxloss[0]);
else if (maxploss[0] != 0.)
printf(" max-loss=%2.2f%%,", maxploss[0]);
else
printf(" max-loss=*,");
if (maxloss[1] != 0)
printf("%d", maxloss[1]);
else if (maxploss[1] != 0.)
printf("%2.2f%%", maxploss[1]);
else
printf("*");
}
printf(" aggressiveness=%d", aggressiveness);
if (seeded)
printf(" seed=%u", seed);
if (templatefile != NULL)
printf(" template-file='%s'", templatefile);
else if (ixann != 0)
printf(" Xflag");
if (rndoffset >= 0)
printf(" rnd-offset=%d", rndoffset);
printf(" diagnotic-selectors='%s'", diags);
printf("\n");
}
/* check local address options */
if ((localname == NULL) && (curport != 0)) {
fprintf(stderr,
"-l<local-addr> must be set to use -L<local-port>\n");
usage();
exit(2);
}
/* check template file options */
if ((templatefile == NULL) && (rndoffset >= 0)) {
fprintf(stderr,
"-T<template-file> must be set to "
"use -O<random-offset>\n");
usage();
exit(2);
}
/* check various template file(s) and other condition(s) options */
if ((templatefile != NULL) && (range > 0) && (rndoffset < 0)) {
fprintf(stderr,
"-O<random-offset> must be set when "
"-T<template-file> and -R<range> are used\n");
usage();
exit(2);
}
/* get the server argument */
if (optind < argc - 1) {
fprintf(stderr, "extra arguments?\n");
usage();
exit(2);
}
if (optind == argc - 1)
servername = argv[optind];
/* handle the local '-l' address/interface */
if (localname != NULL) {
/* given */
getlocaladdr();
if ((diags != NULL) && (strchr(diags, 'a') != NULL)) {
printf("local-addr='%s'", localname);
if (curport != 0)
printf(" local-port='%d..%d'",
minport, maxport);
printf("\n");
}
}
/* get the server socket address */
if (servername == NULL) {
fprintf(stderr, "server is required\n");
usage();
exit(2);
}
getserveraddr(flags);
/* finish local/server socket address stuff and print it */
if ((diags != NULL) && (strchr(diags, 'a') != NULL))
printf("server='%s'\n", servername);
if ((localname != NULL) &&
(diags != NULL) && (strchr(diags, 'a') != NULL)) {
char addr[NI_MAXHOST];
ret = getnameinfo((struct sockaddr *) &localaddr,
sizeof(localaddr),
addr,
NI_MAXHOST,
NULL,
0,
NI_NUMERICHOST);
if (ret != 0) {
fprintf(stderr,
"can't get the local address: %s\n",
gai_strerror(ret));
exit(1);
}
printf("local address='%s'\n", addr);
}
/* initialize exchange structures */
inits();
/* get the socket descriptor and template(s) */
if (templatefile == NULL)
build_template_query();
else
get_template_query();
/* boot is done! */
if (clock_gettime(CLOCK_REALTIME, &boot) < 0) {
perror("clock_gettime(boot)");
exit(1);
}
/* compute the next intermediate reporting date */
if (report != 0) {
dreport.tv_sec = boot.tv_sec + report;
dreport.tv_nsec = boot.tv_nsec;
}
/* seed the random generator */
if (seeded == 0)
seed = (unsigned int) (boot.tv_sec + boot.tv_nsec);
srandom(seed);
/* required only before the interrupted flag check */
(void) signal(SIGINT, interrupt);
(void) signal(SIGTERM, terminate);
/* threads */
master = pthread_self();
ret = pthread_create(&connector, NULL, connecting, NULL);
if (ret != 0) {
fprintf(stderr, "pthread_create: %s\n", strerror(ret));
exit(1);
}
ret = pthread_create(&sender, NULL, sending, NULL);
if (ret != 0) {
fprintf(stderr, "pthread_create: %s\n", strerror(ret));
exit(1);
}
ret = pthread_create(&receiver, NULL, receiving, NULL);
if (ret != 0) {
fprintf(stderr, "pthread_create: %s\n", strerror(ret));
exit(1);
}
/* main loop */
for (;;) {
struct timespec now, ts;
/* immediate loop exit conditions */
if (interrupted) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("interrupted\n");
break;
}
if (fatal) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("got a fatal error\n");
break;
}
loops[0]++;
/* get the date and use it */
if (clock_gettime(CLOCK_REALTIME, &now) < 0) {
perror("clock_gettime(now)");
fatal = 1;
continue;
}
if ((period != 0) &&
((boot.tv_sec + period < now.tv_sec) ||
((boot.tv_sec + period == now.tv_sec) &&
(boot.tv_nsec < now.tv_nsec)))) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("reached test-period\n");
break;
}
if ((report != 0) &&
((dreport.tv_sec < now.tv_sec) ||
((dreport.tv_sec == now.tv_sec) &&
(dreport.tv_nsec < now.tv_nsec))))
reporting();
/* check receive loop exit conditions */
if ((numreq[0] != 0) && ((int) xccount >= numreq[0])) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("reached num-connection\n");
break;
}
if ((numreq[1] != 0) && ((int) xscount >= numreq[1])) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("reached num-query\n");
break;
}
if ((maxloss[0] != 0) &&
((int) (xccount - xscount) > maxloss[0])) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("reached max-loss "
"(connection/absolute)\n");
break;
}
if ((maxloss[1] != 0) &&
((int) (xscount - xrcount) > maxloss[1])) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("reached max-loss "
"(query/absolute)\n");
break;
}
if ((maxploss[0] != 0.) &&
(xccount > 10) &&
(((100. * (xccount - xscount)) / xccount) > maxploss[1])) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("reached max-loss "
"(connection/percent)\n");
break;
}
if ((maxploss[1] != 0.) &&
(xscount > 10) &&
(((100. * (xscount - xrcount)) / xscount) > maxploss[1])) {
if ((diags != NULL) && (strchr(diags, 'e') != NULL))
printf("reached max-loss "
"(query/percent)\n");
break;
}
/* waiting 1ms */
memset(&ts, 0, sizeof(ts));
ts.tv_nsec = 1000000;
(void) clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL);
}
/* after main loop: finished */
if (clock_gettime(CLOCK_REALTIME, &finished) < 0)
perror("clock_gettime(finished)");
/* threads */
(void) pthread_cancel(connector);
(void) pthread_cancel(sender);
(void) pthread_cancel(receiver);
/* main statictics */
printf("connect: %llu, sent: %llu, received: %llu\n",
(unsigned long long) xccount,
(unsigned long long) xscount,
(unsigned long long) xrcount);
printf("embryonics: %lld (%.1f%%)\n",
(long long) (xccount - xscount),
(100. * (xccount - xscount)) / xccount);
printf("drops: %lld (%.1f%%)\n",
(long long) (xscount - xrcount),
(100. * (xscount - xrcount)) / xscount);
printf("total losses: %lld (%.1f%%)\n",
(long long) (xccount - xrcount),
(100. * (xccount - xrcount)) / xccount);
printf("local limits: %llu, bad connects: %llu, "
"connect timeouts: %llu\n",
(unsigned long long) locallimit,
(unsigned long long) badconn,
(unsigned long long) collconn);
printf("bad sends: %llu, bad recvs: %llu, recv timeouts: %llu\n",
(unsigned long long) badsent,
(unsigned long long) recverr,
(unsigned long long) collsent);
printf("too shorts: %llu, bad IDs: %llu, not responses: %llu\n",
(unsigned long long) tooshort,
(unsigned long long) badid,
(unsigned long long) notresp);
printf("rcode counters:\n noerror: %llu, formerr: %llu, "
"servfail: %llu\n "
"nxdomain: %llu, noimp: %llu, refused: %llu, others: %llu\n",
(unsigned long long) rcodes[NS_RCODE_NOERROR],
(unsigned long long) rcodes[NS_RCODE_FORMERR],
(unsigned long long) rcodes[NS_RCODE_SERVFAIL],
(unsigned long long) rcodes[NS_RCODE_NXDOMAIN],
(unsigned long long) rcodes[NS_RCODE_NOIMP],
(unsigned long long) rcodes[NS_RCODE_REFUSED],
(unsigned long long) rcodes[NS_RCODE_LAST]);
/* print the rates */
if (finished.tv_sec != 0) {
double dall, erate[3];
dall = (finished.tv_nsec - boot.tv_nsec) / 1e9;
dall += finished.tv_sec - boot.tv_sec;
erate[0] = xccount / dall;
erate[1] = xscount / dall;
erate[2] = xrcount / dall;
printf("rates: %.0f,%.0f,%.0f (target %d)\n",
erate[0], erate[1], erate[2], rate);
}
/* rate processing instrumentation */
if ((diags != NULL) && (strchr(diags, 'i') != NULL)) {
printf("loops: %llu,%llu,%llu,%llu\n",
(unsigned long long) loops[0],
(unsigned long long) loops[1],
(unsigned long long) loops[2],
(unsigned long long) loops[3]);
printf("shortwait: %llu,%llu,%llu\n",
(unsigned long long) shortwait[0],
(unsigned long long) shortwait[1],
(unsigned long long) shortwait[2]);
printf("compconn: %llu, lateconn: %llu\n",
(unsigned long long) compconn,
(unsigned long long) lateconn);
printf("badconn: %llu, collconn: %llu, "
"recverr: %llu, collsent: %llu\n",
(unsigned long long) badconn,
(unsigned long long) collconn,
(unsigned long long) recverr,
(unsigned long long) collsent);
printf("memory: used(%d) / allocated(%d)\n",
xused, xlast);
}
/* round-time trip statistics */
if (xrcount != 0) {
double avg, stddev;
avg = dsum / xrcount;
stddev = sqrt(dsumsq / xrcount - avg * avg);
printf("RTT: min/avg/max/stddev: %.3f/%.3f/%.3f/%.3f ms\n",
dmin * 1e3, avg * 1e3, dmax * 1e3, stddev * 1e3);
}
printf("\n");
/* template(s) */
if ((diags != NULL) && (strchr(diags, 'T') != NULL)) {
size_t n;
printf("length = 0x%zx\n", length_query);
if (random_query > 0)
printf("random offset = %zu\n", random_query);
printf("content:\n");
for (n = 0; n < length_query; n++) {
printf("%s%02hhx",
(n & 15) == 0 ? "" : " ",
template_query[n]);
if ((n & 15) == 15)
printf("\n");
}
if ((n & 15) != 15)
printf("\n");
printf("\n");
}
/* compute the exit code (and exit) */
if (fatal)
exit(1);
else if ((xccount == xscount) && (xscount == xrcount))
exit(0);
else
exit(3);
}