/* * T T C P . C * * Test TCP connection. Makes a connection on port 2000 * and transfers zero buffers or data copied from stdin. * * Usable on 4.2, 4.3, and 4.1a systems by defining one of * BSD42 BSD43 (BSD41a) * * Modified for operation under 4.2BSD, 18 Dec 84 * T.C. Slattery, USNA * Minor improvements, Mike Muuss and Terry Slattery, 16-Oct-85. * * Mike Muuss and Terry Slattery have released this code to the Public Domain. */ #define BSD43 /* #define BSD42 */ /* #define BSD41a */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* struct timeval */ #ifdef SYSV #include #include #else #include #endif #include "splice.h" #ifndef MAX_SPLICE_SIZE #define MAX_SPLICE_SIZE (64 * 1024) #endif #define VM_BUFFERS 2 #define ALIGN(value,size) (((value) + (size) - 1) & ~((size) - 1)) struct sockaddr_in sinme; struct sockaddr_in sinhim; struct sockaddr_in sindum; struct sockaddr_in frominet; int domain, fromlen; int fd; /* fd of network socket */ int pfds/*[VM_BUFFERS]*/[2]; /* fds for pipe */ int buflen = 1024; /* length of buffer */ char *buf; /* ptr to dynamic buffer */ int nbuf = 1024; /* number of buffers to send in sinkmode */ size_t pipe_buf_size; char *pipe_buf; int udp = 0; /* 0 = tcp, !0 = udp */ int options = 0; /* socket options */ int one = 1; /* for 4.3 BSD style setsockopt() */ short port = 2000; /* TCP port number */ char *host; /* ptr to name of host */ int trans; /* 0=receive, !0=transmit mode */ int sinkmode; /* 0=normal I/O, !0=sink/source mode */ int splicemode; /* 0=normal I/O, !0=splice mode */ struct hostent *addr; extern int errno; char Usage[] = "\ Usage: ttcp -t [-options] host out\n\ -l## length of network read buf (default 1024)\n\ -s sink (discard) all data from network\n\ -z use the splice syscall\n\ -p## port number to listen at (default 2000)\n\ -B Only output full blocks, as specified in -l## (for TAR)\n\ -u use UDP instead of TCP\n\ "; char stats[128]; double t; /* transmission time */ long nbytes; /* bytes on net */ int b_flag = 0; /* use mread() */ void prep_timer(); double read_timer(); double cput, realt; /* user, real time (seconds) */ void err(char *s); void mes(char *s); void pattern(register char *cp, register int cnt); int Nread( int fd, char *buf, int count ); int Nwrite( int fd, char *buf, int count ); int mread(int fd, char *bufp, unsigned int n); void setup_vmsplice(); uint64_t vmsplice_recv(int sd, int fd); //int delay(int us); int main(argc,argv) int argc; char **argv; { unsigned long addr_tmp; if (argc < 2) goto usage; argv++; argc--; while( argc>0 && argv[0][0] == '-' ) { switch (argv[0][1]) { case 'B': b_flag = 1; break; case 't': trans = 1; break; case 'r': trans = 0; break; case 'd': options |= SO_DEBUG; break; case 'n': nbuf = atoi(&argv[0][2]); break; case 'l': buflen = atoi(&argv[0][2]); break; case 's': sinkmode = 1; /* source or sink, really */ break; case 'z': splicemode = 1; /* splice mode */ break; case 'p': port = atoi(&argv[0][2]); break; case 'u': udp = 1; break; default: goto usage; } argv++; argc--; } if(trans) { /* xmitr */ if (argc != 1) goto usage; bzero((char *)&sinhim, sizeof(sinhim)); host = argv[0]; if (atoi(host) > 0 ) { /* Numeric */ sinhim.sin_family = AF_INET; #ifdef cray addr_tmp = inet_addr(host); sinhim.sin_addr = addr_tmp; #else sinhim.sin_addr.s_addr = inet_addr(host); #endif } else { if ((addr=gethostbyname(host)) == NULL) err("bad hostname"); sinhim.sin_family = addr->h_addrtype; bcopy(addr->h_addr,(char*)&addr_tmp, addr->h_length); #ifdef cray sinhim.sin_addr = addr_tmp; #else sinhim.sin_addr.s_addr = addr_tmp; #endif } sinhim.sin_port = htons(port); sinme.sin_port = 0; /* free choice */ } else { /* rcvr */ sinme.sin_port = htons(port); } if( (buf = (char *)malloc(buflen)) == (char *)NULL) err("malloc"); fprintf(stderr,"ttcp%s: nbuf=%d, buflen=%d, port=%d\n", trans?"-t":"-r", nbuf, buflen, port); if ((fd = socket(AF_INET, udp?SOCK_DGRAM:SOCK_STREAM, 0)) < 0) err("socket"); mes("socket"); if (bind(fd, &sinme, sizeof(sinme)) < 0) err("bind"); if (!udp) { if (trans) { /* We are the client if transmitting */ if(options) { #ifdef BSD42 if( setsockopt(fd, SOL_SOCKET, options, 0, 0) < 0) #else if( setsockopt(fd, SOL_SOCKET, options, &one, sizeof(one)) < 0) #endif err("setsockopt"); } if(connect(fd, &sinhim, sizeof(sinhim) ) < 0) err("connect"); mes("connect"); } else { /* otherwise, we are the server and * should listen for the connections */ listen(fd,0); /* allow a queue of 0 */ if(options) { #ifdef BSD42 if( setsockopt(fd, SOL_SOCKET, options, 0, 0) < 0) #else if( setsockopt(fd, SOL_SOCKET, options, &one, sizeof(one)) < 0) #endif err("setsockopt"); } fromlen = sizeof(frominet); domain = AF_INET; if((fd=accept(fd, &frominet, &fromlen) ) < 0) err("accept"); mes("accept"); } } if (splicemode){ pipe_buf_size = buflen; setup_vmsplice(); } prep_timer(); errno = 0; if (sinkmode) { register int cnt; if (trans) { pattern( buf, buflen ); if(udp) (void)Nwrite( fd, buf, 4 ); /* rcvr start */ while (nbuf-- && Nwrite(fd,buf,buflen) == buflen) nbytes += buflen; if(udp) (void)Nwrite( fd, buf, 4 ); /* rcvr end */ } else { while ((cnt=Nread(fd,buf,buflen)) > 0) { static int going = 0; if( cnt <= 4 ) { if( going ) break; /* "EOF" */ going = 1; prep_timer(); } else nbytes += cnt; } } } else { register int cnt; if (trans) { while((cnt=read(0,buf,buflen)) > 0 && Nwrite(fd,buf,cnt) == cnt) nbytes += cnt; } else { if(splicemode) { while((cnt=vmsplice_recv(fd, 1)) > 0) nbytes += cnt; } else { while((cnt=Nread(fd,buf,buflen)) > 0 && write(1,buf,cnt) == cnt) nbytes += cnt; } } } if(errno) err("IO"); (void)read_timer(stats,sizeof(stats)); if(udp&&trans) { (void)Nwrite( fd, buf, 4 ); /* rcvr end */ (void)Nwrite( fd, buf, 4 ); /* rcvr end */ (void)Nwrite( fd, buf, 4 ); /* rcvr end */ (void)Nwrite( fd, buf, 4 ); /* rcvr end */ } fprintf(stderr,"ttcp%s: %s\n", trans?"-t":"-r", stats); if( cput <= 0.0 ) cput = 0.001; if( realt <= 0.0 ) realt = 0.001; fprintf(stderr,"ttcp%s: %ld bytes processed\n", trans?"-t":"-r", nbytes ); fprintf(stderr,"ttcp%s: %9g CPU sec = %9g KB/cpu sec, %9g Kbits/cpu sec\n", trans?"-t":"-r", cput, ((double)nbytes)/cput/1024, ((double)nbytes)*8/cput/1024 ); fprintf(stderr,"ttcp%s: %9g real sec = %9g KB/real sec, %9g Kbits/sec\n", trans?"-t":"-r", realt, ((double)nbytes)/realt/1024, ((double)nbytes)*8/realt/1024 ); exit(0); usage: fprintf(stderr,Usage); exit(1); } void err(s) char *s; { fprintf(stderr,"ttcp%s: ", trans?"-t":"-r"); perror(s); fprintf(stderr,"errno=%d\n",errno); exit(1); } void mes(s) char *s; { fprintf(stderr,"ttcp%s: %s\n", trans?"-t":"-r", s); } void pattern( cp, cnt ) register char *cp; register int cnt; { register char c; c = 0; while( cnt-- > 0 ) { while( !isprint((c&0x7F)) ) c++; *cp++ = (c++&0x7F); } } /******* timing *********/ #ifdef SYSV extern long time(); static long time0; static struct tms tms0; #else static struct timeval time0; /* Time at which timeing started */ static struct rusage ru0; /* Resource utilization at the start */ static void prusage(); static void tvadd(); static void tvsub(); static void psecs(); #endif /* * P R E P _ T I M E R */ void prep_timer() { #ifdef SYSV (void)time(&time0); (void)times(&tms0); #else gettimeofday(&time0, (struct timezone *)0); getrusage(RUSAGE_SELF, &ru0); #endif } /* * R E A D _ T I M E R * */ double read_timer(str,len) char *str; { #ifdef SYSV long now; struct tms tmsnow; char line[132]; (void)time(&now); realt = now-time0; (void)times(&tmsnow); cput = tmsnow.tms_utime - tms0.tms_utime; cput /= HZ; if( cput < 0.00001 ) cput = 0.01; if( realt < 0.00001 ) realt = cput; sprintf(line,"%g CPU secs in %g elapsed secs (%g%%)", cput, realt, cput/realt*100 ); (void)strncpy( str, line, len ); return( cput ); #else /* BSD */ struct timeval timedol; struct rusage ru1; struct timeval td; struct timeval tend, tstart; char line[132]; getrusage(RUSAGE_SELF, &ru1); gettimeofday(&timedol, (struct timezone *)0); prusage(&ru0, &ru1, &timedol, &time0, line); (void)strncpy( str, line, len ); /* Get real time */ tvsub( &td, &timedol, &time0 ); realt = td.tv_sec + ((double)td.tv_usec) / 1000000; /* Get CPU time (user+sys) */ tvadd( &tend, &ru1.ru_utime, &ru1.ru_stime ); tvadd( &tstart, &ru0.ru_utime, &ru0.ru_stime ); tvsub( &td, &tend, &tstart ); cput = td.tv_sec + ((double)td.tv_usec) / 1000000; if( cput < 0.00001 ) cput = 0.00001; return( cput ); #endif } #ifndef SYSV static void prusage(r0, r1, e, b, outp) register struct rusage *r0, *r1; struct timeval *e, *b; char *outp; { struct timeval tdiff; register time_t t; register char *cp; register int i; int ms; t = (r1->ru_utime.tv_sec-r0->ru_utime.tv_sec)*100+ (r1->ru_utime.tv_usec-r0->ru_utime.tv_usec)/10000+ (r1->ru_stime.tv_sec-r0->ru_stime.tv_sec)*100+ (r1->ru_stime.tv_usec-r0->ru_stime.tv_usec)/10000; ms = (e->tv_sec-b->tv_sec)*100 + (e->tv_usec-b->tv_usec)/10000; #define END(x) {while(*x) x++;} cp = "%Uuser %Ssys %Ereal %P %Xi+%Dd %Mmaxrss %F+%Rpf %Ccsw"; for (; *cp; cp++) { if (*cp != '%') *outp++ = *cp; else if (cp[1]) switch(*++cp) { case 'U': tvsub(&tdiff, &r1->ru_utime, &r0->ru_utime); sprintf(outp,"%d.%01ld",(int) tdiff.tv_sec, tdiff.tv_usec/100000); END(outp); break; case 'S': tvsub(&tdiff, &r1->ru_stime, &r0->ru_stime); sprintf(outp,"%d.%01ld", (int )tdiff.tv_sec, tdiff.tv_usec/100000); END(outp); break; case 'E': psecs(ms / 100, outp); END(outp); break; case 'P': sprintf(outp,"%d%%", (int) (t*100 / ((ms ? ms : 1)))); END(outp); break; case 'W': i = r1->ru_nswap - r0->ru_nswap; sprintf(outp,"%d", i); END(outp); break; case 'X': sprintf(outp,"%ld", t == 0 ? 0 : (r1->ru_ixrss-r0->ru_ixrss)/t); END(outp); break; case 'D': sprintf(outp,"%ld", t == 0 ? 0 : (r1->ru_idrss+r1->ru_isrss-(r0->ru_idrss+r0->ru_isrss))/t); END(outp); break; case 'K': sprintf(outp,"%ld", t == 0 ? 0 : ((r1->ru_ixrss+r1->ru_isrss+r1->ru_idrss) - (r0->ru_ixrss+r0->ru_idrss+r0->ru_isrss))/t); END(outp); break; case 'M': sprintf(outp,"%ld", r1->ru_maxrss/2); END(outp); break; case 'F': sprintf(outp,"%ld", r1->ru_majflt-r0->ru_majflt); END(outp); break; case 'R': sprintf(outp,"%ld", r1->ru_minflt-r0->ru_minflt); END(outp); break; case 'I': sprintf(outp,"%ld", r1->ru_inblock-r0->ru_inblock); END(outp); break; case 'O': sprintf(outp,"%ld", r1->ru_oublock-r0->ru_oublock); END(outp); break; case 'C': sprintf(outp,"%ld+%ld", r1->ru_nvcsw-r0->ru_nvcsw, r1->ru_nivcsw-r0->ru_nivcsw ); END(outp); break; } } *outp = '\0'; } static void tvadd(tsum, t0, t1) struct timeval *tsum, *t0, *t1; { tsum->tv_sec = t0->tv_sec + t1->tv_sec; tsum->tv_usec = t0->tv_usec + t1->tv_usec; if (tsum->tv_usec > 1000000) tsum->tv_sec++, tsum->tv_usec -= 1000000; } static void tvsub(tdiff, t1, t0) struct timeval *tdiff, *t1, *t0; { tdiff->tv_sec = t1->tv_sec - t0->tv_sec; tdiff->tv_usec = t1->tv_usec - t0->tv_usec; if (tdiff->tv_usec < 0) tdiff->tv_sec--, tdiff->tv_usec += 1000000; } static void psecs(l,cp) long l; register char *cp; { register int i; i = l / 3600; if (i) { sprintf(cp,"%d:", i); END(cp); i = l % 3600; sprintf(cp,"%d%d", (i/60) / 10, (i/60) % 10); END(cp); } else { i = l; sprintf(cp,"%d", i / 60); END(cp); } i %= 60; *cp++ = ':'; sprintf(cp,"%d%d", i / 10, i % 10); } #endif /* * N R E A D */ int Nread( int fd, char *buf, int count ) { struct sockaddr_in from; int len = sizeof(from); register int cnt; if( udp ) { cnt = recvfrom( fd, buf, count, 0, &from, &len ); } else { if( b_flag ) cnt = mread( fd, buf, count ); /* fill buf */ else cnt = read( fd, buf, count ); } return(cnt); } /* * N W R I T E */ int Nwrite( int fd, char *buf, int count ) { register int cnt; if( udp ) { again: cnt = sendto( fd, buf, count, 0, &sinhim, sizeof(sinhim) ); if( cnt<0 && errno == ENOBUFS ) { usleep(18000); errno = 0; goto again; } } else { cnt = write( fd, buf, count ); } return(cnt); } #if 0 int delay(us) { struct timeval tv; tv.tv_sec = 0; tv.tv_usec = us; (void)select( 1, (char *)0, (char *)0, (char *)0, &tv ); return(1); } #endif /* * M R E A D * * This function performs the function of a read(II) but will * call read(II) multiple times in order to get the requested * number of characters. This can be necessary because * network connections don't deliver data with the same * grouping as it is written with. Written by Robert S. Miles, BRL. */ int mread(fd, bufp, n) int fd; register char *bufp; unsigned n; { register unsigned count = 0; register int nread; do { nread = read(fd, bufp, n-count); if(nread < 0) { perror("ttcp_mread"); return(-1); } if(nread == 0) return((int)count); count += (unsigned)nread; bufp += nread; } while(count < n); return((int)count); } /* vmsplice moves pages backing a user address range to a pipe. However, * you don't want the application changing data in that address range * after the pages have been moved to the pipe, but before they have been * consumed at their destination. * * The solution is to double buffer: * load buffer A, vmsplice to pipe * load buffer B, vmsplice to pipe * When the B->splice->pipe call completes, there can no longer be any * references in the pipe to the pages backing buffer A, since it is now * filled with references to the pages backing buffer B. So, it is safe * to load new data into buffer A. */ void setup_vmsplice() { int i; size_t pg_sz = getpagesize(); /* for (i=0; i < VM_BUFFERS; i++){ if (pipe(pfds[i]) < 0) { err("opening pipe"); } }*/ if (pipe(pfds) < 0) { err("opening pipe"); } if (pipe_buf_size > MAX_SPLICE_SIZE) pipe_buf_size = MAX_SPLICE_SIZE; pipe_buf_size = ALIGN(pipe_buf_size, pg_sz); pipe_buf = malloc(VM_BUFFERS*pipe_buf_size + pg_sz); if (!pipe_buf) { err("Allocating data buffer"); } pipe_buf = (char *)ALIGN((unsigned long)pipe_buf, (unsigned long)pg_sz); fprintf(stderr, "setup_vmsplice: buf %p , buf_size %x\n", pipe_buf, pipe_buf_size); } #if 1 uint64_t vmsplice_recv(int sd, int fd) { struct iovec iov; uint64_t bytes = 0; ssize_t n, m, l; unsigned i = 1; // fprintf(stderr, "vmsplice_recv: sd %d fd %d\n", sd, fd); again: i = (i + 1) % VM_BUFFERS; iov.iov_base = pipe_buf + i * pipe_buf_size; l = 0; again2: m = read(sd, iov.iov_base + l, pipe_buf_size - l); /* fprintf(stderr, "vmsplice_recv: read 0x%x bytes, buf size 0x%x, l %d, buffer %p\n", m, pipe_buf_size, l, iov.iov_base + l);*/ if (m < 0) { if (errno == EINTR) goto again2; perror("Read"); exit(EXIT_FAILURE); } if (m == 0) { if (l == 0) { fprintf(stderr, "vmsplice_recv: l reached zero. bytes is 0x%x\n", (int) bytes); fdatasync(fd); return bytes; } } else { l += m; if (l != pipe_buf_size) goto again2; } while (l) { unsigned int splice_flags = 0; iov.iov_len = l; if ((l & 0x3FF) == 0) splice_flags = SPLICE_F_MOVE; n = vmsplice(pfds[1], &iov, 1, splice_flags); /* fprintf(stderr, "vmsplice_recv: vmsplice 0x%x bytes to pipe\n", n);*/ if (n < 0) { perror("vmsplice to pipe"); fprintf(stderr, "vmsplice_recv: iov_len %d iov.iov_base %x\n", iov.iov_len, iov.iov_base); exit(EXIT_FAILURE); } while (n) { m = splice(pfds[0], NULL, fd, NULL, n, splice_flags); // fprintf(stderr, "vmsplice_recv: vmsplice 0x%x bytes to file\n", m); if (m < 0) { perror("splice to file"); exit(EXIT_FAILURE); } if (m & 0x3FF) { fprintf(stderr, "splice: returned %x \n", m); } n -= m; l -= m; bytes += m; iov.iov_base += m; } } goto again; } #endif