static void carp(const char* routine) {
buffer_flush(buffer_1);
buffer_puts(buffer_2,"httpbench: ");
buffer_puts(buffer_2,routine);
buffer_puts(buffer_2,": ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
}
int main() {
int64 pfd[2];
char buf[20480];
unsigned int i;
if (!io_pipe(pfd)) return 111;
io_nonblock(pfd[1]);
if (!io_fd(pfd[1])) return 111;
switch (fork()) {
case -1: return 111;
case 0: /* child */
io_close(pfd[1]);
sleep(1);
for (;;) {
switch (io_waitread(pfd[0],buf,sizeof buf)) {
case -1: buffer_putsflush(buffer_2,"io_waitread returned -1!\n"); return 111;
case -3: buffer_puts(buffer_2,"io_waitread: ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
return 111;
case 0: io_close(pfd[0]);
return 0;
}
}
}
io_close(pfd[0]);
for (i=0; i<sizeof(buf); ++i) buf[i]="abcdefghihjklmnopqrstuvwxyz"[i%26];
for (i=0; i<1000; ++i) {
int64 r;
if ((r=io_waitwrite(pfd[1],buf,sizeof buf))!=sizeof buf) {
buffer_puts(buffer_2,"io_waitwrite returned ");
buffer_putlonglong(buffer_2,r);
buffer_putnlflush(buffer_2);
}
}
return 0;
}
int main(int argc,char* argv[]) {
unsigned long count=1000;
struct timeval a,b;
unsigned long d;
#ifdef RLIMIT_NPROC
{
struct rlimit rl;
rl.rlim_cur=RLIM_INFINITY; rl.rlim_max=RLIM_INFINITY;
setrlimit(RLIMIT_NPROC,&rl);
}
#endif
for (;;) {
int i;
int c=getopt(argc,argv,"hc:");
if (c==-1) break;
switch (c) {
case 'c':
i=scan_ulong(optarg,&count);
if (i==0 || optarg[i]) {
buffer_puts(buffer_2,"pthreadbench: warning: could not parse count: ");
buffer_puts(buffer_2,optarg+i+1);
buffer_putsflush(buffer_2,"\n");
}
break;
case 'h':
buffer_putsflush(buffer_2,
"usage: pthreadbench [-h] [-c count]\n"
"\n"
"\t-h\tprint this help\n"
"\t-c n\tfork off n children (default: 1000)\n");
return 0;
}
}
{
unsigned long i;
int pfd[2];
char buf[100];
pthread_t *p=malloc(count*sizeof(pthread_t));
if (!p) {
buffer_puts(buffer_2,"out of memory!\n");
exit(1);
}
if (pipe(pfd)==-1) {
buffer_puts(buffer_2,"pipe failed: ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
}
for (i=0; i<count; ++i) {
int r;
gettimeofday(&a,0);
switch ((r=pthread_create(p+i,0,(void*(*)(void*))mythread,pfd))) {
case 0: /* ok */
break;
default:
buffer_puts(buffer_2,"could not create thread: ");
buffer_puterror(buffer_2);
buffer_putsflush(buffer_2,".\n");
exit(1);
}
if (read(pfd[0],buf,1)!=1) {
buffer_putsflush(buffer_2,"thread did not write into pipe?!\n");
exit(1);
}
gettimeofday(&b,0);
d=(b.tv_sec-a.tv_sec)*1000000;
d=d+b.tv_usec-a.tv_usec;
buffer_putulong(buffer_1,d);
buffer_puts(buffer_1,"\n");
}
buffer_flush(buffer_1);
}
return 0;
}
int main(int argc,char* argv[]) {
unsigned long count=1000;
int v6;
v6=0;
{
struct rlimit rl;
rl.rlim_cur=RLIM_INFINITY; rl.rlim_max=RLIM_INFINITY;
setrlimit(RLIMIT_NOFILE,&rl);
#ifdef RLIMIT_NPROC
setrlimit(RLIMIT_NPROC,&rl);
#endif
}
for (;;) {
int i;
int c=getopt(argc,argv,"h6c:");
if (c==-1) break;
switch (c) {
case 'c':
i=scan_ulong(optarg,&count);
if (i==0 || optarg[i]) {
buffer_puts(buffer_2,"httpbench: warning: could not parse count: ");
buffer_puts(buffer_2,optarg+i+1);
buffer_putsflush(buffer_2,"\n");
}
break;
case '6':
v6=1;
break;
case 'h':
buffer_putsflush(buffer_2,
"usage: bindbench [-h] [-6] [-c count]\n"
"\n"
"\t-h\tprint this help\n"
"\t-c n\tbind n sockets to port 0 (default: 1000)\n"
"\t-6\tbind IPv6 sockets instead of IPV4\n");
return 0;
}
}
{
int i,r;
char ip[16];
int port;
#ifdef __i386__
unsigned long long a,b,c;
#else
struct timeval a,b,c;
unsigned long d;
#endif
int *socks=alloca(count*sizeof(int));
port=0; byte_zero(ip,16);
for (i=0; i<count; ++i) {
#ifdef __i386__
rdtscl(a);
#else
gettimeofday(&a,0);
#endif
socks[i]=v6?socket_tcp6():socket_tcp4();
#ifdef __i386__
rdtscl(b);
#else
gettimeofday(&b,0);
#endif
if (socks[i]==-1) {
buffer_puts(buffer_2,"socket() failed: ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
exit(1);
}
if (v6)
r=socket_bind6(socks[i],ip,port,0);
else
r=socket_bind4(socks[i],ip,port);
if (r==-1) {
buffer_puts(buffer_2,"bind() failed: ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
exit(1);
}
#ifdef __i386__
rdtscl(c);
buffer_putulong(buffer_1,b-a);
#else
gettimeofday(&c,0);
d=(b.tv_sec-a.tv_sec)*1000000;
d=d+b.tv_usec-a.tv_usec;
buffer_putulong(buffer_1,d);
#endif
buffer_putspace(buffer_1);
#ifdef __i386__
buffer_putulong(buffer_1,c-b);
#else
d=(c.tv_sec-b.tv_sec)*1000000;
d=d+c.tv_usec-b.tv_usec;
buffer_putulong(buffer_1,d);
#endif
buffer_puts(buffer_1,"\n");
if (i>50) {
close(socks[10]);
socks[10]=v6?socket_tcp6():socket_tcp4();
}
}
}
buffer_flush(buffer_1);
return 0;
}
int
main(int argc, char* argv[]) {
int s = socket_tcp6();
uint32 scope_id;
char ip[16];
uint16 port;
char hisip[16];
uint16 hisport;
uint32 hisscope_id;
static char seed[128];
static stralloc fqdn;
static stralloc out;
if(argc != 4) {
usage:
buffer_putsflush(buffer_2,
"usage: proxy myip myport hisip hisport\n"
"\n"
"e.g.: proxy 0 119 news.fu-berlin.de 119\n");
return 0;
}
if(argv[1][scan_ip6if(argv[1], ip, &scope_id)]) {
if(str_equal(argv[1], "0")) {
byte_zero(ip, 16);
scope_id = 0;
} else
goto usage;
}
if(argv[2][scan_ushort(argv[2], &port)])
goto usage;
if(argv[3][scan_ip6if(argv[3], hisip, &hisscope_id)]) {
dns_random_init(seed);
if(!stralloc_copys(&fqdn, argv[3]))
goto nomem;
if(dns_ip4(&out, &fqdn) == -1) {
buffer_puts(buffer_2, "unable to find IP address for ");
buffer_puts(buffer_2, argv[3]);
buffer_puts(buffer_2, ": ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
return 111;
}
} else if(!stralloc_catb(&out, hisip, 16)) {
nomem:
buffer_putsflush(buffer_2, "out of memory\n");
return 111;
}
if(argv[4][scan_ushort(argv[4], &hisport)])
goto usage;
if(socket_bind6_reuse(s, ip, port, scope_id) == -1) {
buffer_puts(buffer_2, "socket_bind6_reuse: ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
return 111;
}
if(socket_listen(s, 16) == -1) {
buffer_puts(buffer_2, "socket_listen: ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
return 111;
}
if(!io_fd(s)) {
buffer_puts(buffer_2, "io_fd: ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
return 111;
}
io_wantread(s);
for(;;) {
int64 i;
io_wait();
while((i = io_canread()) != -1) {
if(i == s) {
/* the read event is on the server socket */
/* that means it's an incoming connection */
int n;
while((n = socket_accept6(s, ip, &port, &scope_id)) != -1) {
int x = socket_tcp6();
if(x == -1) {
buffer_puts(buffer_2, "socket_tcp6 failed: ");
fail:
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
io_close(n);
} else {
struct state* s = malloc(sizeof(struct state));
if(!s)
goto closefail;
s->a = n;
s->b = x;
s->connected = 0;
s->done = s->todo = 0;
s->dir = UNDECIDED;
io_nonblock(x);
socket_connect6(x, out.s, hisport, hisscope_id);
if(!io_fd(x) || !io_fd(n)) {
buffer_puts(buffer_2, "io_fd failed: ");
closefail:
free(s);
io_close(x);
goto fail;
}
io_setcookie(x, s);
io_setcookie(n, s);
io_wantwrite(x);
}
}
if(errno != EAGAIN) {
buffer_puts(buffer_2, "socket_accept6 failed: ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
}
} else {
/* read event on an established connection */
struct state* s = io_getcookie(i);
int l = io_tryread(i, s->buf, sizeof(s->buf));
if(l == -1) {
buffer_puts(buffer_2, "io_tryread(");
buffer_putulong(buffer_2, i);
buffer_puts(buffer_2, "): ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
io_close(s->a);
io_close(s->b);
} else if(l == 0) {
buffer_puts(buffer_2, "eof on fd #");
buffer_putulong(buffer_2, i);
buffer_putnlflush(buffer_2);
io_close(i);
} else {
int r;
switch(r = io_trywrite(i, s->buf, l)) {
case -1:
buffer_puts(buffer_2, "io_tryread(");
buffer_putulong(buffer_2, i);
buffer_puts(buffer_2, "): ");
buffer_puterror(buffer_2);
buffer_putnlflush(buffer_2);
io_close(i);
break;
case 0:
buffer_puts(buffer_2, "write eof on fd #");
buffer_putulong(buffer_2, i);
buffer_putnlflush(buffer_2);
io_close(i);
default:
if(r != l) {
buffer_puts(buffer_2, "short write on fd #");
buffer_putulong(buffer_2, i);
buffer_puts(buffer_2, ": wrote ");
buffer_putulong(buffer_2, r);
buffer_puts(buffer_2, ", wanted to write ");
buffer_putulong(buffer_2, l);
buffer_putsflush(buffer_2, ").\n");
}
}
}
}
}
}
return 0;
}
