/* * T T C P . C * * Test TCP connection. Makes a connection on port 5013 * and transfers fabricated buffers or data copied from stdin. * * Usable on 4.2, 4.3, and 4.1a systems by defining one of * BSD42 BSD43 (BSD41a) * Machines using System V with BSD sockets should define SYSV. * * Modified for operation under 4.2BSD, 18 Dec 84 * T.C. Slattery, USNA * Minor improvements, Mike Muuss and Terry Slattery, 16-Oct-85. * Modified in 1989 at Silicon Graphics, Inc. * catch SIGPIPE to be able to print stats when receiver has died * for tcp, don't look for sentinel during reads to allow small transfers * increased default buffer size to 8K, nbuf to 2K to transfer 16MB * moved default port to 5013, beyond IPPORT_USERRESERVED * make sinkmode default because it is more popular, * -s now means don't sink/source * count number of read/write system calls to see effects of * blocking from full socket buffers * for tcp, -D option turns off buffered writes (sets TCP_NODELAY sockopt) * buffer alignment options, -A and -O * print stats in a format that's a bit easier to use with grep & awk * for SYSV, mimic BSD routines to use most of the existing timing code * Modified by Steve Miller of the University of Maryland, College Park * -b sets the socket buffer size (SO_SNDBUF/SO_RCVBUF) * Modified Sept. 1989 at Silicon Graphics, Inc. * restored -s sense at request of tcs@brl * Modified Oct. 1991 at Silicon Graphics, Inc. * use getopt(3) for option processing, add -f and -T options. * SGI IRIX 3.3 and 4.0 releases don't need #define SYSV. * Modified April 1994 by John Lin (lin@cs.purdue.edu) * Add CPU_USAGE complier option and move the "gettimeofday" calls. * Heavily modified since 1995 by Werner Almesberger, EPFL ICA * Various ATM-related changes * * Distribution Status - * Public Domain. Distribution Unlimited. */ #if HAVE_CONFIG_H #include #endif #ifndef lint static char RCSid[] = "ttcp.c $Revision: 1.3 $"; #endif /*#define CPU_USAGE*/ /* print out CPU usage numbers? */ #define BSD43 /* #define BSD42 */ /* #define BSD41a */ /* #define SYSV */ /* required on SGI IRIX releases before 3.3 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* struct timeval */ #include #include #if defined(SYSV) #include #include struct rusage { struct timeval ru_utime, ru_stime; }; #define RUSAGE_SELF 0 #else #include #endif struct sockaddr_in sinme; struct sockaddr_in sinhim; struct sockaddr_in frominet; struct sockaddr_atmsvc satm; struct atm_qos qos; int domain; socklen_t fromlen; int fd; /* fd of network socket */ int buflen = 8 * 1024; /* length of buffer */ char *buf; /* ptr to dynamic buffer */ int nbuf = 2 * 1024; /* number of buffers to send in sinkmode */ int bufoffset = 0; /* align buffer to this */ int bufalign = 16*1024; /* modulo this */ int atm = 0; /* 0 = INET, !0 = ATM */ int pcr = 0; char *qos_spec = NULL; int udp = 0; /* 0 = tcp, !0 = udp */ int options = 0; /* socket options */ int one = 1; /* for 4.3 BSD style setsockopt() */ unsigned short port = 5013; /* TCP port number */ char *host; /* ptr to name of host */ int trans; /* 0=receive, !0=transmit mode */ int sinkmode = 0; /* 0=normal I/O, !0=sink/source mode */ int verbose = 0; /* 0=print basic info, 1=print cpu rate, proc * resource usage. */ int nodelay = 0; /* set TCP_NODELAY socket option */ int b_flag = 0; /* use mread() */ int sockbufsize = 0; /* socket buffer size to use */ char fmt = 'K'; /* output format: k = kilobits, K = kilobytes, * m = megabits, M = megabytes, * g = gigabits, G = gigabytes */ int touchdata = 0; /* access data after reading */ static struct timeval start_time; /* Time at which timing started */ static struct timeval stop_time; /* Time at which timing stopped */ static struct rusage ru0; /* Resource utilization at the start */ struct hostent *addr; char Usage[] = "\ Usage: ttcp -t [-options] host [ < in ]\n\ ttcp -r [-options > out]\n\ Common options:\n\ -l ## length of bufs read from or written to network (default 8192)\n\ -u use UDP instead of TCP\n\ -p ## port number to send to or listen at (default 5001)\n\ -s -t: source a pattern to network\n\ -r: sink (discard) all data from network\n\ -A align the start of buffers to this modulus (default 16384)\n\ -O start buffers at this offset from the modulus (default 0)\n\ -v verbose: print more statistics\n\ -d set SO_DEBUG socket option\n\ -b ## set socket buffer size (if supported)\n\ -f X format for rate: k,K = kilo{bit,byte}; m,M = mega; g,G = giga\n\ -a use native ATM instead of UDP/TCP\n\ Options specific to -t:\n\ -n## number of source bufs written to network (default 2048)\n\ -D don't buffer TCP writes (sets TCP_NODELAY socket option)\n\ -C disable (UDP) checksums\n\ -P X use the specified QOS for the ATM connection. If X is only\n\ a number, the following QOS spec is assumed: cbr:pcr=X\n\ -S X use the specified value for the TOS byte. Without -S, the\n\ system default is used.\n\ Options specific to -r:\n\ -B for -s, only output full blocks as specified by -l (for TAR)\n\ -T \"touch\": access each byte as it's read\n\ "; char stats[128]; double nbytes; /* bytes on net */ unsigned long numCalls; /* # of I/O system calls */ double cput, realt; /* user, real time (seconds) */ void err(const char *); void mes(const char *); void pattern(char *, int); void prep_timer(void); double read_timer(char *, int); int Nread(int, char *, int); int Nwrite(int, char *, int); void delay(long); int mread(int, char *, unsigned); char *outfmt(double); static void prusage(struct rusage *, struct rusage *, struct timeval *, struct timeval *, char *); static void tvadd(struct timeval *, struct timeval *, struct timeval *); static void tvsub(struct timeval *, struct timeval *, struct timeval *); static void psecs(long, char*); void sigpipe(int sig) { return; } /*------------------------------------------------------------------------- * main - *------------------------------------------------------------------------- */ int main(int argc, char **argv) { struct timeval td; unsigned long addr_tmp; const char *port_name = NULL,*tos = NULL; int c; double mbps; int no_check = 0; if (argc < 2) goto usage; while ((c = getopt(argc, argv, "adrstuvBDTb:f:l:n:p:P:S:A:O:C")) != -1) { switch (c) { case 'a': atm = udp = 1; break; case 'B': b_flag = 1; break; case 't': trans = 1; break; case 'r': trans = 0; break; case 'C': no_check = 1; break; case 'd': options |= SO_DEBUG; break; case 'D': #ifdef TCP_NODELAY nodelay = 1; #else fprintf(stderr, "ttcp: -D option ignored: TCP_NODELAY socket option not supported\n"); #endif break; case 'n': nbuf = atoi(optarg); break; case 'l': buflen = atoi(optarg); break; case 's': sinkmode = !sinkmode; break; case 'p': port_name = optarg; break; case 'P': qos_spec = optarg; break; case 'S': tos = optarg; break; case 'u': udp = 1; break; case 'v': verbose = 1; break; case 'A': bufalign = atoi(optarg); break; case 'O': bufoffset = atoi(optarg); break; case 'b': #if defined(SO_SNDBUF) || defined(SO_RCVBUF) sockbufsize = atoi(optarg); #else fprintf(stderr, "ttcp: -b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported\n"); #endif break; case 'f': fmt = *optarg; break; case 'T': touchdata = 1; break; default: goto usage; } } if (port_name) { if (atm) { goto usage; } else { struct servent *se; se = getservbyname(port_name,udp ? "udp" : "tcp"); if (se) port = ntohs(se->s_port); else { char *end; port = strtoul(port_name,&end,0); if (*end) goto usage; } } } host = argv[optind]; if (atm) { char *end; memset(&satm,0,sizeof(satm)); if (!host) satm.sas_family = AF_ATMSVC; else if (text2atm(host,(struct sockaddr *) &satm, sizeof(satm),T2A_PVC | T2A_SVC | T2A_NAME) < 0) { fprintf(stderr,"invalid ATM address (PVC or SVC expected)\n"); exit(1); } memset(&qos,0,sizeof(qos)); qos.rxtp.max_sdu = qos.txtp.max_sdu = buflen; if (qos_spec && ((pcr = strtol(qos_spec,&end,10)), *end)) { if (text2qos(qos_spec,&qos,T2Q_DEFAULTS) < 0) { fprintf(stderr,"invalid QOS specification\n"); exit(1); } } else { if (!qos_spec) pcr = 0; if (!trans) qos.rxtp.traffic_class = ATM_UBR; else if (!pcr) qos.txtp.traffic_class = ATM_UBR; else { qos.txtp.traffic_class = ATM_CBR; qos.txtp.max_pcr = pcr; } } if (!qos.aal) qos.aal = ATM_AAL5; } if (!atm && trans) { /* xmitr */ if (optind == argc) goto usage; bzero((char *)&sinhim, sizeof(sinhim)); if (atoi(host) > 0 ) { /* Numeric */ sinhim.sin_family = AF_INET; #if defined(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); #if defined(cray) sinhim.sin_addr = addr_tmp; #else sinhim.sin_addr.s_addr = addr_tmp; #endif /* cray */ } sinhim.sin_port = htons(port); sinme.sin_port = 0; /* free choice */ } else { /* rcvr */ sinme.sin_port = htons(port); } if (udp && buflen < 5) { buflen = 5; /* send more than the sentinel size */ } if ((buf = (char *)malloc(buflen+bufalign)) == (char *)NULL) err("malloc"); if (bufalign != 0) buf +=(bufalign - ((int)buf % bufalign) + bufoffset) % bufalign; if (trans) { fprintf(stdout, "ttcp-t: buflen=%d, nbuf=%d, align=%d/%d, port=%d", buflen, nbuf, bufalign, bufoffset, port); if (sockbufsize) fprintf(stdout, ", sockbufsize=%d", sockbufsize); fprintf(stdout, " %s -> %s\n", atm?"atm":udp?"udp":"tcp", host); } else { fprintf(stdout, "ttcp-r: buflen=%d, nbuf=%d, align=%d/%d, port=%d", buflen, nbuf, bufalign, bufoffset, port); if (sockbufsize) fprintf(stdout, ", sockbufsize=%d", sockbufsize); fprintf(stdout, " %s\n", atm?"atm":udp?"udp":"tcp"); } if ((fd = socket(atm ? satm.sas_family : AF_INET, udp?SOCK_DGRAM:SOCK_STREAM,0)) < 0) err("socket"); mes("socket"); if (atm) { if (setsockopt(fd,SOL_ATM,SO_ATMQOS,&qos,sizeof(qos)) < 0) err("setsockopt SO_ATMQOS"); } else if (setsockopt(fd, SOL_SOCKET, SO_NO_CHECK, &no_check, sizeof(long)) < 0) err("setsockopt: no_check"); #ifdef SO_ATMSAP if (atm && satm.sas_family == AF_ATMSVC) { struct atm_sap sap; memset(&sap,0,sizeof(sap)); sap.bhli.hl_type = ATM_HL_VENDOR; sap.bhli.hl_length = 7; memcpy(sap.bhli.hl_info,TTCP_HLT_VS_ID,7); if (setsockopt(fd,SOL_ATM,SO_ATMSAP,&sap,sizeof(sap)) < 0) err("setsockopt SO_ATMSAP"); } #endif if (!atm || satm.sas_family == AF_ATMPVC || !trans) if (bind(fd, atm ? (struct sockaddr *) &satm : (struct sockaddr *) &sinme, atm ? satm.sas_family == AF_ATMPVC ? sizeof(struct sockaddr_atmpvc) : sizeof(struct sockaddr_atmsvc) : sizeof(sinme)) < 0) err("bind"); if (!udp || (atm && satm.sas_family == AF_ATMSVC)) { signal(SIGPIPE, sigpipe); if (trans) { /* We are the client if transmitting */ if (options) { #if defined(BSD42) if(setsockopt(fd, SOL_SOCKET, options, 0, 0) < 0) #else /* BSD43 */ if(setsockopt(fd, SOL_SOCKET, options, &one, sizeof(one)) < 0) #endif err("setsockopt"); } if (connect(fd, atm ? (struct sockaddr *) &satm : (struct sockaddr *) &sinhim, atm ? sizeof(satm) : sizeof(sinhim)) < 0) err("connect"); mes("connect"); #ifdef TCP_NODELAY if (nodelay) { struct protoent *p; p = getprotobyname("tcp"); if( p && setsockopt(fd, p->p_proto, TCP_NODELAY, &one, sizeof(one)) < 0) err("setsockopt: nodelay"); mes("nodelay"); } if (atm) sleep(1); /* grr ... */ #endif } else { /* otherwise, we are the server and * should listen for the connections */ #if defined(ultrix) || defined(sgi) || 1 listen(fd,1); /* workaround for alleged u4.2 bug */ #else listen(fd,0); /* allow a queue of 0 */ #endif fromlen = sizeof(frominet); domain = AF_INET; if ((fd=accept(fd, (struct sockaddr *) &frominet, &fromlen) ) < 0) err("accept"); { struct sockaddr_atmsvc peer; socklen_t peerlen = sizeof(peer); if (getpeername(fd, (struct sockaddr *) &peer, &peerlen) < 0) { err("getpeername"); } if (atm) { char name[MAX_ATM_ADDR_LEN+1]; if (atm2text(name,MAX_ATM_ADDR_LEN+1,(struct sockaddr *) &peer,/* A2T_NAME | */ A2T_PRETTY) < 0) strcpy(name,""); fprintf(stderr,"ttcp-r: accept from %s\n",name); } else fprintf(stderr,"ttcp-r: accept from %s\n", inet_ntoa(((struct sockaddr_in *) &peer)-> sin_addr)); } if (options) { #if defined(BSD42) if (setsockopt(fd, SOL_SOCKET, options, 0, 0) < 0) #else /* BSD43 */ if (setsockopt(fd, SOL_SOCKET, options, &one, sizeof(one)) < 0) #endif err("setsockopt"); } } } /* set socket buffer size */ #if defined(SO_SNDBUF) || defined(SO_RCVBUF) if (sockbufsize) { socklen_t len; if (trans) { /* set send socket buffer if we are transmitting */ if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sockbufsize, sizeof sockbufsize) < 0) err("setsockopt: sndbuf"); len = sizeof sockbufsize; if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sockbufsize, &len) < 0) perror("getsockopt: sndbuf"); mes("sndbuf"); } else { /* set receive socket buffer if we are receiving */ if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &sockbufsize, sizeof sockbufsize) < 0) err("setsockopt: rcvbuf"); len = sizeof sockbufsize; if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &sockbufsize, &len) < 0) perror("getsockopt: rcvbuf"); mes("rcvbuf"); } printf("real buffer size = %d\n",sockbufsize); } #endif if (tos) { unsigned char tos_value; tos_value = strtoul(tos,NULL,0); if (setsockopt(fd,SOL_IP,IP_TOS,&tos_value,1) < 0) err("setsockopt IP_TOS"); } errno = 0; if (sinkmode) { register int cnt; if (trans) { pattern(buf, buflen); /* construct a data pattern */ if (udp) (void)Nwrite(fd, buf, 4); /* rcvr start */ #ifdef CPU_USAGE prep_timer(); /* start timer */ #else gettimeofday(&start_time, (struct timezone *)0); #endif while (nbuf-- && Nwrite(fd, buf, buflen) == buflen) nbytes += buflen; if (udp) (void)Nwrite(fd, buf, 4); /* rcvr end */ } else { /* receive mode */ if (udp) { while ((cnt = Nread(fd, buf, buflen)) > 0) { static int going = 0; if(cnt <= 4) { if (going) break; /* "EOF" */ going = 1; #ifdef CPU_USAGE prep_timer(); /* start timer */ #else gettimeofday(&start_time, (struct timezone *)0); #endif prep_timer(); } else { nbytes += cnt; } } } else { /* TCP */ #ifdef CPU_USAGE prep_timer(); /* start timer */ #else gettimeofday(&start_time, (struct timezone *)0); #endif while ((cnt=Nread(fd,buf,buflen)) > 0) { nbytes += cnt; } } } } else { /* not sink mode */ register int cnt; #ifdef CPU_USAGE prep_timer(); /* start timer */ #else gettimeofday(&start_time, (struct timezone *)0); #endif if (trans) { while((cnt = read(0, buf, buflen)) > 0 && Nwrite(fd,buf,cnt) == cnt) nbytes += cnt; } else { while((cnt = Nread(fd,buf,buflen)) > 0 && write(1,buf,cnt) == cnt) nbytes += cnt; } } if (errno) err("IO"); /* if TCP close the connection to make sure all the data sent */ if (!udp) close(fd); gettimeofday(&stop_time, (struct timezone *)0); /* Get real time */ tvsub(&td, &stop_time, &start_time); realt = (double)td.tv_sec + ((double)td.tv_usec / (double)1000000.0); #ifdef CPU_USAGE (void) read_timer(stats, sizeof(stats)); /* stop timer */ #endif if (udp && trans) { (void)Nwrite(fd, buf, 4); /* signal rcvr end */ (void)Nwrite(fd, buf, 4); /* rcvr end */ (void)Nwrite(fd, buf, 4); /* rcvr end */ (void)Nwrite(fd, buf, 4); /* rcvr end */ } if (cput <= 0.0) cput = 0.001; if (realt <= 0.0) realt = 0.001; mbps = (double)(nbytes * 8) / realt / 1000000.0; fprintf(stdout, "ttcp%s: %.0f bytes in %f real seconds = %s/sec (%f Mb/sec)\n", trans?"-t":"-r", nbytes, realt, outfmt((double)nbytes/realt), mbps); #ifdef CPU_USAGE fprintf(stdout,"ttcp%s: %s\n", trans?"-t":"-r", stats); #endif if (verbose) { fprintf(stdout, "ttcp%s: %.0f bytes in %.2f CPU seconds = %s/cpu sec\n", trans?"-t":"-r", nbytes, cput, outfmt((double)nbytes/cput)); fprintf(stdout, "ttcp%s: %ld I/O calls, msec/call = %.2f, calls/sec = %.2f\n", trans?"-t":"-r", numCalls, 1000.0 * realt/((double)numCalls), ((double)numCalls)/realt); fprintf(stdout, "ttcp%s: buffer address %#lx\n", trans?"-t":"-r", (unsigned long )buf); } if (udp && trans) sleep(1); exit(0); usage: fprintf(stderr, "%s", Usage); exit(1); } void err(const char *s) { int en = errno; fprintf(stderr,"ttcp%s: ", trans?"-t":"-r"); errno = en; perror(s); errno = en; fprintf(stderr,"errno=%d\n",errno); exit(1); } void mes(const char *s) { fprintf(stderr,"ttcp%s: %s\n", trans?"-t":"-r", s); } /*------------------------------------------------------------------------- * pattern - *------------------------------------------------------------------------- */ 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); } } char * outfmt(b) double b; { static char obuf[50]; switch (fmt) { case 'G': sprintf(obuf, "%f GB", b / 1024.0 / 1024.0 / 1024.0); break; default: case 'K': sprintf(obuf, "%f KB", b / 1024.0); break; case 'M': sprintf(obuf, "%f MB", b / 1024.0 / 1024.0); break; case 'g': sprintf(obuf, "%f Gbit", b * 8.0 / 1024.0 / 1024.0 / 1024.0); break; case 'k': sprintf(obuf, "%f Kbit", b * 8.0 / 1024.0); break; case 'm': sprintf(obuf, "%f Mbit", b * 8.0 / 1024.0 / 1024.0); break; } return obuf; } #if defined(SYSV) /*ARGSUSED*/ static getrusage(ignored, ru) int ignored; register struct rusage *ru; { struct tms buf; times(&buf); /* Assumption: HZ <= 2147 (LONG_MAX/1000000) */ ru->ru_stime.tv_sec = buf.tms_stime / HZ; ru->ru_stime.tv_usec = ((buf.tms_stime % HZ) * 1000000) / HZ; ru->ru_utime.tv_sec = buf.tms_utime / HZ; ru->ru_utime.tv_usec = ((buf.tms_utime % HZ) * 1000000) / HZ; } /*ARGSUSED*/ static gettimeofday(tp, zp) struct timeval *tp; struct timezone *zp; { tp->tv_sec = time(0); tp->tv_usec = 0; } #endif /* SYSV */ /* * P R E P _ T I M E R */ void prep_timer(void) { gettimeofday(&start_time, (struct timezone *)0); getrusage(RUSAGE_SELF, &ru0); } /*------------------------------------------------------------------------- * read_timer - *------------------------------------------------------------------------- */ double read_timer(str,len) char *str; int len; { struct rusage ru1; struct timeval tend, tstart, td; char line[132]; getrusage(RUSAGE_SELF, &ru1); prusage(&ru0, &ru1, &stop_time, &start_time, line); (void)strncpy( str, line, len ); /* 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 ); } 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++;} #if defined(SYSV) cp = "%Uuser %Ssys %Ereal %P"; #else #if defined(sgi) /* IRIX 3.3 will show 0 for %M,%F,%R,%C */ cp = "%Uuser %Ssys %Ereal %P %Mmaxrss %F+%Rpf %Ccsw"; #else cp = (char *) "%Uuser %Ssys %Ereal %P %Xi+%Dd %Mmaxrss %F+%Rpf %Ccsw"; #endif #endif 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,"%ld.%01ld", tdiff.tv_sec, tdiff.tv_usec/100000); END(outp); break; case 'S': tvsub(&tdiff, &r1->ru_stime, &r0->ru_stime); sprintf(outp,"%ld.%01ld", 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; #if !defined(SYSV) 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; #endif /* !SYSV */ } } *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; } /*------------------------------------------------------------------------- * tvsub - tdiff = t1 - t0 *------------------------------------------------------------------------- */ 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); } /* * N R E A D */ int Nread(_fd, _buf, count) int _fd; char *_buf; int count; { #if 0 struct sockaddr_in from; int len = sizeof(from); #endif register int cnt; if( udp ) { #if 0 cnt = recvfrom(_fd, _buf, count, 0, &from, &len ); #else cnt = recv(_fd, _buf, count, 0); #endif numCalls++; } else { if( b_flag ) cnt = mread( _fd, _buf, count ); /* fill buf */ else { cnt = read( _fd, _buf, count ); numCalls++; } if (touchdata && cnt > 0) { register int c = cnt, sum; register char *b = _buf; while (c--) sum += *b++; } } return(cnt); } /*------------------------------------------------------------------------- * Nwrite - *------------------------------------------------------------------------- */ int Nwrite(_fd, _buf, count) int _fd; char *_buf; int count; { register int cnt; if (udp) { again: if (atm) cnt = write(_fd, _buf, count); else cnt = sendto(_fd, _buf, count, 0, (struct sockaddr *) &sinhim, sizeof(sinhim)); numCalls++; if ( cnt<0 && errno == ENOBUFS ) { delay(18000); errno = 0; goto again; } } else { cnt = write(_fd, _buf, count); numCalls++; } if (cnt < 0) perror("WA:write"); return(cnt); } void delay(long us) { struct timeval tv; tv.tv_sec = 0; tv.tv_usec = us; (void)select( 1, (void *)0, (void *)0, (void *)0, &tv ); } /* * 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); numCalls++; 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); }