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

   1 /* -*-c-*-
   2  *
   3  * $Id$
   4  *
   5  * Communication with the peer
   6  *
   7  * (c) 2001 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of Trivial IP Encryption (TrIPE).
  13  *
  14  * TrIPE is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * TrIPE is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with TrIPE; if not, write to the Free Software Foundation,
  26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  */
  28
  29 /*----- Header files ------------------------------------------------------*/
  30
  31 #include "tripe.h"
  32
  33 /*----- Static variables --------------------------------------------------*/
  34
  35 static peer *peers = 0;
  36 static sel_file sock;
  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 static void checktimers(void)
  57 {
  58   sel_timer *t, **tt;
  59
  60   tt = &sel.timers;
  61   while (*tt) {
  62     assert((*tt)->prev == tt);
  63     tt = &(*tt)->next;
  64   }
  65 }
  66
  67 /* --- @p_pingtype@ --- *
  68  *
  69  * Arguments:   @unsigned msg@ = message type
  70  *
  71  * Returns:     String to describe the message.
  72  */
  73
  74 static const char *p_pingtype(unsigned msg)
  75 {
  76   switch (msg & MSG_TYPEMASK) {
  77     case MISC_PING:
  78     case MISC_PONG:
  79       return "transport-ping";
  80     case MISC_EPING:
  81     case MISC_EPONG:
  82       return "encrypted-ping";
  83     default:
  84       abort();
  85   }
  86 }
  87
  88 /* --- @p_ponged@ --- *
  89  *
  90  * Arguments:   @peer *p@ = peer packet arrived from
  91  *              @unsigned msg@ = message type
  92  *              @buf *b@ = buffer containing payload
  93  *
  94  * Returns:     ---
  95  *
  96  * Use:         Processes a ping response.
  97  */
  98
  99 static void p_ponged(peer *p, unsigned msg, buf *b)
 100 {
 101   uint32 id;
 102   const octet *magic;
 103   ping *pg;
 104
 105   IF_TRACING(T_PEER, {
 106     trace(T_PEER, "peer: received %s reply from %s",
 107           p_pingtype(msg), p->spec.name);
 108     trace_block(T_PACKET, "peer: ping contents", BBASE(b), BSZ(b));
 109   })
 110
 111   if (buf_getu32(b, &id) ||
 112       (magic = buf_get(b, sizeof(pg->magic))) == 0 ||
 113       BLEFT(b)) {
 114     a_warn("PEER %s malformed-%s", p->spec.name, p_pingtype(msg));
 115     return;
 116   }
 117
 118   for (pg = p->pings; pg; pg = pg->next) {
 119     if (pg->id == id)
 120       goto found;
 121   }
 122   a_warn("PEER %s unexpected-%s 0x%08lx",
 123          p->spec.name, p_pingtype(msg), (unsigned long)id);
 124   return;
 125
 126 found:
 127   if (memcmp(magic, pg->magic, sizeof(pg->magic)) != 0) {
 128     a_warn("PEER %s corrupt-%s", p->spec.name, p_pingtype(msg));
 129     return;
 130   }
 131   p_pingdone(pg, PING_OK);
 132 }
 133
 134 /* --- @p_read@ --- *
 135  *
 136  * Arguments:   @int fd@ = file descriptor to read from
 137  *              @unsigned mode@ = what happened
 138  *              @void *v@ = an uninteresting pointer
 139  *
 140  * Returns:     ---
 141  *
 142  * Use:         Reads a packet from somewhere.
 143  */
 144
 145 static void p_read(int fd, unsigned mode, void *v)
 146 {
 147   peer *p;
 148   addr a;
 149   size_t sz;
 150   ssize_t n;
 151   int ch;
 152   buf b, bb;
 153
 154   /* --- Read the data --- */
 155
 156   TIMER;
 157   sz = sizeof(addr);
 158   n = recvfrom(fd, buf_i, sizeof(buf_i), 0, &a.sa, &sz);
 159   if (n < 0) {
 160     a_warn("PEER - socket-read-error -- %s", strerror(errno));
 161     return;
 162   }
 163
 164   /* --- Find the appropriate peer --- */
 165
 166   assert(a.sa.sa_family == AF_INET);
 167   for (p = peers; p; p = p->next) {
 168     if (p->spec.sa.sin.sin_addr.s_addr == a.sin.sin_addr.s_addr &&
 169         p->spec.sa.sin.sin_port == a.sin.sin_port)
 170       goto found;
 171   }
 172   a_warn("PEER - unexpected-source INET %s %u",
 173          inet_ntoa(a.sin.sin_addr), (unsigned)ntohs(a.sin.sin_port));
 174   return;
 175
 176 found:
 177   IF_TRACING(T_PEER, {
 178     trace(T_PEER, "peer: packet received from `%s'", p->spec.name);
 179     trace_block(T_PACKET, "peer: packet contents", buf_i, n);
 180   })
 181
 182   /* --- Pick the packet apart --- */
 183
 184   p->st.t_last = time(0);
 185   p->st.n_in++;
 186   p->st.sz_in += n;
 187   buf_init(&b, buf_i, n);
 188   if ((ch = buf_getbyte(&b)) < 0) {
 189     a_warn("PEER %s bad-packet no-type", p->spec.name);
 190     return;
 191   }
 192   switch (ch & MSG_CATMASK) {
 193     case MSG_PACKET:
 194       if (ch & MSG_TYPEMASK) {
 195         a_warn("PEER %s bad-packet unknown-type 0x%02x", p->spec.name, ch);
 196         p->st.n_reject++;
 197         return;
 198       }
 199       buf_init(&bb, buf_o, sizeof(buf_o));
 200       if (ksl_decrypt(&p->ks, MSG_PACKET, &b, &bb)) {
 201         p->st.n_reject++;
 202         a_warn("PEER %s decrypt-failed", p->spec.name);
 203         return;
 204       }
 205       if (BOK(&bb)) {
 206         p->st.n_ipin++;
 207         p->st.sz_ipin += BSZ(&b);
 208         p->t->ops->inject(p->t, &bb);
 209       } else {
 210         p->st.n_reject++;
 211         a_warn("PEER %s packet-build-failed", p->spec.name);
 212       }
 213       break;
 214     case MSG_KEYEXCH:
 215       kx_message(&p->kx, ch & MSG_TYPEMASK, &b);
 216       break;
 217     case MSG_MISC:
 218       switch (ch & MSG_TYPEMASK) {
 219         case MISC_NOP:
 220           T( trace(T_PEER, "peer: received NOP packet"); )
 221           break;
 222         case MISC_PING:
 223           buf_put(p_txstart(p, MSG_MISC | MISC_PONG), BCUR(&b), BLEFT(&b));
 224           p_txend(p);
 225           break;
 226         case MISC_PONG:
 227           p_ponged(p, MISC_PONG, &b);
 228           break;
 229         case MISC_EPING:
 230           buf_init(&bb, buf_t, sizeof(buf_t));
 231           if (ksl_decrypt(&p->ks, ch, &b, &bb)) {
 232             p->st.n_reject++;
 233             a_warn("PEER %s decrypt-failed", p->spec.name);
 234             return;
 235           }
 236           if (BOK(&bb)) {
 237             buf_flip(&bb);
 238             if (ksl_encrypt(&p->ks, MSG_MISC | MISC_EPONG, &bb,
 239                             p_txstart(p, MSG_MISC | MISC_EPONG)))
 240               kx_start(&p->kx, 0);
 241             p_txend(p);
 242           }
 243           break;
 244         case MISC_EPONG:
 245           buf_init(&bb, buf_t, sizeof(buf_t));
 246           if (ksl_decrypt(&p->ks, ch, &b, &bb)) {
 247             p->st.n_reject++;
 248             a_warn("PEER %s decrypt-failed", p->spec.name);
 249             return;
 250           }
 251           if (BOK(&bb)) {
 252             buf_flip(&bb);
 253             p_ponged(p, MISC_EPONG, &bb);
 254           }
 255           break;
 256       }
 257       break;
 258     default:
 259       p->st.n_reject++;
 260       a_warn("PEER %s bad-packet unknown-category 0x%02x", p->spec.name, ch);
 261       break;
 262   }
 263 }
 264
 265 /* --- @p_txstart@ --- *
 266  *
 267  * Arguments:   @peer *p@ = pointer to peer block
 268  *              @unsigned msg@ = message type code
 269  *
 270  * Returns:     A pointer to a buffer to write to.
 271  *
 272  * Use:         Starts sending to a peer.  Only one send can happen at a
 273  *              time.
 274  */
 275
 276 buf *p_txstart(peer *p, unsigned msg)
 277 {
 278   buf_init(&p->b, buf_o, sizeof(buf_o));
 279   buf_putbyte(&p->b, msg);
 280   return (&p->b);
 281 }
 282
 283 /* --- @p_txend@ --- *
 284  *
 285  * Arguments:   @peer *p@ = pointer to peer block
 286  *
 287  * Returns:     ---
 288  *
 289  * Use:         Sends a packet to the peer.
 290  */
 291
 292 static void p_setkatimer(peer *);
 293
 294 static int p_dotxend(peer *p)
 295 {
 296   if (!BOK(&p->b)) {
 297     a_warn("PEER %s packet-build-failed", p->spec.name);
 298     return (0);
 299   }
 300   IF_TRACING(T_PEER, trace_block(T_PACKET, "peer: sending packet",
 301                                  BBASE(&p->b), BLEN(&p->b)); )
 302   if (sendto(sock.fd, BBASE(&p->b), BLEN(&p->b),
 303              0, &p->spec.sa.sa, p->spec.sasz) < 0) {
 304     a_warn("PEER %s socket-write-error -- %s",
 305            p->spec.name, strerror(errno));
 306     return (0);
 307   } else {
 308     p->st.n_out++;
 309     p->st.sz_out += BLEN(&p->b);
 310     return (1);
 311   }
 312 }
 313
 314 void p_txend(peer *p)
 315 {
 316   if (p_dotxend(p) && p->spec.t_ka) {
 317     sel_rmtimer(&p->tka);
 318     p_setkatimer(p);
 319   }
 320 }
 321
 322 /* --- @p_pingwrite@ --- *
 323  *
 324  * Arguments:   @ping *p@ = ping structure
 325  *              @buf *b@ = buffer to write in
 326  *
 327  * Returns:     ---
 328  *
 329  * Use:         Fills in a ping structure and writes the packet payload.
 330  */
 331
 332 static void p_pingwrite(ping *p, buf *b)
 333 {
 334   static uint32 seq = 0;
 335
 336   p->id = U32(seq++);
 337   GR_FILL(&rand_global, p->magic, sizeof(p->magic));
 338   buf_putu32(b, p->id);
 339   buf_put(b, p->magic, sizeof(p->magic));
 340 }
 341
 342 /* --- @p_pingdone@ --- *
 343  *
 344  * Arguments:   @ping *p@ = ping structure
 345  *              @int rc@ = return code to pass on
 346  *
 347  * Returns:     ---
 348  *
 349  * Use:         Disposes of a ping structure, maybe sending a notification.
 350  */
 351
 352 void p_pingdone(ping *p, int rc)
 353 {
 354   if (p->prev) p->prev->next = p->next;
 355   else p->p->pings = p->next;
 356   if (p->next) p->next->prev = p->prev;
 357   if (rc != PING_TIMEOUT) sel_rmtimer(&p->t);
 358   T( trace(T_PEER, "peer: ping 0x%08lx done (rc = %d)",
 359            (unsigned long)p->id, rc); )
 360 checktimers();
 361   if (rc >= 0) p->func(rc, p->arg);
 362 }
 363
 364 /* --- @p_pingtimeout@ --- *
 365  *
 366  * Arguments:   @struct timeval *now@ = the time now
 367  *              @void *pv@ = pointer to ping block
 368  *
 369  * Returns:     ---
 370  *
 371  * Use:         Called when a ping times out.
 372  */
 373
 374 static void p_pingtimeout(struct timeval *now, void *pv)
 375 {
 376   ping *p = pv;
 377
 378   T( trace(T_PEER, "peer: ping 0x%08lx timed out", (unsigned long)p->id); )
 379   p_pingdone(p, PING_TIMEOUT);
 380 }
 381
 382 /* --- @p_pingsend@ --- *
 383  *
 384  * Arguments:   @peer *p@ = destination peer
 385  *              @ping *pg@ = structure to fill in
 386  *              @unsigned type@ = message type
 387  *              @unsigned long timeout@ = how long to wait before giving up
 388  *              @void (*func)(int, void *)@ = callback function
 389  *              @void *arg@ = argument for callback
 390  *
 391  * Returns:     Zero if successful, nonzero if it failed.
 392  *
 393  * Use:         Sends a ping to a peer.  Call @func@ with a nonzero argument
 394  *              if we get an answer within the timeout, or zero if no answer.
 395  */
 396
 397 int p_pingsend(peer *p, ping *pg, unsigned type,
 398                unsigned long timeout,
 399                void (*func)(int, void *), void *arg)
 400 {
 401   buf *b, bb;
 402   struct timeval tv;
 403
 404   switch (type) {
 405     case MISC_PING:
 406       pg->msg = MISC_PONG;
 407       b = p_txstart(p, MSG_MISC | MISC_PING);
 408       p_pingwrite(pg, b);
 409       p_txend(p);
 410       break;
 411     case MISC_EPING:
 412       pg->msg = MISC_EPONG;
 413       b = p_txstart(p, MSG_MISC | MISC_EPING);
 414       buf_init(&bb, buf_t, sizeof(buf_t));
 415       p_pingwrite(pg, &bb);
 416       buf_flip(&bb);
 417       if (ksl_encrypt(&p->ks, MSG_MISC | MISC_EPING, &bb, b))
 418         kx_start(&p->kx, 0);
 419       if (!BOK(b))
 420         return (-1);
 421       p_txend(p);
 422       break;
 423     default:
 424       abort();
 425       break;
 426   }
 427
 428   pg->next = p->pings;
 429   pg->prev = 0;
 430   pg->p = p;
 431   pg->func = func;
 432   pg->arg = arg;
 433   if (p->pings) p->pings->prev = pg;
 434   p->pings = pg;
 435   gettimeofday(&tv, 0);
 436   tv.tv_sec += timeout;
 437   sel_addtimer(&sel, &pg->t, &tv, p_pingtimeout, pg);
 438 checktimers();
 439   T( trace(T_PEER, "peer: send %s 0x%08lx to %s",
 440            p_pingtype(type), (unsigned long)pg->id, p->spec.name); )
 441   return (0);
 442 }
 443
 444 /* --- @p_tun@ --- *
 445  *
 446  * Arguments:   @peer *p@ = pointer to peer block
 447  *              @buf *b@ = buffer containing incoming packet
 448  *
 449  * Returns:     ---
 450  *
 451  * Use:         Handles a packet which needs to be sent to a peer.
 452  */
 453
 454 void p_tun(peer *p, buf *b)
 455 {
 456   buf *bb = p_txstart(p, MSG_PACKET);
 457
 458   TIMER;
 459   if (ksl_encrypt(&p->ks, MSG_PACKET, b, bb))
 460     kx_start(&p->kx, 0);
 461   if (BOK(bb) && BLEN(bb)) {
 462     p->st.n_ipout++;
 463     p->st.sz_ipout += BLEN(bb);
 464     p_txend(p);
 465   }
 466 }
 467
 468 /* --- @p_keyreload@ --- *
 469  *
 470  * Arguments:   ---
 471  *
 472  * Returns:     ---
 473  *
 474  * Use:         Forces a check of the daemon's keyring files.
 475  */
 476
 477 void p_keyreload(void)
 478 {
 479   peer *p;
 480
 481   if (km_reload()) {
 482     for (p = peers; p; p = p->next)
 483       kx_newkeys(&p->kx);
 484   }
 485 }
 486
 487 /* --- @p_interval@ --- *
 488  *
 489  * Arguments:   ---
 490  *
 491  * Returns:     ---
 492  *
 493  * Use:         Called periodically to do tidying.
 494  */
 495
 496 void p_interval(void)
 497 {
 498   peer *p;
 499
 500   p_keyreload();
 501   for (p = peers; p; p = p->next)
 502     ksl_prune(&p->ks);
 503 }
 504
 505 /* --- @p_stats@ --- *
 506  *
 507  * Arguments:   @peer *p@ = pointer to a peer block
 508  *
 509  * Returns:     A pointer to the peer's statistics.
 510  */
 511
 512 stats *p_stats(peer *p) { return (&p->st); }
 513
 514 /* --- @p_ifname@ --- *
 515  *
 516  * Arguments:   @peer *p@ = pointer to a peer block
 517  *
 518  * Returns:     A pointer to the peer's interface name.
 519  */
 520
 521 const char *p_ifname(peer *p) { return (p->t->ops->ifname(p->t)); }
 522
 523 /* --- @p_addr@ --- *
 524  *
 525  * Arguments:   @peer *p@ = pointer to a peer block
 526  *
 527  * Returns:     A pointer to the peer's address.
 528  */
 529
 530 const addr *p_addr(peer *p) { return (&p->spec.sa); }
 531
 532 /* --- @p_init@ --- *
 533  *
 534  * Arguments:   @struct in_addr addr@ = address to bind to
 535  *              @unsigned port@ = port number to listen to
 536  *
 537  * Returns:     ---
 538  *
 539  * Use:         Initializes the peer system; creates the socket.
 540  */
 541
 542 void p_init(struct in_addr addr, unsigned port)
 543 {
 544   int fd;
 545   struct sockaddr_in sin;
 546   int len = PKBUFSZ;
 547
 548   /* --- Note on socket buffer sizes --- *
 549    *
 550    * For some bizarre reason, Linux 2.2 (at least) doubles the socket buffer
 551    * sizes I pass to @setsockopt@.  I'm not putting special-case code here
 552    * for Linux: BSD (at least TCPv2) does what I tell it rather than second-
 553    * guessing me.
 554    */
 555
 556   if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
 557     die(EXIT_FAILURE, "socket creation failed: %s", strerror(errno));
 558   BURN(sin);
 559   sin.sin_family = AF_INET;
 560   sin.sin_addr = addr;
 561   sin.sin_port = htons(port);
 562   if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)))
 563     die(EXIT_FAILURE, "bind failed: %s", strerror(errno));
 564   if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len)) ||
 565       setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &len, sizeof(len))) {
 566     die(EXIT_FAILURE, "failed to set socket buffer sizes: %s",
 567         strerror(errno));
 568   }
 569   fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
 570   sel_initfile(&sel, &sock, fd, SEL_READ, p_read, 0);
 571   sel_addfile(&sock);
 572   T( trace(T_PEER, "peer: created socket"); )
 573 }
 574
 575 /* --- @p_port@ --- *
 576  *
 577  * Arguments:   ---
 578  *
 579  * Returns:     Port number used for socket.
 580  */
 581
 582 unsigned p_port(void)
 583 {
 584   addr a;
 585   size_t sz = sizeof(addr);
 586
 587   if (getsockname(sock.fd, &a.sa, &sz))
 588     die(EXIT_FAILURE, "couldn't read port number: %s", strerror(errno));
 589   assert(a.sa.sa_family == AF_INET);
 590   return (ntohs(a.sin.sin_port));
 591 }
 592
 593 /* --- @p_keepalive@ --- *
 594  *
 595  * Arguments:   @struct timeval *now@ = the current time
 596  *              @void *pv@ = peer to wake up
 597  *
 598  * Returns:     ---
 599  *
 600  * Use:         Sends a keepalive ping message to its peer.
 601  */
 602
 603 static void p_keepalive(struct timeval *now, void *pv)
 604 {
 605   peer *p = pv;
 606   p_txstart(p, MSG_MISC | MISC_NOP); p_dotxend(p);
 607   T( trace(T_PEER, "peer: sent keepalive to %s", p->spec.name); )
 608   p_setkatimer(p);
 609 }
 610
 611 /* --- @p_setkatimer@ --- *
 612  *
 613  * Arguments:   @peer *p@ = peer to set
 614  *
 615  * Returns:     ---
 616  *
 617  * Use:         Resets the keepalive timer thing.
 618  */
 619
 620 static void p_setkatimer(peer *p)
 621 {
 622   struct timeval tv;
 623
 624   if (!p->spec.t_ka)
 625     return;
 626   gettimeofday(&tv, 0);
 627   tv.tv_sec += p->spec.t_ka;
 628   sel_addtimer(&sel, &p->tka, &tv, p_keepalive, p);
 629 }
 630
 631 /* --- @p_create@ --- *
 632  *
 633  * Arguments:   @peerspec *spec@ = information about this peer
 634  *
 635  * Returns:     Pointer to the peer block, or null if it failed.
 636  *
 637  * Use:         Creates a new named peer block.  No peer is actually attached
 638  *              by this point.
 639  */
 640
 641 peer *p_create(peerspec *spec)
 642 {
 643   peer *p = CREATE(peer);
 644
 645   T( trace(T_PEER, "peer: creating new peer `%s'", spec->name); )
 646   p->spec = *spec;
 647   p->spec.name = xstrdup(spec->name);
 648   p->ks = 0;
 649   p->prev = 0;
 650   p->pings = 0;
 651   memset(&p->st, 0, sizeof(stats));
 652   p->st.t_start = time(0);
 653   if ((p->t = spec->tops->create(p)) == 0)
 654     goto tidy_0;
 655   p_setkatimer(p);
 656   if (kx_init(&p->kx, p, &p->ks))
 657     goto tidy_1;
 658   p->next = peers;
 659   if (peers)
 660     peers->prev = p;
 661   peers = p;
 662   switch (p->spec.sa.sa.sa_family) {
 663     case AF_INET:
 664       a_notify("ADD %s %s INET %s %u",
 665                spec->name,
 666                p->t->ops->ifname(p->t),
 667                inet_ntoa(p->spec.sa.sin.sin_addr),
 668                (unsigned)ntohs(p->spec.sa.sin.sin_port));
 669       break;
 670     default:
 671       a_notify("ADD %s %s UNKNOWN", spec->name, p->t->ops->ifname(p->t));
 672       break;
 673   }
 674   a_notify("KXSTART %s", spec->name);   /* Couldn't tell anyone before */
 675   return (p);
 676
 677 tidy_1:
 678   if (spec->t_ka)
 679     sel_rmtimer(&p->tka);
 680   p->t->ops->destroy(p->t);
 681 tidy_0:
 682   xfree(p->spec.name);
 683   DESTROY(p);
 684   return (0);
 685 }
 686
 687 /* --- @p_name@ --- *
 688  *
 689  * Arguments:   @peer *p@ = pointer to a peer block
 690  *
 691  * Returns:     A pointer to the peer's name.
 692  */
 693
 694 const char *p_name(peer *p) { return (p->spec.name); }
 695
 696 /* --- @p_spec@ --- *
 697  *
 698  * Arguments:   @peer *p@ = pointer to a peer block
 699  *
 700  * Returns:     Pointer to the peer's specification
 701  */
 702
 703 const peerspec *p_spec(peer *p) { return (&p->spec); }
 704
 705 /* --- @p_find@ --- *
 706  *
 707  * Arguments:   @const char *name@ = name to look up
 708  *
 709  * Returns:     Pointer to the peer block, or null if not found.
 710  *
 711  * Use:         Finds a peer by name.
 712  */
 713
 714 peer *p_find(const char *name)
 715 {
 716   peer *p;
 717   for (p = peers; p; p = p->next) {
 718     if (strcmp(name, p->spec.name) == 0)
 719       return (p);
 720   }
 721   return (0);
 722 }
 723
 724 /* --- @p_destroy@ --- *
 725  *
 726  * Arguments:   @peer *p@ = pointer to a peer
 727  *
 728  * Returns:     ---
 729  *
 730  * Use:         Destroys a peer.
 731  */
 732
 733 void p_destroy(peer *p)
 734 {
 735   ping *pg, *ppg;
 736
 737   T( trace(T_PEER, "peer: destroying peer `%s'", p->spec.name); )
 738   a_notify("KILL %s", p->spec.name);
 739   ksl_free(&p->ks);
 740   kx_free(&p->kx);
 741   p->t->ops->destroy(p->t);
 742   if (p->spec.t_ka)
 743     sel_rmtimer(&p->tka);
 744   xfree(p->spec.name);
 745   for (pg = p->pings; pg; pg = ppg) {
 746     ppg = pg->next;
 747     p_pingdone(pg, PING_PEERDIED);
 748   }
 749   if (p->next)
 750     p->next->prev = p->prev;
 751   if (p->prev)
 752     p->prev->next = p->next;
 753   else
 754     peers = p->next;
 755   DESTROY(p);
 756 }
 757
 758 /* --- @p_first@, @p_next@ --- *
 759  *
 760  * Arguments:   @peer *p@ = a peer block
 761  *
 762  * Returns:     @peer_first@ returns the first peer in some ordering;
 763  *              @peer_next@ returns the peer following a given one in the
 764  *              same ordering.  Null is returned for the end of the list.
 765  */
 766
 767 peer *p_first(void) { return (peers); }
 768 peer *p_next(peer *p) { return (p->next); }
 769
 770 /*----- That's all, folks -------------------------------------------------*/