API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 5th, 2017
415
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.14 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. * T T C P . C
  3. *
  4. * Test TCP connection. Makes a connection on port 5001
  5. * and transfers fabricated buffers or data copied from stdin.
  6. *
  7. * Usable on 4.2, 4.3, and 4.1a systems by defining one of
  8. * BSD42 BSD43 (BSD41a)
  9. * Machines using System V with BSD sockets should define SYSV.
  10. *
  11. * Modified for operation under 4.2BSD, 18 Dec 84
  12. * T.C. Slattery, USNA
  13. * Minor improvements, Mike Muuss and Terry Slattery, 16-Oct-85.
  14. * Modified in 1989 at Silicon Graphics, Inc.
  15. * catch SIGPIPE to be able to print stats when receiver has died
  16. * for tcp, don't look for sentinel during reads to allow small transfers
  17. * increased default buffer size to 8K, nbuf to 2K to transfer 16MB
  18. * moved default port to 5001, beyond IPPORT_USERRESERVED
  19. * make sinkmode default because it is more popular,
  20. * -s now means don't sink/source
  21. * count number of read/write system calls to see effects of
  22. * blocking from full socket buffers
  23. * for tcp, -D option turns off buffered writes (sets TCP_NODELAY sockopt)
  24. * buffer alignment options, -A and -O
  25. * print stats in a format that's a bit easier to use with grep & awk
  26. * for SYSV, mimic BSD routines to use most of the existing timing code
  27. * Modified by Steve Miller of the University of Maryland, College Park
  28. * -b sets the socket buffer size (SO_SNDBUF/SO_RCVBUF)
  29. * Modified Sept. 1989 at Silicon Graphics, Inc.
  30. * restored -s sense at request of tcs@brl
  31. * Modified Oct. 1991 at Silicon Graphics, Inc.
  32. * use getopt(3) for option processing, add -f and -T options.
  33. * SGI IRIX 3.3 and 4.0 releases don't need #define SYSV.
  34. *
  35. * Modified Jul 2001 by Pekka Savola <pekkas@netcore.fi>
  36. * implement full IPv6 support (server uses ipv6 mapped addresses for ipv4)
  37. * fix a few warnings (from *BSD)
  38. * fix loads of more warnings
  39. * use snprintf with a few fixed-sized buffers, fix format strings
  40. *
  41. * Modified Oct 2001 by Jaakko Kyr� <jkyro@cs.helsinki.fi>
  42. * Added -I option to specify network interface
  43. *
  44. * Modified Oct 2002 by Pekka Savola <pekkas@netcore.fi>
  45. * fix port selection for >2^15
  46. * clean out _cray, sysv etc. cruft, always build with IPv6
  47. * major cleanups, should be a bit more readable now
  48. *
  49. * Modified Oct 2002 by Stig Venaas <venaas@uninett.no>
  50. * added multicast support
  51. * added -w option to specify microsecond delay between each write
  52. * further cleanups
  53. *
  54. * Modified Oct 2002 by Pekka Savola <pekkas@netcore.fi>
  55. * made one variable 'static' to fix compilation on Solaris from <sleinen@switch.ch>
  56. *
  57. * Modified Aug 2004 by Stig Venaas <venaas@uninett.no>
  58. * Binding to group address when receiving multicast
  59. * Added SO_REUSEADDR so multiple processes can listen to same port
  60. *
  61. * Modified Dec 2007 by Pekka Savola <pekkas@netcore.fi>
  62. * Add error/warning message fixes from Niklas Edmundsson
  63. * Some other cleanups as well.
  64. *
  65. * Distribution Status -
  66. * Public Domain. Distribution Unlimited.
  67. */
  68. #ifndef lint
  69. static const char RCSid[] = "ttcp.c $Revision: 1.12 $";
  70. #endif
  71.  
  72. #include <sys/types.h>
  73. #include <sys/socket.h>
  74. #include <sys/time.h> /* struct timeval */
  75. #include <sys/resource.h>
  76. #include <net/if.h>
  77. #include <netinet/in.h>
  78. #include <netinet/tcp.h>
  79. #include <arpa/inet.h>
  80.  
  81. #include <ctype.h>
  82. #include <errno.h>
  83. #include <netdb.h>
  84. #include <signal.h>
  85. #include <stdio.h>
  86. #include <stdlib.h>
  87. #include <string.h>
  88. #include <unistd.h>
  89.  
  90. struct sockaddr_storage frominet;
  91. struct addrinfo hints, *res, *res0;
  92. struct ipv6_mreq mreq6;
  93. struct ip_mreq mreq;
  94.  
  95. socklen_t fromlen;
  96. int fd; /* fd of network socket */
  97.  
  98. int buflen = 8 * 1024; /* length of buffer */
  99. char *buf; /* ptr to dynamic buffer */
  100. int nbuf = 2 * 1024; /* number of buffers to send in sinkmode */
  101.  
  102. int bufoffset = 0; /* align buffer to this */
  103. int bufalign = 16*1024; /* modulo this */
  104.  
  105. int udp = 0; /* 0 = tcp, !0 = udp */
  106. int options = 0; /* socket options */
  107. int one = 1; /* for 4.3 BSD style setsockopt() */
  108. char *port = "5001"; /* TCP/UDP port number */
  109. char *host; /* ptr to name of host */
  110. int trans; /* 0=receive, !0=transmit mode */
  111. int sinkmode = 0; /* 0=normal I/O, !0=sink/source mode */
  112. int verbose = 0; /* 0=print basic info, 1=print cpu rate, proc
  113. * resource usage. */
  114. int nodelay = 0; /* set TCP_NODELAY socket option */
  115. int b_flag = 0; /* use mread() */
  116. int sockbufsize = 0; /* socket buffer size to use */
  117. char fmt = 'K'; /* output format: k = kilobits, K = kilobytes,
  118. * m = megabits, M = megabytes,
  119. * g = gigabits, G = gigabytes */
  120. int touchdata = 0; /* access data after reading */
  121. static long wrwait = 0; /* usecs to wait between each write */
  122. int af = AF_UNSPEC; /* Address family to be determined */
  123.  
  124. extern int errno;
  125. extern int optind;
  126. extern char *optarg;
  127.  
  128. char Usage[] = "\
  129. Usage: ttcp -t [-options] host [ < in ]\n\
  130. ttcp -r [-options] [multicast-group][ > out]\n\
  131. Common options:\n\
  132. -4 use IPv4\n\
  133. -6 use IPv6\n\
  134. -l ## length of bufs read from or written to network (default 8192)\n\
  135. -u use UDP instead of TCP\n\
  136. -p ## port number to send to or listen at (default 5001)\n\
  137. -s -t: source a pattern to network\n\
  138. -r: sink (discard) all data from network\n\
  139. -A ## align the start of buffers to this modulus (default 16384)\n\
  140. -O ## start buffers at this offset from the modulus (default 0)\n\
  141. -v verbose: print more statistics\n\
  142. -d set SO_DEBUG socket option\n\
  143. -b ## set socket buffer size (if supported)\n\
  144. -f X format for rate: k,K = kilo{bit,byte}; m,M = mega; g,G = giga\n\
  145. Options specific to -t:\n\
  146. -n ## number of source bufs written to network (default 2048)\n\
  147. -D don't buffer TCP writes (sets TCP_NODELAY socket option)\n\
  148. -w ## number of microseconds to wait between each write\n\
  149. Options specific to -r:\n\
  150. -B for -s, only output full blocks as specified by -l (for TAR)\n\
  151. -T \"touch\": access each byte as it's read\n\
  152. -I if Specify the network interface (e.g. eth0) to use\n\
  153. ";
  154.  
  155. char stats[128];
  156. double nbytes; /* bytes on net */
  157. unsigned long numCalls; /* # of I/O system calls */
  158. double cput, realt; /* user, real time (seconds) */
  159.  
  160. void err();
  161. void mes();
  162. void pattern();
  163. void prep_timer();
  164. double read_timer();
  165. int Nread();
  166. int Nwrite();
  167. void delay();
  168. int mread();
  169. char *outfmt();
  170.  
  171. int
  172. main(int argc, char **argv)
  173. {
  174. char *device = NULL;
  175. int maf = 0; /* Address family if multicast, else 0 */
  176. int c;
  177.  
  178. if (argc < 2) goto usage;
  179.  
  180. while ((c = getopt(argc, argv, "46drstuvBDTb:f:l:n:p:w:A:O:I:")) != -1) {
  181. switch (c) {
  182. case '4':
  183. af = AF_INET;
  184. break;
  185. case '6':
  186. af = AF_INET6;
  187. break;
  188. case 'I':
  189. device = optarg;
  190. break;
  191. case 'B':
  192. b_flag = 1;
  193. break;
  194. case 't':
  195. trans = 1;
  196. break;
  197. case 'r':
  198. trans = 0;
  199. break;
  200. case 'd':
  201. options |= SO_DEBUG;
  202. break;
  203. case 'D':
  204. #ifdef TCP_NODELAY
  205. nodelay = 1;
  206. #else
  207. fprintf(stderr,
  208. "ttcp: -D option ignored: TCP_NODELAY socket option not supported\n");
  209. #endif
  210. break;
  211. case 'n':
  212. nbuf = atoi(optarg);
  213. break;
  214. case 'l':
  215. buflen = atoi(optarg);
  216. break;
  217. case 's':
  218. sinkmode = !sinkmode;
  219. break;
  220. case 'p':
  221. port = optarg;
  222. break;
  223. case 'u':
  224. udp = 1;
  225. break;
  226. case 'v':
  227. verbose = 1;
  228. break;
  229. case 'w':
  230. wrwait = strtol(optarg, (char **)NULL, 10);
  231. break;
  232. case 'A':
  233. bufalign = atoi(optarg);
  234. break;
  235. case 'O':
  236. bufoffset = atoi(optarg);
  237. break;
  238. case 'b':
  239. #if defined(SO_SNDBUF) || defined(SO_RCVBUF)
  240. sockbufsize = atoi(optarg);
  241. #else
  242. fprintf(stderr,
  243. "ttcp: -b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported\n");
  244. #endif
  245. break;
  246. case 'f':
  247. fmt = *optarg;
  248. break;
  249. case 'T':
  250. touchdata = 1;
  251. break;
  252. default:
  253. goto usage;
  254. }
  255. }
  256.  
  257. memset(&hints, 0, sizeof(hints));
  258. hints.ai_family = af;
  259. hints.ai_socktype = udp ? SOCK_DGRAM : SOCK_STREAM;
  260.  
  261. if (trans) {
  262. /* xmitr */
  263. if (optind == argc)
  264. goto usage;
  265. host = argv[optind];
  266. if (getaddrinfo(host, port, &hints, &res) != 0) {
  267. fprintf(stderr, "can't resolve %s port %s\n", host, port);
  268. exit(1);
  269. }
  270.  
  271. if (udp) {
  272. /* Check if multicast address */
  273. if (res->ai_family == AF_INET6) {
  274. if (IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *)
  275. res->ai_addr)->sin6_addr)) {
  276. maf = AF_INET6;
  277. }
  278. } else if (res->ai_family == AF_INET) {
  279. if (IN_MULTICAST(ntohl(((struct sockaddr_in *)
  280. res->ai_addr)->sin_addr.s_addr))) {
  281. maf = AF_INET;
  282. }
  283. }
  284. }
  285. } else {
  286. /* rcvr */
  287. if (udp && optind < argc) {
  288. if (inet_pton(AF_INET, argv[optind], &mreq.imr_multiaddr) <= 0) {
  289. if (inet_pton(AF_INET6, argv[optind], &mreq6.ipv6mr_multiaddr) <= 0) {
  290. fprintf(stderr, "%s is not a multicast address\n", argv[optind]);
  291. exit(1);
  292. }
  293. /* IPv6 */
  294. if (!IN6_IS_ADDR_MULTICAST(&mreq6.ipv6mr_multiaddr)) {
  295. fprintf(stderr, "%s is not a multicast address\n", argv[optind]);
  296. exit(1);
  297. }
  298. hints.ai_family = AF_INET6;
  299. maf = AF_INET6;
  300. mreq6.ipv6mr_interface = 0;
  301. } else {
  302. /* IPv4 */
  303. if (!IN_MULTICAST(ntohl(mreq.imr_multiaddr.s_addr))) {
  304. fprintf(stderr, "%s is not a multicast address\n", argv[optind]);
  305. exit(1);
  306. }
  307. hints.ai_family = AF_INET;
  308. maf = AF_INET;
  309. mreq.imr_interface.s_addr = INADDR_ANY;
  310. }
  311. host = argv[optind];
  312. hints.ai_flags = AI_NUMERICHOST;
  313. } else {
  314. host = NULL;
  315. hints.ai_flags = AI_PASSIVE;
  316. }
  317. if (getaddrinfo(host, port, &hints, &res0) != 0) {
  318. fprintf(stderr, "can't resolve %s\n", port);
  319. exit(1);
  320. }
  321.  
  322. /* if libc supports ipv6 but kernel doesn't: get the first one */
  323. /* XXX: uses ipv6 mapped addresses as generic methods aren't there yet */
  324. for (res = res0; res; res = res->ai_next) {
  325. if ((fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) > 0)
  326. break;
  327. }
  328. }
  329.  
  330. if (udp && buflen < 5) {
  331. buflen = 5; /* send more than the sentinel size */
  332. }
  333.  
  334. if ((buf = (char *)malloc(buflen+bufalign)) == (char *)NULL)
  335. err("malloc");
  336. if (bufalign != 0)
  337. buf +=(bufalign - ((long)buf % bufalign) + bufoffset) % bufalign;
  338.  
  339. if (trans) {
  340. fprintf(stderr, "ttcp-t: buflen=%d, nbuf=%d, align=%d/%d, port=%s",
  341. buflen, nbuf, bufalign, bufoffset, port);
  342. if (sockbufsize)
  343. fprintf(stderr, ", sockbufsize=%d", sockbufsize);
  344. fprintf(stderr, " %s -> %s\n", udp ? "udp" : "tcp", host);
  345. } else {
  346. fprintf(stderr, "ttcp-r: buflen=%d, nbuf=%d, align=%d/%d, port=%s",
  347. buflen, nbuf, bufalign, bufoffset, port);
  348. if (sockbufsize)
  349. fprintf(stderr, ", sockbufsize=%d", sockbufsize);
  350. fprintf(stderr, " %s\n", udp ? "udp" : "tcp");
  351. }
  352.  
  353. if (!fd) {
  354. if ((fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) < 0)
  355. err("socket");
  356. }
  357.  
  358. if (device) {
  359. if (maf == AF_INET) {
  360. /* Not supported, using struct ip_mreq we need to find IP
  361. * address of interface, at least linux has ip_mreqn which
  362. * uses interface index
  363. */
  364. } else if (maf == AF_INET6) {
  365. if ((mreq6.ipv6mr_interface = if_nametoindex(device)) == 0) {
  366. err("unknown device");
  367. }
  368. } else {
  369. struct ifreq ifr;
  370. memset(&ifr, 0, sizeof(ifr));
  371. strncpy(ifr.ifr_name, device, IFNAMSIZ-1);
  372. ifr.ifr_name[IFNAMSIZ-1] = '\0';
  373. #ifdef SO_BINDTODEVICE
  374. if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr,sizeof(ifr)) == -1) {
  375. err("bind-to-device");
  376. }
  377. #else
  378. fprintf(stderr, "ttcp: warning: setting device not supported!\n");
  379. #endif
  380. }
  381. }
  382. mes("socket");
  383.  
  384. if (maf == AF_INET) {
  385. if (trans) {
  386. /* set hop limit, default 1. Should perhaps be an option */
  387. int ttl=30;
  388. setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, (char *)&ttl, sizeof(ttl));
  389. } else {
  390. /* join the group */
  391. setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
  392. }
  393. } else if (maf == AF_INET6) {
  394. if (trans) {
  395. /* set hop limit, default 1. Should perhaps be an option */
  396. int hops=30;
  397. setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, sizeof(hops));
  398. } else {
  399. /* join the group */
  400. setsockopt(fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq6, sizeof(mreq6));
  401. }
  402. }
  403.  
  404. if (!trans) {
  405. #ifdef SO_REUSEADDR
  406. if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) == -1)
  407. err("reuseaddr");
  408. #endif
  409. if (bind(fd, res->ai_addr, res->ai_addrlen) < 0)
  410. err("bind");
  411. }
  412.  
  413. #if defined(SO_SNDBUF) || defined(SO_RCVBUF)
  414. if (sockbufsize) {
  415. if (trans) {
  416. if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sockbufsize,
  417. sizeof sockbufsize) < 0)
  418. err("setsockopt: sndbuf");
  419. mes("sndbuf");
  420. } else {
  421. if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &sockbufsize,
  422. sizeof sockbufsize) < 0)
  423. err("setsockopt: rcvbuf");
  424. mes("rcvbuf");
  425. }
  426. }
  427. #endif
  428.  
  429. if (!udp) {
  430. signal(SIGPIPE, SIG_IGN);
  431. if (trans) {
  432. /* We are the client if transmitting */
  433. if (options) {
  434. if (setsockopt(fd, SOL_SOCKET, options, &one, sizeof(one)) < 0)
  435. err("setsockopt");
  436. }
  437. #ifdef TCP_NODELAY
  438. if (nodelay) {
  439. struct protoent *p;
  440. p = getprotobyname("tcp");
  441. if (p && setsockopt(fd, p->p_proto, TCP_NODELAY,
  442. &one, sizeof(one)) < 0)
  443. err("setsockopt: nodelay");
  444. mes("nodelay");
  445. }
  446. #endif
  447. if (connect(fd, res->ai_addr, res->ai_addrlen) < 0)
  448. err("connect");
  449. mes("connect");
  450. } else {
  451. /* otherwise, we are the server and
  452. * should listen for the connections
  453. */
  454. listen(fd, 0); /* allow a queue of 0 */
  455. if (options) {
  456. if (setsockopt(fd, SOL_SOCKET, options, &one, sizeof(one)) < 0)
  457. err("setsockopt");
  458. }
  459. fromlen = sizeof(frominet);
  460.  
  461. if ((fd = accept(fd, (struct sockaddr*)&frominet, &fromlen)) < 0)
  462. err("accept");
  463. {
  464. struct sockaddr_storage peer;
  465. char addr_buf[NI_MAXHOST];
  466. socklen_t peerlen = sizeof(peer);
  467.  
  468. if (getpeername(fd, (struct sockaddr*) &peer, &peerlen) < 0)
  469. err("getpeername");
  470. if (getnameinfo((struct sockaddr *) &peer, res->ai_addrlen, addr_buf,
  471. sizeof(addr_buf), NULL, 0, NI_NUMERICHOST))
  472. err("getnameinfo");
  473. fprintf(stderr,"ttcp-r: accept from %s\n", addr_buf);
  474. }
  475. }
  476. }
  477. prep_timer();
  478. errno = 0;
  479. if (sinkmode) {
  480. register int cnt;
  481. if (trans) {
  482. pattern(buf, buflen);
  483. if (udp)
  484. (void)Nwrite(fd, buf, 4); /* rcvr start */
  485. while (nbuf-- && Nwrite(fd, buf, buflen) == buflen)
  486. nbytes += buflen;
  487. if (udp)
  488. (void)Nwrite(fd, buf, 4); /* rcvr end */
  489. } else {
  490. if (udp) {
  491. while ((cnt = Nread(fd, buf, buflen)) > 0) {
  492. static int going = 0;
  493. if (cnt <= 4) {
  494. if (going)
  495. break; /* "EOF" */
  496. going = 1;
  497. prep_timer();
  498. } else
  499. nbytes += cnt;
  500. }
  501. } else {
  502. while ((cnt = Nread(fd, buf, buflen)) > 0) {
  503. nbytes += cnt;
  504. }
  505. }
  506. }
  507. } else {
  508. register int cnt;
  509. if (trans) {
  510. while ((cnt = read(0, buf, buflen)) > 0 &&
  511. Nwrite(fd, buf, cnt) == cnt)
  512. nbytes += cnt;
  513. } else {
  514. while ((cnt = Nread(fd, buf, buflen)) > 0 &&
  515. write(1, buf, cnt) == cnt)
  516. nbytes += cnt;
  517. }
  518. }
  519. if (errno)
  520. err("IO");
  521. (void)read_timer(stats, sizeof(stats));
  522. if (udp && trans) {
  523. (void)Nwrite(fd, buf, 4); /* rcvr end */
  524. (void)Nwrite(fd, buf, 4); /* rcvr end */
  525. (void)Nwrite(fd, buf, 4); /* rcvr end */
  526. (void)Nwrite(fd, buf, 4); /* rcvr end */
  527. }
  528. if (cput <= 0.0)
  529. cput = 0.001;
  530. if (realt <= 0.0)
  531. realt = 0.001;
  532. fprintf(stderr,
  533. "ttcp%s: %.0f bytes in %.2f real seconds = %s/sec +++\n",
  534. trans ? "-t" : "-r",
  535. nbytes, realt, outfmt(nbytes/realt));
  536. if (verbose) {
  537. fprintf(stderr,
  538. "ttcp%s: %.0f bytes in %.2f CPU seconds = %s/cpu sec\n",
  539. trans ? "-t" : "-r",
  540. nbytes, cput, outfmt(nbytes/cput));
  541. }
  542. fprintf(stderr,
  543. "ttcp%s: %ld I/O calls, msec/call = %.2f, calls/sec = %.2f\n",
  544. trans ? "-t" : "-r",
  545. numCalls,
  546. 1024.0 * realt/((double)numCalls),
  547. ((double)numCalls)/realt);
  548. fprintf(stderr, "ttcp%s: %s\n", trans ? "-t" : "-r", stats);
  549. if (verbose) {
  550. fprintf(stderr,
  551. "ttcp%s: buffer address %p\n",
  552. trans ? "-t" : "-r",
  553. buf);
  554. }
  555. exit(0);
  556.  
  557. usage:
  558. fprintf(stderr, "%s", Usage);
  559. exit(1);
  560. }
  561.  
  562. void
  563. err(char *s)
  564. {
  565. fprintf(stderr, "ttcp%s: ", trans ? "-t" : "-r");
  566. perror(s);
  567. fprintf(stderr, "errno=%d\n", errno);
  568. exit(1);
  569. }
  570.  
  571. void
  572. mes(char *s)
  573. {
  574. fprintf(stderr, "ttcp%s: %s\n", trans ? "-t" : "-r", s);
  575. }
  576.  
  577. void
  578. pattern(register char *cp, register int cnt)
  579. {
  580. register char c;
  581. c = 0;
  582. while (cnt-- > 0) {
  583. while (!isprint((c&0x7F))) c++;
  584. *cp++ = (c++&0x7F);
  585. }
  586. }
  587.  
  588. char *
  589. outfmt(double b)
  590. {
  591. static char obuf[50];
  592. switch (fmt) {
  593. case 'G':
  594. snprintf(obuf, sizeof(obuf), "%.2f GB", b / 1024.0 / 1024.0 / 1024.0);
  595. break;
  596. default:
  597. case 'K':
  598. snprintf(obuf, sizeof(obuf), "%.2f KB", b / 1024.0);
  599. break;
  600. case 'M':
  601. snprintf(obuf, sizeof(obuf), "%.2f MB", b / 1024.0 / 1024.0);
  602. break;
  603. case 'g':
  604. snprintf(obuf, sizeof(obuf), "%.2f Gbit", b * 8.0 / 1024.0 / 1024.0 / 1024.0);
  605. break;
  606. case 'k':
  607. snprintf(obuf, sizeof(obuf), "%.2f Kbit", b * 8.0 / 1024.0);
  608. break;
  609. case 'm':
  610. snprintf(obuf, sizeof(obuf), "%.2f Mbit", b * 8.0 / 1024.0 / 1024.0);
  611. break;
  612. }
  613. return obuf;
  614. }
  615.  
  616. static struct timeval time0; /* Time at which timing started */
  617. static struct rusage ru0; /* Resource utilization at the start */
  618.  
  619. static void prusage();
  620. static void tvadd();
  621. static void tvsub();
  622. static void psecs();
  623.  
  624. /*
  625. * P R E P _ T I M E R
  626. */
  627. void
  628. prep_timer()
  629. {
  630. gettimeofday(&time0, (struct timezone *)0);
  631. getrusage(RUSAGE_SELF, &ru0);
  632. }
  633.  
  634. /*
  635. * R E A D _ T I M E R
  636. *
  637. */
  638. double
  639. read_timer(char *str, int len)
  640. {
  641. struct timeval timedol;
  642. struct rusage ru1;
  643. struct timeval td;
  644. struct timeval tend, tstart;
  645. char line[132];
  646.  
  647. getrusage(RUSAGE_SELF, &ru1);
  648. gettimeofday(&timedol, (struct timezone *)0);
  649. prusage(&ru0, &ru1, &timedol, &time0, line);
  650. /* XXX: buffer overflow if len > sizeof(line) */
  651. (void)strncpy(str, line, len);
  652.  
  653. /* Get real time */
  654. tvsub(&td, &timedol, &time0);
  655. realt = td.tv_sec + ((double)td.tv_usec) / 1000000;
  656.  
  657. /* Get CPU time (user+sys) */
  658. tvadd(&tend, &ru1.ru_utime, &ru1.ru_stime);
  659. tvadd(&tstart, &ru0.ru_utime, &ru0.ru_stime);
  660. tvsub(&td, &tend, &tstart);
  661. cput = td.tv_sec + ((double)td.tv_usec) / 1000000;
  662. if (cput < 0.00001)
  663. cput = 0.00001;
  664. return(cput);
  665. }
  666.  
  667. static void
  668. prusage(register struct rusage *r0, register struct rusage *r1,
  669. struct timeval *e, struct timeval *b, char *outp)
  670. {
  671. struct timeval tdiff;
  672. register time_t t;
  673. register char *cp;
  674. register int i;
  675. int ms;
  676.  
  677. t = (r1->ru_utime.tv_sec-r0->ru_utime.tv_sec)*100+
  678. (r1->ru_utime.tv_usec-r0->ru_utime.tv_usec)/10000+
  679. (r1->ru_stime.tv_sec-r0->ru_stime.tv_sec)*100+
  680. (r1->ru_stime.tv_usec-r0->ru_stime.tv_usec)/10000;
  681. ms = (e->tv_sec-b->tv_sec)*100 + (e->tv_usec-b->tv_usec)/10000;
  682.  
  683. #define END(x) {while(*x) x++;}
  684. cp = "%Uuser %Ssys %Ereal %P %Xi+%Dd %Mmaxrss %F+%Rpf %Ccsw";
  685. for (; *cp; cp++) {
  686. if (*cp != '%')
  687. *outp++ = *cp;
  688. else if (cp[1]) switch(*++cp) {
  689.  
  690. case 'U':
  691. tvsub(&tdiff, &r1->ru_utime, &r0->ru_utime);
  692. sprintf(outp, "%ld.%01ld", tdiff.tv_sec, tdiff.tv_usec/100000);
  693. END(outp);
  694. break;
  695.  
  696. case 'S':
  697. tvsub(&tdiff, &r1->ru_stime, &r0->ru_stime);
  698. sprintf(outp, "%ld.%01ld", tdiff.tv_sec, tdiff.tv_usec/100000);
  699. END(outp);
  700. break;
  701.  
  702. case 'E':
  703. psecs(ms / 100, outp);
  704. END(outp);
  705. break;
  706.  
  707. case 'P':
  708. sprintf(outp, "%d%%", (int) (t*100 / ((ms ? ms : 1))));
  709. END(outp);
  710. break;
  711.  
  712. case 'W':
  713. i = r1->ru_nswap - r0->ru_nswap;
  714. sprintf(outp, "%d", i);
  715. END(outp);
  716. break;
  717.  
  718. case 'X':
  719. sprintf(outp, "%ld", t == 0 ? 0 : (r1->ru_ixrss-r0->ru_ixrss)/t);
  720. END(outp);
  721. break;
  722.  
  723. case 'D':
  724. sprintf(outp, "%ld", t == 0 ? 0 :
  725. (r1->ru_idrss+r1->ru_isrss-(r0->ru_idrss+r0->ru_isrss))/t);
  726. END(outp);
  727. break;
  728.  
  729. case 'K':
  730. sprintf(outp, "%ld", t == 0 ? 0 :
  731. ((r1->ru_ixrss+r1->ru_isrss+r1->ru_idrss) -
  732. (r0->ru_ixrss+r0->ru_idrss+r0->ru_isrss))/t);
  733. END(outp);
  734. break;
  735.  
  736. case 'M':
  737. sprintf(outp, "%ld", r1->ru_maxrss/2);
  738. END(outp);
  739. break;
  740.  
  741. case 'F':
  742. sprintf(outp, "%ld", r1->ru_majflt-r0->ru_majflt);
  743. END(outp);
  744. break;
  745.  
  746. case 'R':
  747. sprintf(outp, "%ld", r1->ru_minflt-r0->ru_minflt);
  748. END(outp);
  749. break;
  750.  
  751. case 'I':
  752. sprintf(outp, "%ld", r1->ru_inblock-r0->ru_inblock);
  753. END(outp);
  754. break;
  755.  
  756. case 'O':
  757. sprintf(outp, "%ld", r1->ru_oublock-r0->ru_oublock);
  758. END(outp);
  759. break;
  760. case 'C':
  761. sprintf(outp, "%ld+%ld", r1->ru_nvcsw-r0->ru_nvcsw,
  762. r1->ru_nivcsw-r0->ru_nivcsw );
  763. END(outp);
  764. break;
  765. }
  766. }
  767. *outp = '\0';
  768. }
  769.  
  770. static void
  771. tvadd(struct timeval *tsum, struct timeval *t0, struct timeval *t1)
  772. {
  773. tsum->tv_sec = t0->tv_sec + t1->tv_sec;
  774. tsum->tv_usec = t0->tv_usec + t1->tv_usec;
  775. if (tsum->tv_usec > 1000000)
  776. tsum->tv_sec++, tsum->tv_usec -= 1000000;
  777. }
  778.  
  779. static void
  780. tvsub(struct timeval *tdiff, struct timeval *t1, struct timeval *t0)
  781. {
  782. tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
  783. tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
  784. if (tdiff->tv_usec < 0)
  785. tdiff->tv_sec--, tdiff->tv_usec += 1000000;
  786. }
  787.  
  788. static void
  789. psecs(long l, register char *cp)
  790. {
  791. register int i;
  792.  
  793. i = l / 3600;
  794. if (i) {
  795. sprintf(cp, "%d:", i);
  796. END(cp);
  797. i = l % 3600;
  798. sprintf(cp, "%d%d", (i/60) / 10, (i/60) % 10);
  799. END(cp);
  800. } else {
  801. i = l;
  802. sprintf(cp, "%d", i / 60);
  803. END(cp);
  804. }
  805. i %= 60;
  806. *cp++ = ':';
  807. sprintf(cp, "%d%d", i / 10, i % 10);
  808. }
  809.  
  810. /*
  811. * N R E A D
  812. */
  813. int
  814. Nread(int fd, void *buf, int count)
  815. {
  816. struct sockaddr_in from;
  817. socklen_t len = sizeof(from);
  818. register int cnt;
  819. if (udp) {
  820. cnt = recvfrom(fd, buf, count, 0, (struct sockaddr *)&from, &len);
  821. numCalls++;
  822. } else {
  823. if (b_flag)
  824. cnt = mread(fd, buf, count); /* fill buf */
  825. else {
  826. cnt = read(fd, buf, count);
  827. numCalls++;
  828. }
  829. if (touchdata && cnt > 0) {
  830. register int c = cnt, sum = 0;
  831. register char *b = buf;
  832. while (c--)
  833. sum += *b++;
  834. }
  835. }
  836. return(cnt);
  837. }
  838.  
  839. /*
  840. * N W R I T E
  841. */
  842. int
  843. Nwrite(int fd, void *buf, int count)
  844. {
  845. register int cnt;
  846. if (udp) {
  847. again:
  848. cnt = sendto(fd, buf, count, 0, res->ai_addr, res->ai_addrlen);
  849. numCalls++;
  850. if (cnt<0 && errno == ENOBUFS) {
  851. delay(18000);
  852. errno = 0;
  853. goto again;
  854. }
  855. } else {
  856. cnt = write(fd, buf, count);
  857. numCalls++;
  858. }
  859. if (wrwait)
  860. delay(wrwait);
  861. return(cnt);
  862. }
  863.  
  864. void
  865. delay(int us)
  866. {
  867. struct timeval tv;
  868.  
  869. tv.tv_sec = 0;
  870. tv.tv_usec = us;
  871. (void)select(1, NULL, NULL, NULL, &tv);
  872. }
  873.  
  874. /*
  875. * M R E A D
  876. *
  877. * This function performs the function of a read(II) but will
  878. * call read(II) multiple times in order to get the requested
  879. * number of characters. This can be necessary because
  880. * network connections don't deliver data with the same
  881. * grouping as it is written with. Written by Robert S. Miles, BRL.
  882. */
  883. int
  884. mread(int fd, register char *bufp, unsigned int n)
  885. {
  886. register unsigned count = 0;
  887. register int nread;
  888.  
  889. do {
  890. nread = read(fd, bufp, n-count);
  891. numCalls++;
  892. if(nread < 0) {
  893. perror("ttcp_mread");
  894. return(-1);
  895. }
  896. if(nread == 0)
  897. return((int)count);
  898. count += (unsigned)nread;
  899. bufp += nread;
  900. } while(count < n);
  901.  
  902. return((int)count);
  903. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!