cons: disable dangerous conswrites()
[akaros.git] / tests / ttcp.c
index 3ce93d0..aa5e502 100644 (file)
@@ -14,7 +14,7 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. The author's name may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
- * 
+ *
  * This software is provided by the author AS IS.  The author DISCLAIMS
  * any and all warranties of merchantability and fitness for a particular
  * purpose.  In NO event shall the author be LIABLE for any damages
  *     - isochronous transfer
  */
 
-#include <u.h>
-#include <libc.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <parlib/net.h>
+#include <sys/time.h>
+#include <iplib/iplib.h>
+#include <parlib/timing.h>
 
 long ncalls;
 char scale;
 
-long
-nread(int fd, char* buf, long len)
+static void sysfatal(char *msg)
+{
+       perror(msg);
+       exit(-1);
+}
+
+long nread(int fd, char *buf, long len)
 {
        int cnt, rlen = 0;
-       char* b = buf;
+       char *b = buf;
+
        for (;;) {
                cnt = read(fd, b, len);
                ncalls++;
@@ -60,11 +74,11 @@ nread(int fd, char* buf, long len)
        return rlen;
 }
 
-long
-nwrite(int fd, char* buf, long len)
+long nwrite(int fd, char *buf, long len)
 {
        int cnt, rlen = 0;
-       char* b = buf;
+       char *b = buf;
+
        for (;;) {
                cnt = write(fd, b, len);
                ncalls++;
@@ -79,12 +93,12 @@ nwrite(int fd, char* buf, long len)
        return rlen;
 }
 
-void
-pattern(char* buf, int buflen)
+void pattern(char *buf, int buflen)
 {
        int i;
        char ch = ' ';
-       char* b = buf;
+       char *b = buf;
+
        for (i = 0; i < buflen; i++) {
                *b++ = ch++;
                if (ch == 127)
@@ -93,101 +107,108 @@ pattern(char* buf, int buflen)
 }
 
 char fmt = 'K';
-charunit;
+char *unit;
 
-double
-rate(vlong nbytes, double time)
+double rate(long nbytes, double time)
 {
        switch (fmt) {
        case 'k':
                unit = "Kbit";
-               return nbytes*8/time/(1<<10);
+               return nbytes * 8 / time / (1 << 10);
        case 'K':
                unit = "KB";
-               return nbytes/time/(1<<10);
+               return nbytes / time / (1 << 10);
        case 'm':
                unit = "Mbit";
-               return nbytes*8/time/(1<<20);
+               return nbytes * 8 / time / (1 << 20);
        case 'M':
                unit = "MB";
-               return nbytes/time/(1<<20);
+               return nbytes / time / (1 << 20);
        case 'g':
                unit = "Gbit";
-               return nbytes*8/time/(1<<30);
+               return nbytes * 8 / time / (1 << 30);
        case 'G':
                unit = "GB";
-               return nbytes/time/(1<<30);
+               return nbytes / time / (1 << 30);
        }
        return 0.0;
 }
 
-void
-reader(int udp, char* addr, char* port, int buflen, int nbuf, int sink)
+void reader(int udp, char *addr, char *port, int buflen, int nbuf, int sink)
 {
        char *buf, adir[40], ldir[40];
+       char *ds, ds_store[256];
        int fd, cnt, acfd, lcfd;
-       vlong nbytes = 0;
-       vlong now;
+       long nbytes = 0;
+       long now;
        double elapsed;
        int pd;
        char peer[100];
+       double tput;
 
+       fprintf(stderr, "ttcp-r: buflen=%d, nbuf=%d, port=%s %s\n",
+               buflen, nbuf, port, udp ? "udp" : "tcp");
 
-       print("ttcp-r: buflen=%d, nbuf=%d, port=%s %s\n",
-               buflen, nbuf, port, udp? "udp" : "tcp");
-
-       acfd = announce(netmkaddr(addr, udp? "udp": "tcp", port), adir);
-       if(acfd < 0)
+       ds = netmkaddr(addr, udp ? "udp" : "tcp", port, ds_store,
+                      sizeof(ds_store));
+       acfd = announce9(ds, adir, 0);
+       if (acfd < 0)
                sysfatal("announce: %r");
        buf = malloc(buflen);
 
-       lcfd = listen(adir, ldir);
-       if(lcfd < 0)
+       lcfd = listen9(adir, ldir, 0);
+       if (lcfd < 0)
                sysfatal("listen: %r");
 
-       fd = accept(lcfd, ldir);
-       if(fd < 0)
+       fd = accept9(lcfd, ldir);
+       if (fd < 0)
                return;
 
-       sprint(peer, "%s/remote", ldir);
-       pd = open(peer, OREAD);
+       sprintf(peer, "%s/remote", ldir);
+       pd = open(peer, O_READ);
        cnt = read(pd, peer, 100);
        close(pd);
 
-       print("ttcp-r: accept from %*.*s", cnt, cnt, peer);
+       fprintf(stderr, "ttcp-r: accept from %*.*s", cnt, cnt, peer);
        now = nsec();
        if (sink) {
-               while((cnt = nread(fd, buf, buflen)) > 0)
+               while ((cnt = nread(fd, buf, buflen)) > 0)
                        nbytes += cnt;
        } else {
-               while((cnt = nread(fd, buf, buflen)) > 0 &&
-                     write(1, buf, cnt) == cnt)
+               while ((cnt = nread(fd, buf, buflen)) > 0
+                      && write(1, buf, cnt) == cnt)
                        nbytes += cnt;
        }
-       elapsed = (nsec() - now)/1E9;
+       elapsed = (nsec() - now) / 1E9;
 
-       print("ttcp-r: %lld bytes in %.2f real seconds = %.2f %s/sec\n",
-             nbytes, elapsed, rate(nbytes, elapsed), unit);
+       tput = rate(nbytes, elapsed);   /* also sets 'unit' */
+       fprintf(stderr,
+               "ttcp-r: %lld bytes in %.2f real seconds = %.2f %s/sec\n",
+               nbytes, elapsed, tput, unit);
 }
 
-void
-writer(int udp, char* addr, char* port, int buflen, int nbuf, int src)
+void writer(int udp, char *addr, char *port, int buflen, int nbuf, int src)
 {
        char *buf;
        int fd, cnt;
-       vlong nbytes = 0;
-       vlong now;
+       long nbytes = 0;
+       long now;
        double elapsed;
+       char netaddr[128];
+       double tput;
 
-       print("ttcp-t: buflen=%d, nbuf=%d, port=%s %s -> %s\n",
-               buflen, nbuf, port, udp? "udp" : "tcp", addr);
+       fprintf(stderr, "ttcp-t: buflen=%d, nbuf=%d, port=%s %s -> %s\n",
+                   buflen, nbuf, port, udp ? "udp" : "tcp", addr);
 
        buf = malloc(buflen);
-       fd = dial(netmkaddr(addr, udp? "udp" : "tcp", port), 0, 0, 0);
-       if(fd < 0)
+       snprintf(netaddr, sizeof(netaddr), "%s!%s!%s",
+                udp ? "udp" : "tcp", addr, port);
+       fprintf(stderr, "dialing %s\n", netaddr);
+       fd = dial9(netaddr, 0, 0, 0, 0);
+       if (fd < 0)
                sysfatal("dial: %r");
 
-       print("ttcp-t: connect\n");
+       fprintf(stderr, "ttcp-t: connect\n");
 
        now = nsec();
        if (src) {
@@ -195,86 +216,85 @@ writer(int udp, char* addr, char* port, int buflen, int nbuf, int src)
                while (nbuf-- && nwrite(fd, buf, buflen) == buflen)
                        nbytes += buflen;
        } else {
-               while ((cnt = read(0, buf, buflen)) > 0 &&
-                      nwrite(fd, buf, cnt) == cnt)
+               while ((cnt = read(0, buf, buflen)) > 0
+                      && nwrite(fd, buf, cnt) == cnt)
                        nbytes += cnt;
        }
-       elapsed = (nsec() - now)/1E9;
+       elapsed = (nsec() - now) / 1E9;
 
-       print("ttcp-t: %lld bytes in %.2f real seconds = %.2f %s/sec\n",
-             nbytes, elapsed, rate(nbytes, elapsed), unit);
+       tput = rate(nbytes, elapsed);   /* also sets 'unit' */
+       fprintf(stderr,
+               "ttcp-t: %lld bytes in %.2f real seconds = %.2f %s/sec\n",
+               nbytes, elapsed, tput, unit);
 }
 
-void
-usage(void)
+void usage(void)
 {
-       print("usage:\tttcp -t [options] host\n"
+       fprintf(stderr, "usage:\tttcp -t [options] host\n"
              "\t\tttcp -r [options]\n"
              " options:\n"
-//           "  -D\t\don't delay tcp (nodelay option)\n"
              "  -f fmt\trate format: k,m,g,K,M,G = {kilo,mega,giga}{bit,byte}\n"
              "  -l\t\tlength of buf (default 8192)\n"
              "  -p port\tport number (default 5001)\n"
              "  -n num\tnumber of bufs written (default 2048)\n"
              "  -s\t\t-t: source a pattern to network\n"
-             "\t\t\-r: sink (discard) all data from network\n"
-//           "  -u\t\tuse UDP instead of TCP\n"
+             "\t\t-r: sink (discard) all data from network\n"
              );
-       exits(0);
+       exit(0);
 }
 
-void
-main(int argc, char *argv[])
+void main(int argc, char *argv[])
 {
        int buflen = 8192;
        int nbuf = 2048;
        int srcsink = 0;
-       charport = "5001";
+       char *port = "5001";
        int udp = 0;
-       enum {none, recv, xmit} mode = none;
-
-       ARGBEGIN {
-       case 'f':
-               fmt = EARGF(usage())[0];
-               break;
-       case 'l':
-               buflen = atoi(EARGF(usage()));
-               break;
-       case 'n':
-               nbuf = atoi(EARGF(usage()));
-               break;
-       case 'p':
-               port = EARGF(usage());
-               break;
-       case 'r':
-               mode = recv;
-               break;
-       case 's':
-               srcsink = 1;
-               break;
-       case 't':
-               mode = xmit;
-               break;
-       case 'u':
-               udp = 1;
-               break;
-       default:
-               usage();
-       } ARGEND;
+       enum { none, recv, xmit } mode = none;
+       char c;
 
-       USED(buflen);
+       while ((c = getopt(argc, argv, "rstuf:l:n:p:")) != -1) {
+               switch (c) {
+               case 'f':
+                       fmt = *optarg;
+                       break;
+               case 'l':
+                       buflen = atoi(optarg);
+                       break;
+               case 'n':
+                       nbuf = atoi(optarg);
+                       break;
+               case 'p':
+                       port = optarg;
+                       break;
+               case 'r':
+                       mode = recv;
+                       break;
+               case 's':
+                       srcsink = 1;
+                       break;
+               case 't':
+                       mode = xmit;
+                       break;
+               case 'u':
+                       udp = 1;
+                       break;
+               default:
+                       usage();
+               }
+       }
        switch (mode) {
        case none:
                usage();
                break;
        case xmit:
-               if (argv[0] == nil)
+               if (optind == argc)
                        usage();
-               writer(udp, argv[0], port, buflen, nbuf, srcsink);
+               writer(udp, argv[optind], port, buflen, nbuf, srcsink);
                break;
        case recv:
                reader(udp, "*", port, buflen, nbuf, srcsink);
                break;
        }
-       exits(0);
+       exit(0);
 }