chiark - git - mdw - tripe/blob - server/peer.c

   1 /* -*-c-*-
   2  *
   3  * Communication with the peer
   4  *
   5  * (c) 2001 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
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * TrIPE is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with TrIPE; if not, write to the Free Software Foundation,
  24  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25  */
  26
  27 /*----- Header files ------------------------------------------------------*/
  28
  29 #include "tripe.h"
  30
  31 /*----- Static variables --------------------------------------------------*/
  32
  33 static sym_table byname;
  34 static addrmap byaddr;
  35 static sel_file sock;
  36 static unsigned nmobile;
  37
  38 /*----- Tunnel table ------------------------------------------------------*/
  39
  40 const tunnel_ops *tunnels[] = {
  41 #ifdef TUN_LINUX
  42   &tun_linux,
  43 #endif
  44 #ifdef TUN_BSD
  45   &tun_bsd,
  46 #endif
  47 #ifdef TUN_UNET
  48   &tun_unet,
  49 #endif
  50   &tun_slip,
  51   0
  52 }, *tun_default;
  53
  54 /*----- Main code ---------------------------------------------------------*/
  55
  56 /* --- @p_pingtype@ --- *
  57  *
  58  * Arguments:   @unsigned msg@ = message type
  59  *
  60  * Returns:     String to describe the message.
  61  */
  62
  63 static const char *p_pingtype(unsigned msg)
  64 {
  65   switch (msg & MSG_TYPEMASK) {
  66     case MISC_PING:
  67     case MISC_PONG:
  68       return "transport-ping";
  69     case MISC_EPING:
  70     case MISC_EPONG:
  71       return "encrypted-ping";
  72     default:
  73       abort();
  74   }
  75 }
  76
  77 /* --- @p_ponged@ --- *
  78  *
  79  * Arguments:   @peer *p@ = peer packet arrived from
  80  *              @unsigned msg@ = message type
  81  *              @buf *b@ = buffer containing payload
  82  *
  83  * Returns:     ---
  84  *
  85  * Use:         Processes a ping response.
  86  */
  87
  88 static void p_ponged(peer *p, unsigned msg, buf *b)
  89 {
  90   uint32 id;
  91   const octet *magic;
  92   ping *pg;
  93
  94   IF_TRACING(T_PEER, {
  95     trace(T_PEER, "peer: received %s reply from %s",
  96           p_pingtype(msg), p->spec.name);
  97     trace_block(T_PACKET, "peer: ping contents", BBASE(b), BSZ(b));
  98   })
  99
 100   if (buf_getu32(b, &id) ||
 101       (magic = buf_get(b, sizeof(pg->magic))) == 0 ||
 102       BLEFT(b)) {
 103     a_warn("PEER", "?PEER", p, "malformed-%s", p_pingtype(msg), A_END);
 104     return;
 105   }
 106
 107   for (pg = p->pings; pg; pg = pg->next) {
 108     if (pg->id == id)
 109       goto found;
 110   }
 111   a_warn("PEER",
 112          "?PEER", p,
 113          "unexpected-%s", p_pingtype(msg),
 114          "0x%08lx", (unsigned long)id,
 115          A_END);
 116   return;
 117
 118 found:
 119   if (memcmp(magic, pg->magic, sizeof(pg->magic)) != 0) {
 120     a_warn("PEER", "?PEER", p, "corrupt-%s", p_pingtype(msg), A_END);
 121     return;
 122   }
 123   p_pingdone(pg, PING_OK);
 124 }
 125
 126 /* --- @p_rxupdstats@ --- *
 127  *
 128  * Arguments:   @peer *p@ = peer to update
 129  *              @size_t n@ = size of incoming packet
 130  *
 131  * Returns:     ---
 132  *
 133  * Use:         Updates the peer's incoming packet statistics.
 134  */
 135
 136 static void p_rxupdstats(peer *p, size_t n)
 137 {
 138   p->st.t_last = time(0);
 139   p->st.n_in++;
 140   p->st.sz_in += n;
 141 }
 142
 143 /* --- @p_encrypt@ --- *
 144  *
 145  * Arguments:   @peer *p@ = peer to encrypt message to
 146  *              @int ty@ message type to send
 147  *              @buf *bin, *bout@ = input and output buffers
 148  *
 149  * Returns:     ---
 150  *
 151  * Use:         Convenience function for packet encryption.  Forces
 152  *              renegotiation when necessary.  Check for the output buffer
 153  *              being broken to find out whether the encryption was
 154  *              successful.
 155  */
 156
 157 static int p_encrypt(peer *p, int ty, buf *bin, buf *bout)
 158 {
 159   int err = ksl_encrypt(&p->ks, ty, bin, bout);
 160
 161   if (err == KSERR_REGEN) {
 162     kx_start(&p->kx, 1);
 163     err = 0;
 164   }
 165   if (!BOK(bout))
 166     err = -1;
 167   return (err);
 168 }
 169
 170 /* --- @p_decrypt@ --- *
 171  *
 172  * Arguments:   @peer **pp@ = pointer to peer to decrypt message from
 173  *              @addr *a@ = address the packet arrived on
 174  *              @size_t n@ = size of original incoming packet
 175  *              @int ty@ = message type to expect
 176  *              @buf *bin, *bout@ = input and output buffers
 177  *
 178  * Returns:     Zero on success; nonzero on error.
 179  *
 180  * Use:         Convenience function for packet decryption.  Reports errors
 181  *              and updates statistics appropriately.
 182  *
 183  *              If @*pp@ is null on entry and there are mobile peers then we
 184  *              see if any of them can decrypt the packet.  If so, we record
 185  *              @*a@ as the peer's new address and send a notification.
 186  */
 187
 188 static int p_decrypt(peer **pp, addr *a, size_t n,
 189                      int ty, buf *bin, buf *bout)
 190 {
 191   peer *p;
 192   peer_byaddr *pa;
 193   int err = KSERR_DECRYPT;
 194   unsigned f;
 195
 196   if (*pp) {
 197     p = *pp;
 198     T( trace(T_PEER, "peer: decrypting packet from known peer `%s'",
 199              p_name(p)); )
 200     err = ksl_decrypt(&p->ks, ty, bin, bout);
 201   } else {
 202     p = 0;
 203     if (nmobile) {
 204       T( trace(T_PEER, "peer: unknown source: trying mobile peers..."); )
 205       FOREACH_PEER(q, {
 206         if ((err = ksl_decrypt(&q->ks, ty, bin, bout)) == KSERR_DECRYPT) {
 207           T( trace(T_PEER, "peer: peer `%s' failed to decrypt",
 208                    p_name(q)); )
 209           continue;
 210         } else {
 211           p = *pp = q;
 212           IF_TRACING(T_PEER, {
 213             if (!err)
 214               trace(T_PEER, "peer: peer `%s' reports success", p_name(p));
 215             else {
 216               trace(T_PEER, "peer: peer `%s' reports decryption error %d",
 217                     p_name(p), err);
 218             }
 219           })
 220           break;
 221         }
 222       });
 223     }
 224     if (!p) {
 225       a_warn("PEER", "-", "unexpected-source", "?ADDR", a, A_END);
 226       return (-1);
 227     }
 228     if (!err) {
 229       T( trace(T_PEER, "peer: updating address for `%s'", p_name(p)); )
 230       p_rxupdstats(p, n);
 231       pa = am_find(&byaddr, a, sizeof(peer_byaddr), &f); assert(!f);
 232       am_remove(&byaddr, p->byaddr);
 233       p->byaddr = pa;
 234       pa->p = p;
 235       p->spec.sa = *a;
 236       a_notify("NEWADDR", "?PEER", p, "?ADDR", a, A_END);
 237     }
 238   }
 239   if (err) {
 240     if (p) p->st.n_reject++;
 241     a_warn("PEER", "?PEER", p, "decrypt-failed",
 242            "error-code", "%d", err, A_END);
 243     return (-1);
 244   }
 245   if (!BOK(bout))
 246     return (-1);
 247   return (0);
 248 }
 249
 250 /* --- @p_read@ --- *
 251  *
 252  * Arguments:   @int fd@ = file descriptor to read from
 253  *              @unsigned mode@ = what happened
 254  *              @void *v@ = an uninteresting pointer
 255  *
 256  * Returns:     ---
 257  *
 258  * Use:         Reads a packet from somewhere.
 259  */
 260
 261 static void p_read(int fd, unsigned mode, void *v)
 262 {
 263   peer *p = 0;
 264   addr a;
 265   size_t sz;
 266   ssize_t n;
 267   int ch;
 268   buf b, bb;
 269
 270   /* --- Read the data --- */
 271
 272   TIMER;
 273   sz = sizeof(addr);
 274   n = recvfrom(fd, buf_i, sizeof(buf_i), 0, &a.sa, &sz);
 275   if (n < 0) {
 276     a_warn("PEER", "-", "socket-read-error", "?ERRNO", A_END);
 277     return;
 278   }
 279
 280   /* --- If the packet is a greeting, don't check peers --- */
 281
 282   if (n && buf_i[0] == (MSG_MISC | MISC_GREET)) {
 283     IF_TRACING(T_PEER, {
 284       trace(T_PEER, "peer: greeting received from INET %s %u",
 285             inet_ntoa(a.sin.sin_addr),
 286             (unsigned)ntohs(a.sin.sin_port));
 287       trace_block(T_PACKET, "peer: greeting contents", buf_i, n);
 288     })
 289     buf_init(&b, buf_i, n);
 290     buf_getbyte(&b);
 291     if (c_check(&b) || BLEFT(&b)) {
 292       a_warn("PEER", "-", "invalid-greeting", A_END);
 293       return;
 294     }
 295     a_notify("GREET",
 296              "?B64", buf_i + 1, (size_t)(n - 1),
 297              "?ADDR", &a,
 298              A_END);
 299     return;
 300   }
 301
 302   /* --- Find the appropriate peer --- *
 303    *
 304    * At this stage, don't worry too much about whether we actually found it.
 305    */
 306
 307   p = p_findbyaddr(&a);
 308
 309   IF_TRACING(T_PEER, {
 310     if (p) {
 311       trace(T_PEER,
 312             "peer: packet received from `%s' from address INET %s %d",
 313             p_name(p), inet_ntoa(a.sin.sin_addr), ntohs(a.sin.sin_port));
 314     } else {
 315       trace(T_PEER, "peer: packet received from unknown address INET %s %d",
 316             inet_ntoa(a.sin.sin_addr), ntohs(a.sin.sin_port));
 317     }
 318     trace_block(T_PACKET, "peer: packet contents", buf_i, n);
 319   })
 320
 321   /* --- Pick the packet apart --- */
 322
 323   if (p) p_rxupdstats(p, n);
 324   buf_init(&b, buf_i, n);
 325   if ((ch = buf_getbyte(&b)) < 0) {
 326     a_warn("PEER", "?PEER", p, "bad-packet", "no-type", A_END);
 327     return;
 328   }
 329   switch (ch & MSG_CATMASK) {
 330     case MSG_PACKET:
 331       if (ch & MSG_TYPEMASK) {
 332         a_warn("PEER",
 333                "?PEER", p,
 334                "bad-packet",
 335                "unknown-type", "0x%02x", ch,
 336                A_END);
 337         if (p) p->st.n_reject++;
 338         return;
 339       }
 340       buf_init(&bb, buf_o, sizeof(buf_o));
 341       if (p_decrypt(&p, &a, n, MSG_PACKET, &b, &bb))
 342         return;
 343       if (BOK(&bb)) {
 344         p->st.n_ipin++;
 345         p->st.sz_ipin += BSZ(&b);
 346         p->t->ops->inject(p->t, &bb);
 347       } else {
 348         p->st.n_reject++;
 349         a_warn("PEER", "?PEER", p, "packet-build-failed", A_END);
 350       }
 351       break;
 352     case MSG_KEYEXCH:
 353       if (!p) goto unexp;
 354       kx_message(&p->kx, ch & MSG_TYPEMASK, &b);
 355       break;
 356     case MSG_MISC:
 357       switch (ch & MSG_TYPEMASK) {
 358         case MISC_NOP:
 359           if (!p) goto unexp;
 360           T( trace(T_PEER, "peer: received NOP packet"); )
 361           break;
 362         case MISC_PING:
 363           if (!p) goto unexp;
 364           buf_put(p_txstart(p, MSG_MISC | MISC_PONG), BCUR(&b), BLEFT(&b));
 365           p_txend(p);
 366           break;
 367         case MISC_PONG:
 368           if (!p) goto unexp;
 369           p_ponged(p, MISC_PONG, &b);
 370           break;
 371         case MISC_EPING:
 372           buf_init(&bb, buf_t, sizeof(buf_t));
 373           if (p_decrypt(&p, &a, n, ch, &b, &bb))
 374             return;
 375           if (BOK(&bb)) {
 376             buf_flip(&bb);
 377             p_encrypt(p, MSG_MISC | MISC_EPONG, &bb,
 378                       p_txstart(p, MSG_MISC | MISC_EPONG));
 379             p_txend(p);
 380           }
 381           break;
 382         case MISC_EPONG:
 383           buf_init(&bb, buf_t, sizeof(buf_t));
 384           if (p_decrypt(&p, &a, n, ch, &b, &bb))
 385             return;
 386           if (BOK(&bb)) {
 387             buf_flip(&bb);
 388             p_ponged(p, MISC_EPONG, &bb);
 389           }
 390           break;
 391       }
 392       break;
 393     default:
 394       if (p) p->st.n_reject++;
 395       a_warn("PEER",
 396              "?PEER", p,
 397              "bad-packet",
 398              "unknown-category", "0x%02x", ch,
 399              A_END);
 400       break;
 401     unexp:
 402       a_warn("PEER", "-", "unexpected-source", "?ADDR", &a, A_END);
 403       break;
 404   }
 405 }
 406
 407 /* --- @p_txstart@ --- *
 408  *
 409  * Arguments:   @peer *p@ = pointer to peer block
 410  *              @unsigned msg@ = message type code
 411  *
 412  * Returns:     A pointer to a buffer to write to.
 413  *
 414  * Use:         Starts sending to a peer.  Only one send can happen at a
 415  *              time.
 416  */
 417
 418 buf *p_txstart(peer *p, unsigned msg)
 419 {
 420   buf_init(&p->b, buf_o, sizeof(buf_o));
 421   buf_putbyte(&p->b, msg);
 422   return (&p->b);
 423 }
 424
 425 /* --- @p_txend@ --- *
 426  *
 427  * Arguments:   @peer *p@ = pointer to peer block
 428  *
 429  * Returns:     ---
 430  *
 431  * Use:         Sends a packet to the peer.
 432  */
 433
 434 static void p_setkatimer(peer *);
 435
 436 static int p_dotxend(peer *p)
 437 {
 438   if (!BOK(&p->b)) {
 439     a_warn("PEER", "?PEER", p, "packet-build-failed", A_END);
 440     return (0);
 441   }
 442   IF_TRACING(T_PEER, trace_block(T_PACKET, "peer: sending packet",
 443                                  BBASE(&p->b), BLEN(&p->b)); )
 444   if (sendto(sock.fd, BBASE(&p->b), BLEN(&p->b),
 445              0, &p->spec.sa.sa, p->spec.sasz) < 0) {
 446     a_warn("PEER", "?PEER", p, "socket-write-error", "?ERRNO", A_END);
 447     return (0);
 448   } else {
 449     p->st.n_out++;
 450     p->st.sz_out += BLEN(&p->b);
 451     return (1);
 452   }
 453 }
 454
 455 void p_txend(peer *p)
 456 {
 457   if (p_dotxend(p) && p->spec.t_ka) {
 458     sel_rmtimer(&p->tka);
 459     p_setkatimer(p);
 460   }
 461 }
 462
 463 /* --- @p_pingwrite@ --- *
 464  *
 465  * Arguments:   @ping *p@ = ping structure
 466  *              @buf *b@ = buffer to write in
 467  *
 468  * Returns:     ---
 469  *
 470  * Use:         Fills in a ping structure and writes the packet payload.
 471  */
 472
 473 static void p_pingwrite(ping *p, buf *b)
 474 {
 475   static uint32 seq = 0;
 476
 477   p->id = U32(seq++);
 478   GR_FILL(&rand_global, p->magic, sizeof(p->magic));
 479   buf_putu32(b, p->id);
 480   buf_put(b, p->magic, sizeof(p->magic));
 481 }
 482
 483 /* --- @p_pingdone@ --- *
 484  *
 485  * Arguments:   @ping *p@ = ping structure
 486  *              @int rc@ = return code to pass on
 487  *
 488  * Returns:     ---
 489  *
 490  * Use:         Disposes of a ping structure, maybe sending a notification.
 491  */
 492
 493 void p_pingdone(ping *p, int rc)
 494 {
 495   if (p->prev) p->prev->next = p->next;
 496   else p->p->pings = p->next;
 497   if (p->next) p->next->prev = p->prev;
 498   if (rc != PING_TIMEOUT) sel_rmtimer(&p->t);
 499   T( trace(T_PEER, "peer: ping 0x%08lx done (rc = %d)",
 500            (unsigned long)p->id, rc); )
 501   if (rc >= 0) p->func(rc, p->arg);
 502 }
 503
 504 /* --- @p_pingtimeout@ --- *
 505  *
 506  * Arguments:   @struct timeval *now@ = the time now
 507  *              @void *pv@ = pointer to ping block
 508  *
 509  * Returns:     ---
 510  *
 511  * Use:         Called when a ping times out.
 512  */
 513
 514 static void p_pingtimeout(struct timeval *now, void *pv)
 515 {
 516   ping *p = pv;
 517
 518   T( trace(T_PEER, "peer: ping 0x%08lx timed out", (unsigned long)p->id); )
 519   p_pingdone(p, PING_TIMEOUT);
 520 }
 521
 522 /* --- @p_pingsend@ --- *
 523  *
 524  * Arguments:   @peer *p@ = destination peer
 525  *              @ping *pg@ = structure to fill in
 526  *              @unsigned type@ = message type
 527  *              @unsigned long timeout@ = how long to wait before giving up
 528  *              @void (*func)(int, void *)@ = callback function
 529  *              @void *arg@ = argument for callback
 530  *
 531  * Returns:     Zero if successful, nonzero if it failed.
 532  *
 533  * Use:         Sends a ping to a peer.  Call @func@ with a nonzero argument
 534  *              if we get an answer within the timeout, or zero if no answer.
 535  */
 536
 537 int p_pingsend(peer *p, ping *pg, unsigned type,
 538                unsigned long timeout,
 539                void (*func)(int, void *), void *arg)
 540 {
 541   buf *b, bb;
 542   struct timeval tv;
 543
 544   switch (type) {
 545     case MISC_PING:
 546       pg->msg = MISC_PONG;
 547       b = p_txstart(p, MSG_MISC | MISC_PING);
 548       p_pingwrite(pg, b);
 549       p_txend(p);
 550       break;
 551     case MISC_EPING:
 552       pg->msg = MISC_EPONG;
 553       b = p_txstart(p, MSG_MISC | MISC_EPING);
 554       buf_init(&bb, buf_t, sizeof(buf_t));
 555       p_pingwrite(pg, &bb);
 556       buf_flip(&bb);
 557       p_encrypt(p, MSG_MISC | MISC_EPING, &bb, b);
 558       if (!BOK(b))
 559         return (-1);
 560       p_txend(p);
 561       break;
 562     default:
 563       abort();
 564       break;
 565   }
 566
 567   pg->next = p->pings;
 568   pg->prev = 0;
 569   pg->p = p;
 570   pg->func = func;
 571   pg->arg = arg;
 572   if (p->pings) p->pings->prev = pg;
 573   p->pings = pg;
 574   gettimeofday(&tv, 0);
 575   tv.tv_sec += timeout;
 576   sel_addtimer(&sel, &pg->t, &tv, p_pingtimeout, pg);
 577   T( trace(T_PEER, "peer: send %s 0x%08lx to %s",
 578            p_pingtype(type), (unsigned long)pg->id, p->spec.name); )
 579   return (0);
 580 }
 581
 582 /* --- @p_greet@ --- *
 583  *
 584  * Arguments:   @peer *p@ = peer to send to
 585  *              @const void *c@ = pointer to challenge
 586  *              @size_t sz@ = size of challenge
 587  *
 588  * Returns:     ---
 589  *
 590  * Use:         Sends a greeting packet.
 591  */
 592
 593 void p_greet(peer *p, const void *c, size_t sz)
 594 {
 595   buf *b = p_txstart(p, MSG_MISC | MISC_GREET);
 596   buf_put(b, c, sz);
 597   p_txend(p);
 598 }
 599
 600 /* --- @p_tun@ --- *
 601  *
 602  * Arguments:   @peer *p@ = pointer to peer block
 603  *              @buf *b@ = buffer containing incoming packet
 604  *
 605  * Returns:     ---
 606  *
 607  * Use:         Handles a packet which needs to be sent to a peer.
 608  */
 609
 610 void p_tun(peer *p, buf *b)
 611 {
 612   buf *bb = p_txstart(p, MSG_PACKET);
 613
 614   TIMER;
 615   p_encrypt(p, MSG_PACKET, b, bb);
 616   if (BOK(bb) && BLEN(bb)) {
 617     p->st.n_ipout++;
 618     p->st.sz_ipout += BLEN(bb);
 619     p_txend(p);
 620   }
 621 }
 622
 623 /* --- @p_keyreload@ --- *
 624  *
 625  * Arguments:   ---
 626  *
 627  * Returns:     ---
 628  *
 629  * Use:         Forces a check of the daemon's keyring files.
 630  */
 631
 632 void p_keyreload(void)
 633 {
 634   if (km_reload())
 635     FOREACH_PEER(p, { kx_newkeys(&p->kx); });
 636 }
 637
 638 /* --- @p_interval@ --- *
 639  *
 640  * Arguments:   ---
 641  *
 642  * Returns:     ---
 643  *
 644  * Use:         Called periodically to do tidying.
 645  */
 646
 647 void p_interval(void)
 648 {
 649   p_keyreload();
 650   FOREACH_PEER(p, { ksl_prune(&p->ks); });
 651 }
 652
 653 /* --- @p_stats@ --- *
 654  *
 655  * Arguments:   @peer *p@ = pointer to a peer block
 656  *
 657  * Returns:     A pointer to the peer's statistics.
 658  */
 659
 660 stats *p_stats(peer *p) { return (&p->st); }
 661
 662 /* --- @p_ifname@ --- *
 663  *
 664  * Arguments:   @peer *p@ = pointer to a peer block
 665  *
 666  * Returns:     A pointer to the peer's interface name.
 667  */
 668
 669 const char *p_ifname(peer *p) { return (p->ifname); }
 670
 671 /* --- @p_setifname@ --- *
 672  *
 673  * Arguments:   @peer *p@ = pointer to a peer block
 674  *              @const char *name@ = pointer to the new name
 675  *
 676  * Returns:     ---
 677  *
 678  * Use:         Changes the name held for a peer's interface.
 679  */
 680
 681 void p_setifname(peer *p, const char *name)
 682 {
 683   xfree(p->ifname);
 684   p->ifname = xstrdup(name);
 685   if (p->spec.tops->setifname)
 686     p->spec.tops->setifname(p->t, name);
 687 }
 688
 689 /* --- @p_addr@ --- *
 690  *
 691  * Arguments:   @peer *p@ = pointer to a peer block
 692  *
 693  * Returns:     A pointer to the peer's address.
 694  */
 695
 696 const addr *p_addr(peer *p) { return (&p->spec.sa); }
 697
 698 /* --- @p_init@ --- *
 699  *
 700  * Arguments:   @struct in_addr addr@ = address to bind to
 701  *              @unsigned port@ = port number to listen to
 702  *
 703  * Returns:     ---
 704  *
 705  * Use:         Initializes the peer system; creates the socket.
 706  */
 707
 708 void p_init(struct in_addr addr, unsigned port)
 709 {
 710   int fd;
 711   struct sockaddr_in sin;
 712   int len = PKBUFSZ;
 713
 714   /* --- Note on socket buffer sizes --- *
 715    *
 716    * For some bizarre reason, Linux 2.2 (at least) doubles the socket buffer
 717    * sizes I pass to @setsockopt@.  I'm not putting special-case code here
 718    * for Linux: BSD (at least TCPv2) does what I tell it rather than second-
 719    * guessing me.
 720    */
 721
 722   if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
 723     die(EXIT_FAILURE, "socket creation failed: %s", strerror(errno));
 724   BURN(sin);
 725   sin.sin_family = AF_INET;
 726   sin.sin_addr = addr;
 727   sin.sin_port = htons(port);
 728   if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)))
 729     die(EXIT_FAILURE, "bind failed: %s", strerror(errno));
 730   if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len)) ||
 731       setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &len, sizeof(len))) {
 732     die(EXIT_FAILURE, "failed to set socket buffer sizes: %s",
 733         strerror(errno));
 734   }
 735   fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
 736   sel_initfile(&sel, &sock, fd, SEL_READ, p_read, 0);
 737   sel_addfile(&sock);
 738   T( trace(T_PEER, "peer: created socket"); )
 739
 740   sym_create(&byname);
 741   am_create(&byaddr);
 742 }
 743
 744 /* --- @p_port@ --- *
 745  *
 746  * Arguments:   ---
 747  *
 748  * Returns:     Port number used for socket.
 749  */
 750
 751 unsigned p_port(void)
 752 {
 753   addr a;
 754   size_t sz = sizeof(addr);
 755
 756   if (getsockname(sock.fd, &a.sa, &sz))
 757     die(EXIT_FAILURE, "couldn't read port number: %s", strerror(errno));
 758   assert(a.sa.sa_family == AF_INET);
 759   return (ntohs(a.sin.sin_port));
 760 }
 761
 762 /* --- @p_keepalive@ --- *
 763  *
 764  * Arguments:   @struct timeval *now@ = the current time
 765  *              @void *pv@ = peer to wake up
 766  *
 767  * Returns:     ---
 768  *
 769  * Use:         Sends a keepalive ping message to its peer.
 770  */
 771
 772 static void p_keepalive(struct timeval *now, void *pv)
 773 {
 774   peer *p = pv;
 775   p_txstart(p, MSG_MISC | MISC_NOP); p_dotxend(p);
 776   T( trace(T_PEER, "peer: sent keepalive to %s", p->spec.name); )
 777   p_setkatimer(p);
 778 }
 779
 780 /* --- @p_setkatimer@ --- *
 781  *
 782  * Arguments:   @peer *p@ = peer to set
 783  *
 784  * Returns:     ---
 785  *
 786  * Use:         Resets the keepalive timer thing.
 787  */
 788
 789 static void p_setkatimer(peer *p)
 790 {
 791   struct timeval tv;
 792
 793   if (!p->spec.t_ka)
 794     return;
 795   gettimeofday(&tv, 0);
 796   tv.tv_sec += p->spec.t_ka;
 797   sel_addtimer(&sel, &p->tka, &tv, p_keepalive, p);
 798 }
 799
 800 /* --- @p_create@ --- *
 801  *
 802  * Arguments:   @peerspec *spec@ = information about this peer
 803  *
 804  * Returns:     Pointer to the peer block, or null if it failed.
 805  *
 806  * Use:         Creates a new named peer block.  No peer is actually attached
 807  *              by this point.
 808  */
 809
 810 peer *p_create(peerspec *spec)
 811 {
 812   peer *p = CREATE(peer);
 813   const tunnel_ops *tops = spec->tops;
 814   int fd;
 815   unsigned f;
 816
 817   p->byname = sym_find(&byname, spec->name, -1, sizeof(peer_byname), &f);
 818   if (f) goto tidy_0;
 819   p->byaddr = am_find(&byaddr, &spec->sa, sizeof(peer_byaddr), &f);
 820   if (f) goto tidy_1;
 821   p->byname->p = p->byaddr->p = p;
 822
 823   T( trace(T_PEER, "peer: creating new peer `%s'", spec->name); )
 824   p->spec = *spec;
 825   p->spec.name = (/*unconst*/ char *)SYM_NAME(p->byname);
 826   if (spec->tag)
 827     p->spec.tag = xstrdup(spec->tag);
 828   p->ks = 0;
 829   p->pings = 0;
 830   p->ifname = 0;
 831   memset(&p->st, 0, sizeof(stats));
 832   p->st.t_start = time(0);
 833   if (!(tops->flags & TUNF_PRIVOPEN))
 834     fd = -1;
 835   else if ((fd = ps_tunfd(tops, &p->ifname)) < 0)
 836     goto tidy_2;
 837   if ((p->t = tops->create(p, fd, &p->ifname)) == 0)
 838     goto tidy_3;
 839   T( trace(T_TUNNEL, "peer: attached interface %s to peer `%s'",
 840            p->ifname, p_name(p)); )
 841   p_setkatimer(p);
 842   if (kx_init(&p->kx, p, &p->ks, p->spec.f & PSF_KXMASK))
 843     goto tidy_4;
 844   a_notify("ADD",
 845            "?PEER", p,
 846            "%s", p->ifname,
 847            "?ADDR", &p->spec.sa,
 848            A_END);
 849   if (!(p->spec.f & KXF_CORK)) {
 850     a_notify("KXSTART", "?PEER", p, A_END);
 851     /* Couldn't tell anyone before */
 852   }
 853   if (p->spec.f & PSF_MOBILE) nmobile++;
 854   return (p);
 855
 856 tidy_4:
 857   if (spec->t_ka)
 858     sel_rmtimer(&p->tka);
 859   xfree(p->ifname);
 860   p->t->ops->destroy(p->t);
 861 tidy_3:
 862   if (fd >= 0) close(fd);
 863 tidy_2:
 864   am_remove(&byaddr, p->byaddr);
 865   if (p->spec.tag) xfree(p->spec.tag);
 866 tidy_1:
 867   sym_remove(&byname, p->byname);
 868 tidy_0:
 869   DESTROY(p);
 870   return (0);
 871 }
 872
 873 /* --- @p_name@ --- *
 874  *
 875  * Arguments:   @peer *p@ = pointer to a peer block
 876  *
 877  * Returns:     A pointer to the peer's name.
 878  */
 879
 880 const char *p_name(peer *p)
 881   { if (p) return (p->spec.name); else return ("-"); }
 882
 883 /* --- @p_tag@ --- *
 884  *
 885  * Arguments:   @peer *p@ = pointer to a peer block
 886  *
 887  * Returns:     A pointer to the peer's public key tag.
 888  */
 889
 890 const char *p_tag(peer *p)
 891   { return (p->spec.tag ? p->spec.tag : p->spec.name); }
 892
 893 /* --- @p_spec@ --- *
 894  *
 895  * Arguments:   @peer *p@ = pointer to a peer block
 896  *
 897  * Returns:     Pointer to the peer's specification
 898  */
 899
 900 const peerspec *p_spec(peer *p) { return (&p->spec); }
 901
 902 /* --- @p_findbyaddr@ --- *
 903  *
 904  * Arguments:   @const addr *a@ = address to look up
 905  *
 906  * Returns:     Pointer to the peer block, or null if not found.
 907  *
 908  * Use:         Finds a peer by address.
 909  */
 910
 911 peer *p_findbyaddr(const addr *a)
 912 {
 913   peer_byaddr *pa;
 914
 915   if ((pa = am_find(&byaddr, a, 0, 0)) != 0) {
 916     assert(pa->p);
 917     return (pa->p);
 918   }
 919   return (0);
 920 }
 921
 922 /* --- @p_find@ --- *
 923  *
 924  * Arguments:   @const char *name@ = name to look up
 925  *
 926  * Returns:     Pointer to the peer block, or null if not found.
 927  *
 928  * Use:         Finds a peer by name.
 929  */
 930
 931 peer *p_find(const char *name)
 932 {
 933   peer_byname *pn;
 934
 935   if ((pn = sym_find(&byname, name, -1, 0, 0)) != 0)
 936     return (pn->p);
 937   return (0);
 938 }
 939
 940 /* --- @p_destroy@ --- *
 941  *
 942  * Arguments:   @peer *p@ = pointer to a peer
 943  *
 944  * Returns:     ---
 945  *
 946  * Use:         Destroys a peer.
 947  */
 948
 949 void p_destroy(peer *p)
 950 {
 951   ping *pg, *ppg;
 952
 953   T( trace(T_PEER, "peer: destroying peer `%s'", p->spec.name); )
 954   a_notify("KILL", "%s", p->spec.name, A_END);
 955   ksl_free(&p->ks);
 956   kx_free(&p->kx);
 957   if (p->spec.f & PSF_MOBILE)
 958     nmobile--;
 959   if (p->ifname)
 960     xfree(p->ifname);
 961   if (p->spec.tag)
 962     xfree(p->spec.tag);
 963   p->t->ops->destroy(p->t);
 964   if (p->spec.t_ka)
 965     sel_rmtimer(&p->tka);
 966   for (pg = p->pings; pg; pg = ppg) {
 967     ppg = pg->next;
 968     p_pingdone(pg, PING_PEERDIED);
 969   }
 970   sym_remove(&byname, p->byname);
 971   am_remove(&byaddr, p->byaddr);
 972   DESTROY(p);
 973 }
 974
 975 /* --- @p_mkiter@ --- *
 976  *
 977  * Arguments:   @peer_iter *i@ = pointer to an iterator
 978  *
 979  * Returns:     ---
 980  *
 981  * Use:         Initializes the iterator.
 982  */
 983
 984 void p_mkiter(peer_iter *i) { sym_mkiter(&i->i, &byname); }
 985
 986 /* --- @p_next@ --- *
 987  *
 988  * Arguments:   @peer_iter *i@ = pointer to an iterator
 989  *
 990  * Returns:     Next peer, or null if at the end.
 991  *
 992  * Use:         Returns the next peer.
 993  */
 994
 995 peer *p_next(peer_iter *i)
 996 {
 997   peer_byname *pn;
 998
 999   if ((pn = sym_next(&i->i)) == 0)
1000     return (0);
1001   return (pn->p);
1002 }
1003
1004 /*----- That's all, folks -------------------------------------------------*/