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, *q;
 192   peer_byaddr *pa, *qa;
 193   int err = KSERR_DECRYPT;
 194   unsigned f;
 195
 196   /* --- If we have a match on the source address then try that first --- */
 197
 198   q = *pp;
 199   if (q) {
 200     T( trace(T_PEER, "peer: decrypting packet from known peer `%s'",
 201              p_name(q)); )
 202     if ((err = ksl_decrypt(&q->ks, ty, bin, bout)) != KSERR_DECRYPT ||
 203         !(q->spec.f & PSF_MOBILE) || nmobile == 1) {
 204       p = q;
 205       goto match;
 206     }
 207     T( trace(T_PEER, "peer: failed to decrypt: try other mobile peers...",
 208              p_name(q)); )
 209   } else if (nmobile)
 210     T( trace(T_PEER, "peer: unknown source: trying mobile peers..."); )
 211   else {
 212     p = 0;
 213     goto searched;
 214   }
 215
 216   /* --- See whether any mobile peer is interested --- */
 217
 218   FOREACH_PEER(pp, {
 219     if (pp == q || !(pp->spec.f & PSF_MOBILE)) continue;
 220     if ((err = ksl_decrypt(&pp->ks, ty, bin, bout)) == KSERR_DECRYPT) {
 221       T( trace(T_PEER, "peer: peer `%s' failed to decrypt",
 222                p_name(pp)); )
 223         continue;
 224     } else {
 225       p = pp;
 226       IF_TRACING(T_PEER, {
 227         if (!err)
 228           trace(T_PEER, "peer: peer `%s' reports success", p_name(pp));
 229         else {
 230           trace(T_PEER, "peer: peer `%s' reports decryption error %d",
 231                 p_name(pp), err);
 232         }
 233       })
 234       break;
 235     }
 236   });
 237
 238   /* --- We've searched the mobile peers --- */
 239
 240 searched:
 241   if (!p) {
 242     a_warn("PEER", "-", "unexpected-source", "?ADDR", a, A_END);
 243     return (-1);
 244   }
 245
 246   /* --- We found one that accepted, so update the peer's address --- *
 247    *
 248    * If we had an initial guess of which peer this packet came from -- i.e.,
 249    * @q@ is not null -- then swap the addresses over.  This doesn't leave the
 250    * evicted peer in an especially good state, but it ought to get sorted out
 251    * soon enough.
 252    */
 253
 254   if (!err) {
 255     if (!q) {
 256       T( trace(T_PEER, "peer: updating address for `%s'", p_name(p)); )
 257       pa = am_find(&byaddr, a, sizeof(peer_byaddr), &f); assert(!f);
 258       am_remove(&byaddr, p->byaddr);
 259       p->byaddr = pa;
 260       pa->p = p;
 261       p->spec.sa = *a;
 262       a_notify("NEWADDR", "?PEER", p, "?ADDR", a, A_END);
 263     } else {
 264       T( trace(T_PEER, "peer: swapping addresses for `%s' and `%s'",
 265                p_name(p), p_name(q)); )
 266       pa = p->byaddr; qa = q->byaddr;
 267       pa->p = q; q->byaddr = pa; q->spec.sa = p->spec.sa;
 268       qa->p = p; p->byaddr = qa; p->spec.sa = *a;
 269       a_notify("NEWADDR", "?PEER", p, "?ADDR", a, A_END);
 270       a_notify("NEWADDR", "?PEER", q, "?ADDR", &q->spec.sa, A_END);
 271     }
 272   }
 273
 274 match:
 275   p_rxupdstats(p, n);
 276   if (err) {
 277     if (p) p->st.n_reject++;
 278     a_warn("PEER", "?PEER", p, "decrypt-failed",
 279            "error-code", "%d", err, A_END);
 280     return (-1);
 281   }
 282   if (!BOK(bout))
 283     return (-1);
 284   return (0);
 285 }
 286
 287 /* --- @p_read@ --- *
 288  *
 289  * Arguments:   @int fd@ = file descriptor to read from
 290  *              @unsigned mode@ = what happened
 291  *              @void *v@ = an uninteresting pointer
 292  *
 293  * Returns:     ---
 294  *
 295  * Use:         Reads a packet from somewhere.
 296  */
 297
 298 static void p_read(int fd, unsigned mode, void *v)
 299 {
 300   peer *p = 0;
 301   addr a;
 302   size_t sz;
 303   ssize_t n;
 304   int ch;
 305   buf b, bb;
 306
 307   /* --- Read the data --- */
 308
 309   TIMER;
 310   sz = sizeof(addr);
 311   n = recvfrom(fd, buf_i, sizeof(buf_i), 0, &a.sa, &sz);
 312   if (n < 0) {
 313     a_warn("PEER", "-", "socket-read-error", "?ERRNO", A_END);
 314     return;
 315   }
 316
 317   /* --- If the packet is a greeting, don't check peers --- */
 318
 319   if (n && buf_i[0] == (MSG_MISC | MISC_GREET)) {
 320     IF_TRACING(T_PEER, {
 321       trace(T_PEER, "peer: greeting received from INET %s %u",
 322             inet_ntoa(a.sin.sin_addr),
 323             (unsigned)ntohs(a.sin.sin_port));
 324       trace_block(T_PACKET, "peer: greeting contents", buf_i, n);
 325     })
 326     buf_init(&b, buf_i, n);
 327     buf_getbyte(&b);
 328     if (c_check(&b) || BLEFT(&b)) {
 329       a_warn("PEER", "-", "invalid-greeting", A_END);
 330       return;
 331     }
 332     a_notify("GREET",
 333              "?B64", buf_i + 1, (size_t)(n - 1),
 334              "?ADDR", &a,
 335              A_END);
 336     return;
 337   }
 338
 339   /* --- Find the appropriate peer --- *
 340    *
 341    * At this stage, don't worry too much about whether we actually found it.
 342    */
 343
 344   p = p_findbyaddr(&a);
 345
 346   IF_TRACING(T_PEER, {
 347     if (p) {
 348       trace(T_PEER,
 349             "peer: packet received from `%s' from address INET %s %d",
 350             p_name(p), inet_ntoa(a.sin.sin_addr), ntohs(a.sin.sin_port));
 351     } else {
 352       trace(T_PEER, "peer: packet received from unknown address INET %s %d",
 353             inet_ntoa(a.sin.sin_addr), ntohs(a.sin.sin_port));
 354     }
 355     trace_block(T_PACKET, "peer: packet contents", buf_i, n);
 356   })
 357
 358   /* --- Pick the packet apart --- */
 359
 360   buf_init(&b, buf_i, n);
 361   if ((ch = buf_getbyte(&b)) < 0) {
 362     a_warn("PEER", "?PEER", p, "bad-packet", "no-type", A_END);
 363     return;
 364   }
 365   switch (ch & MSG_CATMASK) {
 366     case MSG_PACKET:
 367       if (ch & MSG_TYPEMASK) {
 368         a_warn("PEER",
 369                "?PEER", p,
 370                "bad-packet",
 371                "unknown-type", "0x%02x", ch,
 372                A_END);
 373         if (p) p->st.n_reject++;
 374         return;
 375       }
 376       buf_init(&bb, buf_o, sizeof(buf_o));
 377       if (p_decrypt(&p, &a, n, MSG_PACKET, &b, &bb))
 378         return;
 379       if (BOK(&bb)) {
 380         p->st.n_ipin++;
 381         p->st.sz_ipin += BSZ(&b);
 382         p->t->ops->inject(p->t, &bb);
 383       } else {
 384         p->st.n_reject++;
 385         a_warn("PEER", "?PEER", p, "packet-build-failed", A_END);
 386       }
 387       break;
 388     case MSG_KEYEXCH:
 389       if (!p) goto unexp;
 390       p_rxupdstats(p, n);
 391       kx_message(&p->kx, ch & MSG_TYPEMASK, &b);
 392       break;
 393     case MSG_MISC:
 394       switch (ch & MSG_TYPEMASK) {
 395         case MISC_NOP:
 396           if (!p) goto unexp;
 397           p_rxupdstats(p, n);
 398           T( trace(T_PEER, "peer: received NOP packet"); )
 399           break;
 400         case MISC_PING:
 401           if (!p) goto unexp;
 402           p_rxupdstats(p, n);
 403           buf_put(p_txstart(p, MSG_MISC | MISC_PONG), BCUR(&b), BLEFT(&b));
 404           p_txend(p);
 405           break;
 406         case MISC_PONG:
 407           if (!p) goto unexp;
 408           p_rxupdstats(p, n);
 409           p_ponged(p, MISC_PONG, &b);
 410           break;
 411         case MISC_EPING:
 412           buf_init(&bb, buf_t, sizeof(buf_t));
 413           if (p_decrypt(&p, &a, n, ch, &b, &bb))
 414             return;
 415           if (BOK(&bb)) {
 416             buf_flip(&bb);
 417             p_encrypt(p, MSG_MISC | MISC_EPONG, &bb,
 418                       p_txstart(p, MSG_MISC | MISC_EPONG));
 419             p_txend(p);
 420           }
 421           break;
 422         case MISC_EPONG:
 423           buf_init(&bb, buf_t, sizeof(buf_t));
 424           if (p_decrypt(&p, &a, n, ch, &b, &bb))
 425             return;
 426           if (BOK(&bb)) {
 427             buf_flip(&bb);
 428             p_ponged(p, MISC_EPONG, &bb);
 429           }
 430           break;
 431       }
 432       break;
 433     default:
 434       if (p) p->st.n_reject++;
 435       a_warn("PEER",
 436              "?PEER", p,
 437              "bad-packet",
 438              "unknown-category", "0x%02x", ch,
 439              A_END);
 440       break;
 441     unexp:
 442       a_warn("PEER", "-", "unexpected-source", "?ADDR", &a, A_END);
 443       break;
 444   }
 445 }
 446
 447 /* --- @p_txstart@ --- *
 448  *
 449  * Arguments:   @peer *p@ = pointer to peer block
 450  *              @unsigned msg@ = message type code
 451  *
 452  * Returns:     A pointer to a buffer to write to.
 453  *
 454  * Use:         Starts sending to a peer.  Only one send can happen at a
 455  *              time.
 456  */
 457
 458 buf *p_txstart(peer *p, unsigned msg)
 459 {
 460   buf_init(&p->b, buf_o, sizeof(buf_o));
 461   buf_putbyte(&p->b, msg);
 462   return (&p->b);
 463 }
 464
 465 /* --- @p_txend@ --- *
 466  *
 467  * Arguments:   @peer *p@ = pointer to peer block
 468  *
 469  * Returns:     ---
 470  *
 471  * Use:         Sends a packet to the peer.
 472  */
 473
 474 static void p_setkatimer(peer *);
 475
 476 static int p_dotxend(peer *p)
 477 {
 478   if (!BOK(&p->b)) {
 479     a_warn("PEER", "?PEER", p, "packet-build-failed", A_END);
 480     return (0);
 481   }
 482   IF_TRACING(T_PEER, trace_block(T_PACKET, "peer: sending packet",
 483                                  BBASE(&p->b), BLEN(&p->b)); )
 484   if (sendto(sock.fd, BBASE(&p->b), BLEN(&p->b),
 485              0, &p->spec.sa.sa, p->spec.sasz) < 0) {
 486     a_warn("PEER", "?PEER", p, "socket-write-error", "?ERRNO", A_END);
 487     return (0);
 488   } else {
 489     p->st.n_out++;
 490     p->st.sz_out += BLEN(&p->b);
 491     return (1);
 492   }
 493 }
 494
 495 void p_txend(peer *p)
 496 {
 497   if (p_dotxend(p) && p->spec.t_ka) {
 498     sel_rmtimer(&p->tka);
 499     p_setkatimer(p);
 500   }
 501 }
 502
 503 /* --- @p_pingwrite@ --- *
 504  *
 505  * Arguments:   @ping *p@ = ping structure
 506  *              @buf *b@ = buffer to write in
 507  *
 508  * Returns:     ---
 509  *
 510  * Use:         Fills in a ping structure and writes the packet payload.
 511  */
 512
 513 static void p_pingwrite(ping *p, buf *b)
 514 {
 515   static uint32 seq = 0;
 516
 517   p->id = U32(seq++);
 518   GR_FILL(&rand_global, p->magic, sizeof(p->magic));
 519   buf_putu32(b, p->id);
 520   buf_put(b, p->magic, sizeof(p->magic));
 521 }
 522
 523 /* --- @p_pingdone@ --- *
 524  *
 525  * Arguments:   @ping *p@ = ping structure
 526  *              @int rc@ = return code to pass on
 527  *
 528  * Returns:     ---
 529  *
 530  * Use:         Disposes of a ping structure, maybe sending a notification.
 531  */
 532
 533 void p_pingdone(ping *p, int rc)
 534 {
 535   if (p->prev) p->prev->next = p->next;
 536   else p->p->pings = p->next;
 537   if (p->next) p->next->prev = p->prev;
 538   if (rc != PING_TIMEOUT) sel_rmtimer(&p->t);
 539   T( trace(T_PEER, "peer: ping 0x%08lx done (rc = %d)",
 540            (unsigned long)p->id, rc); )
 541   if (rc >= 0) p->func(rc, p->arg);
 542 }
 543
 544 /* --- @p_pingtimeout@ --- *
 545  *
 546  * Arguments:   @struct timeval *now@ = the time now
 547  *              @void *pv@ = pointer to ping block
 548  *
 549  * Returns:     ---
 550  *
 551  * Use:         Called when a ping times out.
 552  */
 553
 554 static void p_pingtimeout(struct timeval *now, void *pv)
 555 {
 556   ping *p = pv;
 557
 558   T( trace(T_PEER, "peer: ping 0x%08lx timed out", (unsigned long)p->id); )
 559   p_pingdone(p, PING_TIMEOUT);
 560 }
 561
 562 /* --- @p_pingsend@ --- *
 563  *
 564  * Arguments:   @peer *p@ = destination peer
 565  *              @ping *pg@ = structure to fill in
 566  *              @unsigned type@ = message type
 567  *              @unsigned long timeout@ = how long to wait before giving up
 568  *              @void (*func)(int, void *)@ = callback function
 569  *              @void *arg@ = argument for callback
 570  *
 571  * Returns:     Zero if successful, nonzero if it failed.
 572  *
 573  * Use:         Sends a ping to a peer.  Call @func@ with a nonzero argument
 574  *              if we get an answer within the timeout, or zero if no answer.
 575  */
 576
 577 int p_pingsend(peer *p, ping *pg, unsigned type,
 578                unsigned long timeout,
 579                void (*func)(int, void *), void *arg)
 580 {
 581   buf *b, bb;
 582   struct timeval tv;
 583
 584   switch (type) {
 585     case MISC_PING:
 586       pg->msg = MISC_PONG;
 587       b = p_txstart(p, MSG_MISC | MISC_PING);
 588       p_pingwrite(pg, b);
 589       p_txend(p);
 590       break;
 591     case MISC_EPING:
 592       pg->msg = MISC_EPONG;
 593       b = p_txstart(p, MSG_MISC | MISC_EPING);
 594       buf_init(&bb, buf_t, sizeof(buf_t));
 595       p_pingwrite(pg, &bb);
 596       buf_flip(&bb);
 597       p_encrypt(p, MSG_MISC | MISC_EPING, &bb, b);
 598       if (!BOK(b))
 599         return (-1);
 600       p_txend(p);
 601       break;
 602     default:
 603       abort();
 604       break;
 605   }
 606
 607   pg->next = p->pings;
 608   pg->prev = 0;
 609   pg->p = p;
 610   pg->func = func;
 611   pg->arg = arg;
 612   if (p->pings) p->pings->prev = pg;
 613   p->pings = pg;
 614   gettimeofday(&tv, 0);
 615   tv.tv_sec += timeout;
 616   sel_addtimer(&sel, &pg->t, &tv, p_pingtimeout, pg);
 617   T( trace(T_PEER, "peer: send %s 0x%08lx to %s",
 618            p_pingtype(type), (unsigned long)pg->id, p->spec.name); )
 619   return (0);
 620 }
 621
 622 /* --- @p_greet@ --- *
 623  *
 624  * Arguments:   @peer *p@ = peer to send to
 625  *              @const void *c@ = pointer to challenge
 626  *              @size_t sz@ = size of challenge
 627  *
 628  * Returns:     ---
 629  *
 630  * Use:         Sends a greeting packet.
 631  */
 632
 633 void p_greet(peer *p, const void *c, size_t sz)
 634 {
 635   buf *b = p_txstart(p, MSG_MISC | MISC_GREET);
 636   buf_put(b, c, sz);
 637   p_txend(p);
 638 }
 639
 640 /* --- @p_tun@ --- *
 641  *
 642  * Arguments:   @peer *p@ = pointer to peer block
 643  *              @buf *b@ = buffer containing incoming packet
 644  *
 645  * Returns:     ---
 646  *
 647  * Use:         Handles a packet which needs to be sent to a peer.
 648  */
 649
 650 void p_tun(peer *p, buf *b)
 651 {
 652   buf *bb = p_txstart(p, MSG_PACKET);
 653
 654   TIMER;
 655   p_encrypt(p, MSG_PACKET, b, bb);
 656   if (BOK(bb) && BLEN(bb)) {
 657     p->st.n_ipout++;
 658     p->st.sz_ipout += BLEN(bb);
 659     p_txend(p);
 660   }
 661 }
 662
 663 /* --- @p_keyreload@ --- *
 664  *
 665  * Arguments:   ---
 666  *
 667  * Returns:     ---
 668  *
 669  * Use:         Forces a check of the daemon's keyring files.
 670  */
 671
 672 void p_keyreload(void)
 673 {
 674   if (km_reload())
 675     FOREACH_PEER(p, { kx_newkeys(&p->kx); });
 676 }
 677
 678 /* --- @p_interval@ --- *
 679  *
 680  * Arguments:   ---
 681  *
 682  * Returns:     ---
 683  *
 684  * Use:         Called periodically to do tidying.
 685  */
 686
 687 void p_interval(void)
 688 {
 689   p_keyreload();
 690   FOREACH_PEER(p, { ksl_prune(&p->ks); });
 691 }
 692
 693 /* --- @p_stats@ --- *
 694  *
 695  * Arguments:   @peer *p@ = pointer to a peer block
 696  *
 697  * Returns:     A pointer to the peer's statistics.
 698  */
 699
 700 stats *p_stats(peer *p) { return (&p->st); }
 701
 702 /* --- @p_ifname@ --- *
 703  *
 704  * Arguments:   @peer *p@ = pointer to a peer block
 705  *
 706  * Returns:     A pointer to the peer's interface name.
 707  */
 708
 709 const char *p_ifname(peer *p) { return (p->ifname); }
 710
 711 /* --- @p_setifname@ --- *
 712  *
 713  * Arguments:   @peer *p@ = pointer to a peer block
 714  *              @const char *name@ = pointer to the new name
 715  *
 716  * Returns:     ---
 717  *
 718  * Use:         Changes the name held for a peer's interface.
 719  */
 720
 721 void p_setifname(peer *p, const char *name)
 722 {
 723   xfree(p->ifname);
 724   p->ifname = xstrdup(name);
 725   if (p->spec.tops->setifname)
 726     p->spec.tops->setifname(p->t, name);
 727 }
 728
 729 /* --- @p_addr@ --- *
 730  *
 731  * Arguments:   @peer *p@ = pointer to a peer block
 732  *
 733  * Returns:     A pointer to the peer's address.
 734  */
 735
 736 const addr *p_addr(peer *p) { return (&p->spec.sa); }
 737
 738 /* --- @p_init@ --- *
 739  *
 740  * Arguments:   @struct in_addr addr@ = address to bind to
 741  *              @unsigned port@ = port number to listen to
 742  *
 743  * Returns:     ---
 744  *
 745  * Use:         Initializes the peer system; creates the socket.
 746  */
 747
 748 void p_init(struct in_addr addr, unsigned port)
 749 {
 750   int fd;
 751   struct sockaddr_in sin;
 752   int len = PKBUFSZ;
 753
 754   /* --- Note on socket buffer sizes --- *
 755    *
 756    * For some bizarre reason, Linux 2.2 (at least) doubles the socket buffer
 757    * sizes I pass to @setsockopt@.  I'm not putting special-case code here
 758    * for Linux: BSD (at least TCPv2) does what I tell it rather than second-
 759    * guessing me.
 760    */
 761
 762   if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
 763     die(EXIT_FAILURE, "socket creation failed: %s", strerror(errno));
 764   BURN(sin);
 765   sin.sin_family = AF_INET;
 766   sin.sin_addr = addr;
 767   sin.sin_port = htons(port);
 768   if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)))
 769     die(EXIT_FAILURE, "bind failed: %s", strerror(errno));
 770   if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len)) ||
 771       setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &len, sizeof(len))) {
 772     die(EXIT_FAILURE, "failed to set socket buffer sizes: %s",
 773         strerror(errno));
 774   }
 775   fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
 776   sel_initfile(&sel, &sock, fd, SEL_READ, p_read, 0);
 777   sel_addfile(&sock);
 778   T( trace(T_PEER, "peer: created socket"); )
 779
 780   sym_create(&byname);
 781   am_create(&byaddr);
 782 }
 783
 784 /* --- @p_port@ --- *
 785  *
 786  * Arguments:   ---
 787  *
 788  * Returns:     Port number used for socket.
 789  */
 790
 791 unsigned p_port(void)
 792 {
 793   addr a;
 794   size_t sz = sizeof(addr);
 795
 796   if (getsockname(sock.fd, &a.sa, &sz))
 797     die(EXIT_FAILURE, "couldn't read port number: %s", strerror(errno));
 798   assert(a.sa.sa_family == AF_INET);
 799   return (ntohs(a.sin.sin_port));
 800 }
 801
 802 /* --- @p_keepalive@ --- *
 803  *
 804  * Arguments:   @struct timeval *now@ = the current time
 805  *              @void *pv@ = peer to wake up
 806  *
 807  * Returns:     ---
 808  *
 809  * Use:         Sends a keepalive ping message to its peer.
 810  */
 811
 812 static void p_keepalive(struct timeval *now, void *pv)
 813 {
 814   peer *p = pv;
 815   p_txstart(p, MSG_MISC | MISC_NOP); p_dotxend(p);
 816   T( trace(T_PEER, "peer: sent keepalive to %s", p->spec.name); )
 817   p_setkatimer(p);
 818 }
 819
 820 /* --- @p_setkatimer@ --- *
 821  *
 822  * Arguments:   @peer *p@ = peer to set
 823  *
 824  * Returns:     ---
 825  *
 826  * Use:         Resets the keepalive timer thing.
 827  */
 828
 829 static void p_setkatimer(peer *p)
 830 {
 831   struct timeval tv;
 832
 833   if (!p->spec.t_ka)
 834     return;
 835   gettimeofday(&tv, 0);
 836   tv.tv_sec += p->spec.t_ka;
 837   sel_addtimer(&sel, &p->tka, &tv, p_keepalive, p);
 838 }
 839
 840 /* --- @p_create@ --- *
 841  *
 842  * Arguments:   @peerspec *spec@ = information about this peer
 843  *
 844  * Returns:     Pointer to the peer block, or null if it failed.
 845  *
 846  * Use:         Creates a new named peer block.  No peer is actually attached
 847  *              by this point.
 848  */
 849
 850 peer *p_create(peerspec *spec)
 851 {
 852   peer *p = CREATE(peer);
 853   const tunnel_ops *tops = spec->tops;
 854   int fd;
 855   unsigned f;
 856
 857   p->byname = sym_find(&byname, spec->name, -1, sizeof(peer_byname), &f);
 858   if (f) goto tidy_0;
 859   p->byaddr = am_find(&byaddr, &spec->sa, sizeof(peer_byaddr), &f);
 860   if (f) goto tidy_1;
 861   p->byname->p = p->byaddr->p = p;
 862
 863   T( trace(T_PEER, "peer: creating new peer `%s'", spec->name); )
 864   p->spec = *spec;
 865   p->spec.name = (/*unconst*/ char *)SYM_NAME(p->byname);
 866   if (spec->tag)
 867     p->spec.tag = xstrdup(spec->tag);
 868   p->ks = 0;
 869   p->pings = 0;
 870   p->ifname = 0;
 871   memset(&p->st, 0, sizeof(stats));
 872   p->st.t_start = time(0);
 873   if (!(tops->flags & TUNF_PRIVOPEN))
 874     fd = -1;
 875   else if ((fd = ps_tunfd(tops, &p->ifname)) < 0)
 876     goto tidy_2;
 877   if ((p->t = tops->create(p, fd, &p->ifname)) == 0)
 878     goto tidy_3;
 879   T( trace(T_TUNNEL, "peer: attached interface %s to peer `%s'",
 880            p->ifname, p_name(p)); )
 881   p_setkatimer(p);
 882   if (kx_init(&p->kx, p, &p->ks, p->spec.f & PSF_KXMASK))
 883     goto tidy_4;
 884   a_notify("ADD",
 885            "?PEER", p,
 886            "%s", p->ifname,
 887            "?ADDR", &p->spec.sa,
 888            A_END);
 889   if (!(p->spec.f & KXF_CORK)) {
 890     a_notify("KXSTART", "?PEER", p, A_END);
 891     /* Couldn't tell anyone before */
 892   }
 893   if (p->spec.f & PSF_MOBILE) nmobile++;
 894   return (p);
 895
 896 tidy_4:
 897   if (spec->t_ka)
 898     sel_rmtimer(&p->tka);
 899   xfree(p->ifname);
 900   p->t->ops->destroy(p->t);
 901 tidy_3:
 902   if (fd >= 0) close(fd);
 903 tidy_2:
 904   am_remove(&byaddr, p->byaddr);
 905   if (p->spec.tag) xfree(p->spec.tag);
 906 tidy_1:
 907   sym_remove(&byname, p->byname);
 908 tidy_0:
 909   DESTROY(p);
 910   return (0);
 911 }
 912
 913 /* --- @p_name@ --- *
 914  *
 915  * Arguments:   @peer *p@ = pointer to a peer block
 916  *
 917  * Returns:     A pointer to the peer's name.
 918  */
 919
 920 const char *p_name(peer *p)
 921   { if (p) return (p->spec.name); else return ("-"); }
 922
 923 /* --- @p_tag@ --- *
 924  *
 925  * Arguments:   @peer *p@ = pointer to a peer block
 926  *
 927  * Returns:     A pointer to the peer's public key tag.
 928  */
 929
 930 const char *p_tag(peer *p)
 931   { return (p->spec.tag ? p->spec.tag : p->spec.name); }
 932
 933 /* --- @p_spec@ --- *
 934  *
 935  * Arguments:   @peer *p@ = pointer to a peer block
 936  *
 937  * Returns:     Pointer to the peer's specification
 938  */
 939
 940 const peerspec *p_spec(peer *p) { return (&p->spec); }
 941
 942 /* --- @p_findbyaddr@ --- *
 943  *
 944  * Arguments:   @const addr *a@ = address to look up
 945  *
 946  * Returns:     Pointer to the peer block, or null if not found.
 947  *
 948  * Use:         Finds a peer by address.
 949  */
 950
 951 peer *p_findbyaddr(const addr *a)
 952 {
 953   peer_byaddr *pa;
 954
 955   if ((pa = am_find(&byaddr, a, 0, 0)) != 0) {
 956     assert(pa->p);
 957     return (pa->p);
 958   }
 959   return (0);
 960 }
 961
 962 /* --- @p_find@ --- *
 963  *
 964  * Arguments:   @const char *name@ = name to look up
 965  *
 966  * Returns:     Pointer to the peer block, or null if not found.
 967  *
 968  * Use:         Finds a peer by name.
 969  */
 970
 971 peer *p_find(const char *name)
 972 {
 973   peer_byname *pn;
 974
 975   if ((pn = sym_find(&byname, name, -1, 0, 0)) != 0)
 976     return (pn->p);
 977   return (0);
 978 }
 979
 980 /* --- @p_destroy@ --- *
 981  *
 982  * Arguments:   @peer *p@ = pointer to a peer
 983  *
 984  * Returns:     ---
 985  *
 986  * Use:         Destroys a peer.
 987  */
 988
 989 void p_destroy(peer *p)
 990 {
 991   ping *pg, *ppg;
 992
 993   T( trace(T_PEER, "peer: destroying peer `%s'", p->spec.name); )
 994   a_notify("KILL", "%s", p->spec.name, A_END);
 995   ksl_free(&p->ks);
 996   kx_free(&p->kx);
 997   if (p->spec.f & PSF_MOBILE)
 998     nmobile--;
 999   if (p->ifname)
1000     xfree(p->ifname);
1001   if (p->spec.tag)
1002     xfree(p->spec.tag);
1003   p->t->ops->destroy(p->t);
1004   if (p->spec.t_ka)
1005     sel_rmtimer(&p->tka);
1006   for (pg = p->pings; pg; pg = ppg) {
1007     ppg = pg->next;
1008     p_pingdone(pg, PING_PEERDIED);
1009   }
1010   sym_remove(&byname, p->byname);
1011   am_remove(&byaddr, p->byaddr);
1012   DESTROY(p);
1013 }
1014
1015 /* --- @p_mkiter@ --- *
1016  *
1017  * Arguments:   @peer_iter *i@ = pointer to an iterator
1018  *
1019  * Returns:     ---
1020  *
1021  * Use:         Initializes the iterator.
1022  */
1023
1024 void p_mkiter(peer_iter *i) { sym_mkiter(&i->i, &byname); }
1025
1026 /* --- @p_next@ --- *
1027  *
1028  * Arguments:   @peer_iter *i@ = pointer to an iterator
1029  *
1030  * Returns:     Next peer, or null if at the end.
1031  *
1032  * Use:         Returns the next peer.
1033  */
1034
1035 peer *p_next(peer_iter *i)
1036 {
1037   peer_byname *pn;
1038
1039   if ((pn = sym_next(&i->i)) == 0)
1040     return (0);
1041   return (pn->p);
1042 }
1043
1044 /*----- That's all, folks -------------------------------------------------*/