mdw@git.distorted.org.uk Git - tripe/blob - uslip/uslip.c

   1 /* -*-c-*-
   2  *
   3  * A simple SLIP implementation drivable from the command-line
   4  *
   5  * (c) 2008 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of Trivial IP Encryption (TrIPE).
  11  *
  12  * TrIPE is free software: you can redistribute it and/or modify it under
  13  * the terms of the GNU General Public License as published by the Free
  14  * Software Foundation; either version 3 of the License, or (at your
  15  * option) any later version.
  16  *
  17  * TrIPE is distributed in the hope that it will be useful, but WITHOUT
  18  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20  * for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with TrIPE.  If not, see <https://www.gnu.org/licenses/>.
  24  */
  25
  26 /*----- Header files ------------------------------------------------------*/
  27
  28 #include "config.h"
  29
  30 #include <assert.h>
  31 #include <ctype.h>
  32 #include <errno.h>
  33 #include <signal.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include <sys/types.h>
  39 #include <sys/time.h>
  40 #include <unistd.h>
  41
  42 #include <sys/socket.h>
  43 #include <sys/un.h>
  44 #include <netinet/in.h>
  45 #include <arpa/inet.h>
  46 #include <netdb.h>
  47
  48 #include <mLib/alloc.h>
  49 #include <mLib/bits.h>
  50 #include <mLib/conn.h>
  51 #include <mLib/dstr.h>
  52 #include <mLib/fdflags.h>
  53 #include <mLib/mdwopt.h>
  54 #include <mLib/quis.h>
  55 #include <mLib/report.h>
  56 #include <mLib/sel.h>
  57 #include <mLib/sig.h>
  58 #include <mLib/sub.h>
  59 #include <mLib/tv.h>
  60
  61 #include "slip.h"
  62
  63 #undef sun
  64
  65 /*----- Data structures ---------------------------------------------------*/
  66
  67 typedef struct pkq_node {
  68   struct pkq_node *next;
  69   unsigned char *buf;
  70   size_t n, sz;
  71 } pkq_node;
  72
  73 typedef struct pkq {
  74   pkq_node *head, **tail;
  75 } pkq;
  76
  77 enum { START, OK, ESC, BAD, SYNC1, SYNC2 };
  78
  79 typedef struct client {
  80   sel_file f;
  81   dstr d;
  82   int mode;
  83 } client;
  84
  85 typedef struct gobbler {
  86   sel_file f;
  87   void (*done)(struct gobbler *, int, void *);
  88   void *p;
  89 } gobbler;
  90
  91 typedef struct dribbler {
  92   sel_file f;
  93   pkq q;
  94   void (*done)(struct dribbler *, int, void *);
  95   void *p;
  96 } dribbler;
  97
  98 typedef struct waiter {
  99   struct waiter *next;
 100   int fd;
 101   gobbler *g;
 102 } waiter;
 103
 104 /*----- Static variables --------------------------------------------------*/
 105
 106 static pkq q_in;
 107 static dribbler *dribble_out;
 108 static dstr slipbuf = DSTR_INIT;
 109 static int slipstate = SYNC1;
 110 static sel_file slip_in, listener;
 111 static sel_state sel;
 112 static unsigned reasons;
 113 static waiter *wait_head, **wait_tail = &wait_head;
 114 static unsigned char buf[16384];
 115 static const char *name;
 116
 117 /*----- Utilities ---------------------------------------------------------*/
 118
 119 static void socketaddr(struct sockaddr_un *sun, size_t *sz)
 120 {
 121   size_t n = strlen(name) + 1;
 122   if (n + offsetof(struct sockaddr_un, sun_path) > sizeof(*sun))
 123     die(EXIT_FAILURE, "name too long: `%s'", name);
 124   sun->sun_family = AF_UNIX;
 125   memcpy(sun->sun_path, name, n);
 126   if (sz)
 127     *sz = n + offsetof(struct sockaddr_un, sun_path);
 128 }
 129
 130 /*------ Packet queue -----------------------------------------------------*
 131  *
 132  * A packet queue contains a sequence of octet strings.  Packets can be added
 133  * to the end and read off the front.
 134  */
 135
 136 static void initqueue(pkq *q) { q->head = 0; q->tail = &q->head; }
 137
 138 static pkq_node *make_pkqnode(const void *p, size_t n)
 139 {
 140   pkq_node *pn;
 141
 142   if (!n) return (0);
 143   pn = CREATE(pkq_node);
 144   pn->next = 0;
 145   pn->buf = xmalloc(n);
 146   if (p) memcpy(pn->buf, p, n);
 147   pn->sz = n;
 148   pn->n = 0;
 149   return (pn);
 150 }
 151
 152 static int enqueue(pkq *q, pkq_node *pn)
 153 {
 154   int rc = 0;
 155
 156   if (!pn) return (0);
 157   rc = !q->head;
 158   pn->next = 0;
 159   *q->tail = pn;
 160   q->tail = &pn->next;
 161   return (rc);
 162 }
 163
 164 static void destroy_pkqnode(pkq_node *pn) { xfree(pn->buf); DESTROY(pn); }
 165
 166 static int dequeue(pkq *q, int freep)
 167 {
 168   pkq_node *pn = q->head;
 169   assert(pn);
 170   q->head = pn->next;
 171   if (freep)
 172     destroy_pkqnode(pn);
 173   if (!q->head) {
 174     q->tail = &q->head;
 175     return (1);
 176   }
 177   return (0);
 178 }
 179
 180 static void destroy_pkq(pkq *q)
 181 {
 182   pkq_node *pn, *pnn;
 183
 184   for (pn = q->head; pn; pn = pnn) {
 185     pnn = pn->next;
 186     destroy_pkqnode(pn);
 187   }
 188   q->head = 0; q->tail = &q->head;
 189 }
 190
 191 /*----- Gobblers ----------------------------------------------------------*
 192  *
 193  * A gobbler just eats everything it sees on its input descriptor.
 194  * Eventually, when it sees end-of-file, it closes the input descriptor,
 195  * calls a user-supplied calback function, and quits.
 196  */
 197
 198 static void close_gobbler(gobbler *g)
 199   { if (g->f.fd != -1) { sel_rmfile(&g->f); close(g->f.fd); g->f.fd = -1; } }
 200
 201 static void destroy_gobbler(gobbler *g) { close_gobbler(g); DESTROY(g); }
 202
 203 static void do_gobble_in(int fd, unsigned mode, void *p)
 204 {
 205   gobbler *g = p;
 206   ssize_t n;
 207
 208   for (;;) {
 209     n = read(fd, buf, sizeof(buf));
 210     if (n < 0) {
 211       if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 212         break;
 213       else {
 214         moan("read (gobble): %s", strerror(errno));
 215         if (g->done) g->done(g, errno, g->p);
 216         close_gobbler(g);
 217         break;
 218       }
 219     } else if (n == 0) {
 220       if (g->done) g->done(g, 0, g->p);
 221       close_gobbler(g);
 222       break;
 223     }
 224   }
 225 }
 226
 227 static gobbler *make_gobbler(int fd,
 228                              void (*done)(gobbler *, int, void *),
 229                              void *p)
 230 {
 231   gobbler *g;
 232
 233   g = CREATE(gobbler);
 234   g->done = done;
 235   g->p = p;
 236   sel_initfile(&sel, &g->f, fd, SEL_READ, do_gobble_in, g);
 237   sel_addfile(&g->f);
 238   do_gobble_in(fd, SEL_READ, g);
 239   return (g);
 240 }
 241
 242 /*----- Dribbler ----------------------------------------------------------*
 243  *
 244  * A dribbler hands out data from a packet queue to a file descriptor.  It
 245  * makes no attempt to preserve the record boundaries inherent in the packet
 246  * queue structure.  If the dribbler reaches the end of its queue, it invokes
 247  * a user-supplied `done' function and stops selecting its output descriptor
 248  * for writing.
 249  */
 250
 251 static void cripple_dribbler(dribbler *d) { close(d->f.fd); d->f.fd = -1; }
 252
 253 static void destroy_dribbler(dribbler *d)
 254   { cripple_dribbler(d); DESTROY(d); }
 255
 256 static void dribble_done(dribbler *d, int err)
 257 {
 258   if (d->q.head) {
 259     sel_rmfile(&d->f);
 260     destroy_pkq(&d->q);
 261   }
 262   d->done(d, err, d->p);
 263 }
 264
 265 static void do_dribble_out(int fd, unsigned mode, void *p)
 266 {
 267   dribbler *d = p;
 268   ssize_t n;
 269   pkq_node *pn;
 270
 271   for (;;) {
 272     pn = d->q.head;
 273     n = write(fd, pn->buf + pn->n, pn->sz - pn->n);
 274     if (n < 0) {
 275       if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 276         break;
 277       else {
 278         dribble_done(d, errno);
 279         break;
 280       }
 281     }
 282     pn->n += n;
 283     if (pn->n == pn->sz && dequeue(&d->q, 1)) {
 284       sel_rmfile(&d->f);
 285       dribble_done(d, 0);
 286       break;
 287     }
 288   }
 289 }
 290
 291 static int enqueue_dribble(dribbler *d, pkq_node *pn)
 292 {
 293   if (d->f.fd == -1) {
 294     destroy_pkqnode(pn);
 295     return (0);
 296   }
 297   if (enqueue(&d->q, pn)) {
 298     sel_addfile(&d->f);
 299     do_dribble_out(d->f.fd, SEL_WRITE, d);
 300     return (1);
 301   }
 302   return (0);
 303 }
 304
 305 static dribbler *make_dribbler(int fd,
 306                                void (*done)(dribbler *, int, void *),
 307                                void *p)
 308 {
 309   dribbler *d = CREATE(dribbler);
 310   sel_initfile(&sel, &d->f, fd, SEL_WRITE, do_dribble_out, d);
 311   initqueue(&d->q);
 312   d->done = done;
 313   d->p = p;
 314   return (d);
 315 }
 316
 317 /*----- Clients -----------------------------------------------------------*/
 318
 319 static void done_client_dribble(dribbler *d, int err, void *p)
 320 {
 321   if (err)
 322     moan("write (client): %s", strerror(err));
 323   destroy_gobbler(p);
 324   destroy_dribbler(d);
 325   reasons--;
 326 }
 327
 328 static void dequeue_to_waiter(void)
 329 {
 330   waiter *w;
 331   dribbler *d;
 332   pkq_node *pn;
 333
 334   while (q_in.head && wait_head) {
 335     w = wait_head;
 336     wait_head = w->next;
 337     if (!wait_head)
 338       wait_tail = &wait_head;
 339     d = make_dribbler(w->fd, done_client_dribble, w->g);
 340     DESTROY(w);
 341     pn = q_in.head;
 342     if (dequeue(&q_in, 0))
 343       reasons--;
 344     enqueue_dribble(d, pn);
 345   }
 346 }
 347
 348 static void destroy_client(client *c)
 349 {
 350   sel_rmfile(&c->f);
 351   close(c->f.fd);
 352   dstr_destroy(&c->d);
 353   reasons--;
 354   DESTROY(c);
 355 }
 356
 357 static void do_client_in(int fd, unsigned mode, void *p)
 358 {
 359   client *c = p;
 360   ssize_t n, i, i0;
 361   waiter *w;
 362
 363   /* --- Attention --- *
 364    *
 365    * The queue for outbound packets is SLIP-encoded; we need to encode it
 366    * here. The queue for inbound packets is raw.
 367    */
 368
 369   for (;;) {
 370     n = read(fd, buf, sizeof(buf));
 371     i0 = 0;
 372     if (n < 0) {
 373       if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 374         break;
 375       else {
 376         moan("read (client): %s", strerror(errno));
 377         destroy_client(c);
 378         return;
 379       }
 380     } else if (n == 0) {
 381       if (c->mode == '>') {
 382         DPUTC(&c->d, SL_END);
 383         if (enqueue_dribble(dribble_out, make_pkqnode(c->d.buf, c->d.len)))
 384           reasons++;
 385       }
 386       destroy_client(c);
 387       return;
 388     }
 389     if (c->mode == '?') {
 390       switch (buf[0]) {
 391         case '>':
 392           i0 = 1;
 393           c->mode = '>';
 394           break;
 395         case '<':
 396           w = CREATE(waiter);
 397           w->g = make_gobbler(fd, 0, 0);
 398           w->next = 0;
 399           w->fd = fd;
 400           *wait_tail = w;
 401           wait_tail = &w->next;
 402           sel_rmfile(&c->f);
 403           DESTROY(c);
 404           dequeue_to_waiter();
 405           return;
 406         default:
 407           moan("bad client mode `%c'", buf[0]);
 408           destroy_client(c);
 409           return;
 410       }
 411     }
 412     for (i = i0; i < n; i++) {
 413       switch (buf[i]) {
 414         case SL_ESC:
 415           DPUTC(&c->d, SL_ESC);
 416           DPUTC(&c->d, SL_ESCESC);
 417           break;
 418         case SL_END:
 419           DPUTC(&c->d, SL_ESC);
 420           DPUTC(&c->d, SL_ESCEND);
 421           break;
 422         default:
 423           DPUTC(&c->d, buf[i]);
 424           break;
 425       }
 426     }
 427   }
 428 }
 429
 430 static void do_accept(int fd, unsigned mode, void *hunoz)
 431 {
 432   client *c;
 433   struct sockaddr_un sun;
 434   socklen_t n = sizeof(sun);
 435   int nfd;
 436
 437   if ((nfd = accept(fd, (struct sockaddr *)&sun, &n)) < 0) {
 438     if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 439       return;
 440     else
 441       die(EXIT_FAILURE, "accept: %s", strerror(errno));
 442   }
 443   c = CREATE(client);
 444   c->mode = '?';
 445   dstr_create(&c->d);
 446   fdflags(nfd, O_NONBLOCK, O_NONBLOCK, 0, 0);
 447   sel_initfile(&sel, &c->f, nfd, SEL_READ, do_client_in, c);
 448   sel_addfile(&c->f);
 449   reasons++;
 450 }
 451
 452 /*----- Main daemon -------------------------------------------------------*/
 453
 454 static void done_slip_dribble(dribbler *d, int err, void *hunoz)
 455 {
 456   if (!err)
 457     reasons--;
 458   else if (err != EPIPE)
 459     die(EXIT_FAILURE, "write (slip): %s", strerror(errno));
 460   else
 461     cripple_dribbler(d);
 462 }
 463
 464 static void close_slip(int fd)
 465 {
 466   switch (slipstate) {
 467     case SYNC1: case SYNC2: case START: case BAD: break;
 468     default: moan("eof found while processing packet (discarding)"); break;
 469   }
 470   close(fd); sel_rmfile(&slip_in);
 471   reasons--;
 472 }
 473
 474 static void do_slip_in(int fd, unsigned mode, void *hunoz)
 475 {
 476   ssize_t i, n;
 477
 478   /* --- Attention --- *
 479    *
 480    * The queue for inbound packets contains raw data; we need to decode it
 481    * here.  The queue for outbound packets is SLIP-encoded.
 482    *
 483    * TrIPE sends two empty packets on start-up, in order to resynchronize the
 484    * target.  We don't need this and it messes us up.
 485    */
 486
 487   for (;;) {
 488     n = read(fd, buf, sizeof(buf));
 489     if (n == 0) {
 490       close_slip(fd);
 491       return;
 492     } else if (n < 0) {
 493       if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 494         break;
 495       die(EXIT_FAILURE, "read (slip in): %s", strerror(errno));
 496     }
 497     for (i = 0; i < n; i++) {
 498       switch (slipstate) {
 499         case SYNC1:
 500           switch (buf[i]) {
 501             case SL_END:
 502               slipstate = SYNC2;
 503               break;
 504             default:
 505               goto start;
 506           }
 507           break;
 508         case SYNC2:
 509           switch (buf[i]) {
 510             case SL_END:
 511               slipstate = START;
 512               break;
 513             default:
 514               goto start;
 515           }
 516           break;
 517         case BAD:
 518           switch (buf[i]) {
 519             case SL_END:
 520               DRESET(&slipbuf);
 521               slipstate = OK;
 522               break;
 523             default:
 524               break;
 525           }
 526           break;
 527         case ESC:
 528           switch (buf[i]) {
 529             case SL_ESCEND:
 530               DPUTC(&slipbuf, SL_END);
 531               slipstate = OK;
 532               break;
 533             case SL_ESCESC:
 534               DPUTC(&slipbuf, SL_ESC);
 535               slipstate = OK;
 536               break;
 537             case SL_END:
 538               moan("found escaped end byte (discard packet and resync");
 539               DRESET(&slipbuf);
 540               slipstate = OK;
 541               break;
 542             default:
 543               moan("unexpected escape char 0x%02x", buf[i]);
 544               slipstate = BAD;
 545               break;
 546           }
 547           break;
 548         case START:
 549         case OK:
 550         start:
 551           switch (buf[i]) {
 552             case SL_ESC:
 553               slipstate = ESC;
 554               break;
 555             case SL_END:
 556               if (enqueue(&q_in, make_pkqnode(slipbuf.buf, slipbuf.len)))
 557                 reasons++;
 558               DRESET(&slipbuf);
 559               dequeue_to_waiter();
 560               slipstate = START;
 561               break;
 562             default:
 563               DPUTC(&slipbuf, buf[i]);
 564               slipstate = OK;
 565               break;
 566           }
 567           break;
 568       }
 569     }
 570   }
 571 }
 572
 573 static void slip_term(int n, void *fdp)
 574   { close_slip(*(int *)fdp); }
 575
 576 static void slipif(void)
 577 {
 578   int fd;
 579   dstr d = DSTR_INIT;
 580   struct sockaddr_un sun;
 581   sig term;
 582   size_t sz;
 583
 584   /* --- Make the socket --- */
 585
 586   if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
 587     die(EXIT_FAILURE, "socket: %s", strerror(errno));
 588   socketaddr(&sun, &sz);
 589   if (bind(fd, (struct sockaddr *)&sun, sz))
 590     die(EXIT_FAILURE, "bind: %s", strerror(errno));
 591   if (listen(fd, 5))
 592     die(EXIT_FAILURE, "listen: %s", strerror(errno));
 593
 594   /* --- Set up listeners for things --- */
 595
 596   fdflags(fd, O_NONBLOCK, O_NONBLOCK, 0, 0);
 597   sel_initfile(&sel, &listener, fd, SEL_READ, do_accept, 0);
 598   sel_addfile(&listener);
 599
 600   fdflags(STDIN_FILENO, O_NONBLOCK, O_NONBLOCK, 0, 0);
 601   fdflags(STDOUT_FILENO, O_NONBLOCK, O_NONBLOCK, 0, 0);
 602   sel_initfile(&sel, &slip_in, STDIN_FILENO, SEL_READ, do_slip_in, 0);
 603   dribble_out = make_dribbler(STDOUT_FILENO, done_slip_dribble, 0);
 604   sel_addfile(&slip_in);
 605
 606   sig_init(&sel);
 607   sig_add(&term, SIGTERM, slip_term, &fd);
 608   sig_add(&term, SIGHUP, slip_term, &fd);
 609   sig_add(&term, SIGINT, slip_term, &fd);
 610
 611   initqueue(&q_in);
 612   reasons++;
 613
 614   /* --- Write the interface name --- */
 615
 616   dstr_putf(&d, "%s-%s\n", QUIS, name);
 617   if (enqueue_dribble(dribble_out, make_pkqnode(d.buf, d.len)))
 618     reasons++;
 619   dstr_destroy(&d);
 620
 621   /* --- Main loop --- */
 622
 623   while (reasons) {
 624     if (sel_select(&sel) && errno != EINTR)
 625       die(EXIT_FAILURE, "select: %s", strerror(errno));
 626   }
 627
 628   /* --- Done --- */
 629
 630   unlink(name);
 631 }
 632
 633 /*----- Putting and getting -----------------------------------------------*/
 634
 635 static int make_sock(int mode)
 636 {
 637   struct sockaddr_un sun;
 638   size_t sz;
 639   int fd;
 640   char ch;
 641
 642   if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
 643     die(EXIT_FAILURE, "socket: %s", strerror(errno));
 644   socketaddr(&sun, &sz);
 645   if (connect(fd, (struct sockaddr *)&sun, sz))
 646     die(EXIT_FAILURE, "connect: %s", strerror(errno));
 647   ch = mode;
 648   if (write(fd, &ch, 1) < 0)
 649     die(EXIT_FAILURE, "write (mode): %s", strerror(errno));
 650   return (fd);
 651 }
 652
 653 static void shovel(int from, int to)
 654 {
 655   ssize_t n;
 656   size_t sz;
 657   unsigned char *p;
 658
 659   for (;;) {
 660     n = read(from, buf, sizeof(buf));
 661     if (n < 0) {
 662       if (errno == EINTR)
 663         continue;
 664       else
 665         die(EXIT_FAILURE, "read (shovel): %s", strerror(errno));
 666     } else if (n == 0)
 667       break;
 668
 669     sz = n;
 670     p = buf;
 671     while (sz) {
 672       n = write(to, p, sz);
 673       if (n < 0) {
 674         if (errno == EINTR)
 675           continue;
 676         else
 677           die(EXIT_FAILURE, "write (shovel): %s", strerror(errno));
 678       }
 679       p += n;
 680       sz -= n;
 681     }
 682   }
 683   close(from);
 684   close(to);
 685 }
 686
 687 static void put(void) { shovel(STDIN_FILENO, make_sock('>')); }
 688 static void get(void) { shovel(make_sock('<'), STDOUT_FILENO); }
 689
 690 /*----- Flooding and sinking ----------------------------------------------*/
 691
 692 /* --- Connection jobs --- */
 693
 694 typedef struct conninfo {
 695   struct conninfo *next;
 696   conn c;
 697 } conninfo;
 698
 699 #define MAXCONN 32
 700 static conninfo conns[MAXCONN], *freeconns;
 701
 702 static void (*connhook)(int, conninfo *);
 703
 704 static void connrecycle(conninfo *c) { c->next = freeconns; freeconns = c; }
 705
 706 static void connerr(conninfo *c)
 707 {
 708   if (errno == EAGAIN) connrecycle(c);
 709   else die(EXIT_FAILURE, "connect: %s", strerror(errno));
 710 }
 711
 712 static void connected(int fd, void *p)
 713   { if (fd == -1) connerr(p); else connhook(fd, p); }
 714
 715 static void conndoconnect(conninfo *c)
 716 {
 717   int fd;
 718   struct sockaddr_un sun;
 719   size_t sz;
 720
 721   if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
 722     die(EXIT_FAILURE, "socket: %s", strerror(errno));
 723   socketaddr(&sun, &sz);
 724   if (conn_init(&c->c, &sel, fd, (struct sockaddr *)&sun, sz, connected, c))
 725     connerr(c);
 726 }
 727
 728 static int timerflag;
 729
 730 static void conndrip(struct timeval *tv, void *hunoz)
 731 {
 732   conninfo *c, *cc;
 733
 734   timerflag = 0;
 735   while (freeconns) {
 736     c = freeconns; freeconns = 0;
 737     while (c) { cc = c->next; conndoconnect(c); c = cc; }
 738   }
 739 }
 740
 741 static void connloop(void (*connected)(int, conninfo *))
 742 {
 743   int i;
 744   conninfo **cc;
 745   sel_timer t;
 746   struct timeval tv;
 747
 748   connhook = connected;
 749   for (i = 0, cc = &freeconns; i < MAXCONN; i++) {
 750     *cc = &conns[i];
 751     cc = &conns[i].next;
 752   }
 753   *cc = 0;
 754
 755   for (;;) {
 756     if (freeconns && !timerflag) {
 757       gettimeofday(&tv, 0);
 758       TV_ADDL(&tv, &tv, 0, 10000);
 759       sel_addtimer(&sel, &t, &tv, conndrip, 0);
 760       timerflag = 1;
 761     }
 762     if (sel_select(&sel))
 763       die(EXIT_FAILURE, "select: %s", strerror(errno));
 764   }
 765 }
 766
 767 /* --- Sinking (glug glug) --- */
 768
 769 static void close_sink(gobbler *g, int err, void *p)
 770 {
 771   static char baton[4] = "/-\\|";
 772   static int pos = 0;
 773   static int count = 0;
 774   static int state = '?';
 775
 776   conninfo *c = p;
 777
 778   if (!err) {
 779     if (state == '?')
 780       state = isatty(STDOUT_FILENO) ? 'y' : 'n';
 781     if (state == 'y') {
 782       if (count) count--;
 783       else {
 784         putchar(baton[pos]);
 785         putchar('\b');
 786         fflush(stdout);
 787         pos++;
 788         if (pos >= sizeof(baton)) pos = 0;
 789         count = 128;
 790       }
 791     }
 792   }
 793   connrecycle(c);
 794 }
 795
 796 static void sink_connected(int fd, conninfo *c)
 797 {
 798   char dir = '<';
 799
 800   if (write(fd, &dir, 1) != 1) {
 801     moan("write: %s (continuing)", strerror(errno));
 802     close(fd);
 803     connrecycle(c);
 804     return;
 805   }
 806   make_gobbler(fd, close_sink, c);
 807 }
 808
 809 static void sink(void) { connloop(sink_connected); }
 810
 811 /* --- Flooding --- */
 812
 813 static void close_flood(dribbler *d, int err, void *p)
 814 {
 815   conninfo *c = p;
 816
 817   if (err) moan("write: %s (continuing)\n", strerror(errno));
 818   destroy_dribbler(d);
 819   connrecycle(c);
 820 }
 821
 822 static void flood_connected(int fd, conninfo *c)
 823 {
 824   static uint32 seq;
 825
 826   dribbler *d;
 827   pkq_node *pn;
 828   int i;
 829
 830 #define FLOOD_PKSZ 1024
 831
 832   pn = make_pkqnode(0, 1 + FLOOD_PKSZ);
 833   pn->buf[0] = '>';
 834   STORE32(pn->buf + 1, seq);
 835   for (i = 4; i < FLOOD_PKSZ; i++)
 836     pn->buf[i + 1] = i & 0xff;
 837   seq++;
 838   d = make_dribbler(fd, close_flood, c);
 839   enqueue_dribble(d, pn);
 840 }
 841
 842 static void flood(void) { connloop(flood_connected); }
 843
 844 /*----- Main code ---------------------------------------------------------*/
 845
 846 static void usage(FILE *fp) { pquis(fp, "Usage: $ [-fgps] SOCKET\n"); }
 847
 848 static void version(void)
 849   { pquis(stdout, "$ (" PACKAGE " version " VERSION")\n"); }
 850
 851 static void help(void)
 852 {
 853   version();
 854   fputc('\n', stdout);
 855   usage(stdout);
 856   puts("\n\
 857 With no options, provides a SLIP interface for TrIPE.\n\
 858 \n\
 859 Options:\n\
 860   -f, --flood   Send packets to TrIPE as fast as possible.\n\
 861   -g, --get     Receive packet from TrIPE and write to stdout.\n\
 862   -p, --put     Send packet on stdin to TrIPE.\n\
 863   -s, --sink    Slurp packets out of TrIPE and display progress.");
 864 }
 865
 866 int main(int argc, char *argv[])
 867 {
 868   int mode = 'd';
 869   int i;
 870
 871   ego(argv[0]);
 872   for (;;) {
 873     const struct option opt[] = {
 874       { "help",                 0,              0,              'h' },
 875       { "version",              0,              0,              'v' },
 876       { "put",                  0,              0,              'p' },
 877       { "get",                  0,              0,              'g' },
 878       { "flood",                0,              0,              'f' },
 879       { "sink",                 0,              0,              's' },
 880       { 0,                      0,              0,              0 }
 881     };
 882     i = mdwopt(argc, argv, "hvpgfs", opt, 0, 0, 0);
 883     if (i < 0)
 884       break;
 885     switch (i) {
 886       case 'h': help(); return (0);
 887       case 'v': version(); return (0);
 888       case 'p': case 'g': case 's': case 'f': mode = i; break;
 889       default: usage(stderr); exit(EXIT_FAILURE); break;
 890     }
 891   }
 892   if (argc - optind != 1) { usage(stderr); exit(EXIT_FAILURE); }
 893   name = argv[optind];
 894   signal(SIGPIPE, SIG_IGN);
 895   switch (mode) {
 896     case 'd': slipif(); break;
 897     case 'p': put(); break;
 898     case 'g': get(); break;
 899     case 'f': flood(); break;
 900     case 's': sink(); break;
 901   }
 902   return (0);
 903 }
 904
 905 /*----- That's all, folks -------------------------------------------------*/