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