site.c

   1 /* site.c - manage communication with a remote network site */
   2
   3 /* The 'site' code doesn't know anything about the structure of the
   4    packets it's transmitting.  In fact, under the new netlink
   5    configuration scheme it doesn't need to know anything at all about
   6    IP addresses, except how to contact its peer.  This means it could
   7    potentially be used to tunnel other protocols too (IPv6, IPX, plain
   8    old Ethernet frames) if appropriate netlink code can be written
   9    (and that ought not to be too hard, eg. using the TUN/TAP device to
  10    pretend to be an Ethernet interface).  */
  11
  12 /* At some point in the future the netlink code will be asked for
  13    configuration information to go in the PING/PONG packets at the end
  14    of the key exchange. */
  15
  16 #include "secnet.h"
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <limits.h>
  20 #include <assert.h>
  21 #include <sys/socket.h>
  22
  23 #include <sys/mman.h>
  24 #include "util.h"
  25 #include "unaligned.h"
  26 #include "magic.h"
  27
  28 #define SETUP_BUFFER_LEN 2048
  29
  30 #define DEFAULT_KEY_LIFETIME                  (3600*1000) /* [ms] */
  31 #define DEFAULT_KEY_RENEGOTIATE_GAP           (5*60*1000) /* [ms] */
  32 #define DEFAULT_SETUP_RETRIES 5
  33 #define DEFAULT_SETUP_RETRY_INTERVAL             (2*1000) /* [ms] */
  34 #define DEFAULT_WAIT_TIME                       (20*1000) /* [ms] */
  35
  36 #define DEFAULT_MOBILE_KEY_LIFETIME      (2*24*3600*1000) /* [ms] */
  37 #define DEFAULT_MOBILE_KEY_RENEGOTIATE_GAP (12*3600*1000) /* [ms] */
  38 #define DEFAULT_MOBILE_SETUP_RETRIES 30
  39 #define DEFAULT_MOBILE_SETUP_RETRY_INTERVAL      (1*1000) /* [ms] */
  40 #define DEFAULT_MOBILE_WAIT_TIME                (10*1000) /* [ms] */
  41
  42 #define DEFAULT_MOBILE_PEER_EXPIRY            (2*60)      /* [s] */
  43 #define DEFAULT_MOBILE_PEERS_MAX 3 /* send at most this many copies (default) */
  44
  45 /* Each site can be in one of several possible states. */
  46
  47 /* States:
  48    SITE_STOP         - nothing is allowed to happen; tunnel is down;
  49                        all session keys have been erased
  50      -> SITE_RUN upon external instruction
  51    SITE_RUN          - site up, maybe with valid key
  52      -> SITE_RESOLVE upon outgoing packet and no valid key
  53          we start name resolution for the other end of the tunnel
  54      -> SITE_SENTMSG2 upon valid incoming message 1 and suitable time
  55          we send an appropriate message 2
  56    SITE_RESOLVE      - waiting for name resolution
  57      -> SITE_SENTMSG1 upon successful resolution
  58          we send an appropriate message 1
  59      -> SITE_SENTMSG2 upon valid incoming message 1 (then abort resolution)
  60          we abort resolution and
  61      -> SITE_WAIT on timeout or resolution failure
  62    SITE_SENTMSG1
  63      -> SITE_SENTMSG2 upon valid incoming message 1 from higher priority end
  64      -> SITE_SENTMSG3 upon valid incoming message 2
  65      -> SITE_WAIT on timeout
  66    SITE_SENTMSG2
  67      -> SITE_SENTMSG4 upon valid incoming message 3
  68      -> SITE_WAIT on timeout
  69    SITE_SENTMSG3
  70      -> SITE_SENTMSG5 upon valid incoming message 4
  71      -> SITE_WAIT on timeout
  72    SITE_SENTMSG4
  73      -> SITE_RUN upon valid incoming message 5
  74      -> SITE_WAIT on timeout
  75    SITE_SENTMSG5
  76      -> SITE_RUN upon valid incoming message 6
  77      -> SITE_WAIT on timeout
  78    SITE_WAIT         - failed to establish key; do nothing for a while
  79      -> SITE_RUN on timeout
  80    */
  81
  82 #define SITE_STOP     0
  83 #define SITE_RUN      1
  84 #define SITE_RESOLVE  2
  85 #define SITE_SENTMSG1 3
  86 #define SITE_SENTMSG2 4
  87 #define SITE_SENTMSG3 5
  88 #define SITE_SENTMSG4 6
  89 #define SITE_SENTMSG5 7
  90 #define SITE_WAIT     8
  91
  92 static cstring_t state_name(uint32_t state)
  93 {
  94     switch (state) {
  95     case 0: return "STOP";
  96     case 1: return "RUN";
  97     case 2: return "RESOLVE";
  98     case 3: return "SENTMSG1";
  99     case 4: return "SENTMSG2";
 100     case 5: return "SENTMSG3";
 101     case 6: return "SENTMSG4";
 102     case 7: return "SENTMSG5";
 103     case 8: return "WAIT";
 104     default: return "*bad state*";
 105     }
 106 }
 107
 108 #define NONCELEN 8
 109
 110 #define LOG_UNEXPECTED    0x00000001
 111 #define LOG_SETUP_INIT    0x00000002
 112 #define LOG_SETUP_TIMEOUT 0x00000004
 113 #define LOG_ACTIVATE_KEY  0x00000008
 114 #define LOG_TIMEOUT_KEY   0x00000010
 115 #define LOG_SEC           0x00000020
 116 #define LOG_STATE         0x00000040
 117 #define LOG_DROP          0x00000080
 118 #define LOG_DUMP          0x00000100
 119 #define LOG_ERROR         0x00000400
 120 #define LOG_PEER_ADDRS    0x00000800
 121
 122 static struct flagstr log_event_table[]={
 123     { "unexpected", LOG_UNEXPECTED },
 124     { "setup-init", LOG_SETUP_INIT },
 125     { "setup-timeout", LOG_SETUP_TIMEOUT },
 126     { "activate-key", LOG_ACTIVATE_KEY },
 127     { "timeout-key", LOG_TIMEOUT_KEY },
 128     { "security", LOG_SEC },
 129     { "state-change", LOG_STATE },
 130     { "packet-drop", LOG_DROP },
 131     { "dump-packets", LOG_DUMP },
 132     { "errors", LOG_ERROR },
 133     { "peer-addrs", LOG_PEER_ADDRS },
 134     { "default", LOG_SETUP_INIT|LOG_SETUP_TIMEOUT|
 135       LOG_ACTIVATE_KEY|LOG_TIMEOUT_KEY|LOG_SEC|LOG_ERROR },
 136     { "all", 0xffffffff },
 137     { NULL, 0 }
 138 };
 139
 140
 141 /***** TRANSPORT PEERS declarations *****/
 142
 143 /* Details of "mobile peer" semantics:
 144
 145    - We record mobile_peers_max peer address/port numbers ("peers")
 146      for key setup, and separately mobile_peers_max for data
 147      transfer.  If these lists fill up, we retain the newest peers.
 148      (For non-mobile peers we only record one of each.)
 149
 150    - Outgoing packets are sent to every recorded peer in the
 151      applicable list.
 152
 153    - Data transfer peers are straightforward: whenever we successfully
 154      process a data packet, we record the peer.  Also, whenever we
 155      successfully complete a key setup, we merge the key setup
 156      peers into the data transfer peers.
 157
 158      (For "non-mobile" peers we simply copy the peer used for
 159      successful key setup, and don't change the peer otherwise.)
 160
 161    - Key setup peers are slightly more complicated.
 162
 163      Whenever we receive and successfully process a key exchange
 164      packet, we record the peer.
 165
 166      Whenever we try to initiate a key setup, we copy the list of data
 167      transfer peers and use it for key setup.  But we also look to see
 168      if the config supplies an address and port number and if so we
 169      add that as a key setup peer (possibly evicting one of the data
 170      transfer peers we just copied).
 171
 172      (For "non-mobile" peers, if we if we have a configured peer
 173      address and port, we always use that; otherwise if we have a
 174      current data peer address we use that; otherwise we do not
 175      attempt to initiate a key setup for lack of a peer address.)
 176
 177    "Record the peer" means
 178     1. expire any peers last seen >120s ("mobile-peer-expiry") ago
 179     2. add the peer of the just received packet to the applicable list
 180        (possibly evicting older entries)
 181    NB that we do not expire peers until an incoming packet arrives.
 182
 183    */
 184
 185 #define MAX_MOBILE_PEERS_MAX 5 /* send at most this many copies, compiled max */
 186
 187 typedef struct {
 188     struct timeval last;
 189     struct comm_addr addr;
 190 } transport_peer;
 191
 192 typedef struct {
 193 /* configuration information */
 194 /* runtime information */
 195     int npeers;
 196     transport_peer peers[MAX_MOBILE_PEERS_MAX];
 197 } transport_peers;
 198
 199 static void transport_peers_clear(struct site *st, transport_peers *peers);
 200 static int transport_peers_valid(transport_peers *peers);
 201 static void transport_peers_copy(struct site *st, transport_peers *dst,
 202                                  const transport_peers *src);
 203
 204 static void transport_setup_msgok(struct site *st, const struct comm_addr *a);
 205 static void transport_data_msgok(struct site *st, const struct comm_addr *a);
 206 static bool_t transport_compute_setupinit_peers(struct site *st,
 207         const struct comm_addr *configured_addr /* 0 if none or not found */);
 208 static void transport_record_peer(struct site *st, transport_peers *peers,
 209                                   const struct comm_addr *addr, const char *m);
 210
 211 static void transport_xmit(struct site *st, transport_peers *peers,
 212                            struct buffer_if *buf, bool_t candebug);
 213
 214  /***** END of transport peers declarations *****/
 215
 216
 217 struct data_key {
 218     struct transform_inst_if *transform;
 219     uint64_t key_timeout; /* End of life of current key */
 220     uint32_t remote_session_id;
 221 };
 222
 223 struct site {
 224     closure_t cl;
 225     struct site_if ops;
 226 /* configuration information */
 227     string_t localname;
 228     string_t remotename;
 229     bool_t peer_mobile; /* Mobile client support */
 230     int32_t transport_peers_max;
 231     string_t tunname; /* localname<->remotename by default, used in logs */
 232     string_t address; /* DNS name for bootstrapping, optional */
 233     int remoteport; /* Port for bootstrapping, optional */
 234     struct netlink_if *netlink;
 235     struct comm_if **comms;
 236     int ncomms;
 237     struct resolver_if *resolver;
 238     struct log_if *log;
 239     struct random_if *random;
 240     struct rsaprivkey_if *privkey;
 241     struct rsapubkey_if *pubkey;
 242     struct transform_if *transform;
 243     struct dh_if *dh;
 244     struct hash_if *hash;
 245
 246     uint32_t index; /* Index of this site */
 247     uint32_t local_capabilities;
 248     int32_t setup_retries; /* How many times to send setup packets */
 249     int32_t setup_retry_interval; /* Initial timeout for setup packets */
 250     int32_t wait_timeout; /* How long to wait if setup unsuccessful */
 251     int32_t mobile_peer_expiry; /* How long to remember 2ary addresses */
 252     int32_t key_lifetime; /* How long a key lasts once set up */
 253     int32_t key_renegotiate_time; /* If we see traffic (or a keepalive)
 254                                       after this time, initiate a new
 255                                       key exchange */
 256
 257     bool_t setup_priority; /* Do we have precedence if both sites emit
 258                               message 1 simultaneously? */
 259     uint32_t log_events;
 260
 261 /* runtime information */
 262     uint32_t state;
 263     uint64_t now; /* Most recently seen time */
 264
 265     /* The currently established session */
 266     struct data_key current;
 267     struct data_key auxiliary_key;
 268     bool_t auxiliary_is_new;
 269     uint64_t renegotiate_key_time; /* When we can negotiate a new key */
 270     uint64_t auxiliary_renegotiate_key_time;
 271     transport_peers peers; /* Current address(es) of peer for data traffic */
 272
 273     /* The current key setup protocol exchange.  We can only be
 274        involved in one of these at a time.  There's a potential for
 275        denial of service here (the attacker keeps sending a setup
 276        packet; we keep trying to continue the exchange, and have to
 277        timeout before we can listen for another setup packet); perhaps
 278        we should keep a list of 'bad' sources for setup packets. */
 279     uint32_t remote_capabilities;
 280     uint32_t setup_session_id;
 281     transport_peers setup_peers;
 282     uint8_t localN[NONCELEN]; /* Nonces for key exchange */
 283     uint8_t remoteN[NONCELEN];
 284     struct buffer_if buffer; /* Current outgoing key exchange packet */
 285     struct buffer_if scratch;
 286     int32_t retries; /* Number of retries remaining */
 287     uint64_t timeout; /* Timeout for current state */
 288     uint8_t *dhsecret;
 289     uint8_t *sharedsecret;
 290     uint32_t sharedsecretlen;
 291     struct transform_inst_if *new_transform; /* For key setup/verify */
 292 };
 293
 294 static void slog(struct site *st, uint32_t event, cstring_t msg, ...)
 295 {
 296     va_list ap;
 297     char buf[240];
 298     uint32_t class;
 299
 300     va_start(ap,msg);
 301
 302     if (event&st->log_events) {
 303         switch(event) {
 304         case LOG_UNEXPECTED: class=M_INFO; break;
 305         case LOG_SETUP_INIT: class=M_INFO; break;
 306         case LOG_SETUP_TIMEOUT: class=M_NOTICE; break;
 307         case LOG_ACTIVATE_KEY: class=M_INFO; break;
 308         case LOG_TIMEOUT_KEY: class=M_INFO; break;
 309         case LOG_SEC: class=M_SECURITY; break;
 310         case LOG_STATE: class=M_DEBUG; break;
 311         case LOG_DROP: class=M_DEBUG; break;
 312         case LOG_DUMP: class=M_DEBUG; break;
 313         case LOG_ERROR: class=M_ERR; break;
 314         case LOG_PEER_ADDRS: class=M_DEBUG; break;
 315         default: class=M_ERR; break;
 316         }
 317
 318         vsnprintf(buf,sizeof(buf),msg,ap);
 319         st->log->log(st->log->st,class,"%s: %s",st->tunname,buf);
 320     }
 321     va_end(ap);
 322 }
 323
 324 static void set_link_quality(struct site *st);
 325 static void delete_keys(struct site *st, cstring_t reason, uint32_t loglevel);
 326 static void delete_one_key(struct site *st, struct data_key *key,
 327                            const char *reason /* may be 0 meaning don't log*/,
 328                            const char *which /* ignored if !reasonn */,
 329                            uint32_t loglevel /* ignored if !reasonn */);
 330 static bool_t initiate_key_setup(struct site *st, cstring_t reason);
 331 static void enter_state_run(struct site *st);
 332 static bool_t enter_state_resolve(struct site *st);
 333 static bool_t enter_new_state(struct site *st,uint32_t next);
 334 static void enter_state_wait(struct site *st);
 335 static void activate_new_key(struct site *st);
 336
 337 static bool_t is_transform_valid(struct transform_inst_if *transform)
 338 {
 339     return transform->valid(transform->st);
 340 }
 341
 342 static bool_t current_valid(struct site *st)
 343 {
 344     return is_transform_valid(st->current.transform);
 345 }
 346
 347 #define DEFINE_CALL_TRANSFORM(fwdrev)                                   \
 348 static int call_transform_##fwdrev(struct site *st,                     \
 349                                    struct transform_inst_if *transform, \
 350                                    struct buffer_if *buf,               \
 351                                    const char **errmsg)                 \
 352 {                                                                       \
 353     return transform->fwdrev(transform->st,buf,errmsg);                 \
 354 }
 355
 356 DEFINE_CALL_TRANSFORM(forwards)
 357 DEFINE_CALL_TRANSFORM(reverse)
 358
 359 static void dispose_transform(struct transform_inst_if **transform_var)
 360 {
 361     /* will become more sophisticated very shortly */
 362     struct transform_inst_if *transform=*transform_var;
 363     transform->delkey(transform->st);
 364 }
 365
 366 #define CHECK_AVAIL(b,l) do { if ((b)->size<(l)) return False; } while(0)
 367 #define CHECK_EMPTY(b) do { if ((b)->size!=0) return False; } while(0)
 368 #define CHECK_TYPE(b,t) do { uint32_t type; \
 369     CHECK_AVAIL((b),4); \
 370     type=buf_unprepend_uint32((b)); \
 371     if (type!=(t)) return False; } while(0)
 372
 373 struct parsedname {
 374     int32_t len;
 375     uint8_t *name;
 376     struct buffer_if extrainfo;
 377 };
 378
 379 struct msg {
 380     uint8_t *hashstart;
 381     uint32_t dest;
 382     uint32_t source;
 383     struct parsedname remote;
 384     struct parsedname local;
 385     uint32_t remote_capabilities;
 386     uint8_t *nR;
 387     uint8_t *nL;
 388     int32_t pklen;
 389     char *pk;
 390     int32_t hashlen;
 391     int32_t siglen;
 392     char *sig;
 393 };
 394
 395 static void set_new_transform(struct site *st)
 396 {
 397     st->new_transform->setkey(st->new_transform->st,st->sharedsecret,
 398                               st->sharedsecretlen,st->setup_priority);
 399 }
 400
 401 struct xinfoadd {
 402     int32_t lenpos, afternul;
 403 };
 404 static void append_string_xinfo_start(struct buffer_if *buf,
 405                                       struct xinfoadd *xia,
 406                                       const char *str)
 407     /* Helps construct one of the names with additional info as found
 408      * in MSG1..4.  Call this function first, then append all the
 409      * desired extra info (not including the nul byte) to the buffer,
 410      * then call append_string_xinfo_done. */
 411 {
 412     xia->lenpos = buf->size;
 413     buf_append_string(buf,str);
 414     buf_append_uint8(buf,0);
 415     xia->afternul = buf->size;
 416 }
 417 static void append_string_xinfo_done(struct buffer_if *buf,
 418                                      struct xinfoadd *xia)
 419 {
 420     /* we just need to adjust the string length */
 421     if (buf->size == xia->afternul) {
 422         /* no extra info, strip the nul too */
 423         buf_unappend_uint8(buf);
 424     } else {
 425         put_uint16(buf->start+xia->lenpos, buf->size-(xia->lenpos+2));
 426     }
 427 }
 428
 429 /* Build any of msg1 to msg4. msg5 and msg6 are built from the inside
 430    out using a transform of config data supplied by netlink */
 431 static bool_t generate_msg(struct site *st, uint32_t type, cstring_t what)
 432 {
 433     void *hst;
 434     uint8_t *hash;
 435     string_t dhpub, sig;
 436
 437     st->retries=st->setup_retries;
 438     BUF_ALLOC(&st->buffer,what);
 439     buffer_init(&st->buffer,0);
 440     buf_append_uint32(&st->buffer,
 441         (type==LABEL_MSG1?0:st->setup_session_id));
 442     buf_append_uint32(&st->buffer,st->index);
 443     buf_append_uint32(&st->buffer,type);
 444
 445     struct xinfoadd xia;
 446     append_string_xinfo_start(&st->buffer,&xia,st->localname);
 447     if ((st->local_capabilities & CAPAB_EARLY) || (type != LABEL_MSG1)) {
 448         buf_append_uint32(&st->buffer,st->local_capabilities);
 449     }
 450     append_string_xinfo_done(&st->buffer,&xia);
 451
 452     buf_append_string(&st->buffer,st->remotename);
 453     memcpy(buf_append(&st->buffer,NONCELEN),st->localN,NONCELEN);
 454     if (type==LABEL_MSG1) return True;
 455     memcpy(buf_append(&st->buffer,NONCELEN),st->remoteN,NONCELEN);
 456     if (type==LABEL_MSG2) return True;
 457
 458     if (hacky_par_mid_failnow()) return False;
 459
 460     dhpub=st->dh->makepublic(st->dh->st,st->dhsecret,st->dh->len);
 461     buf_append_string(&st->buffer,dhpub);
 462     free(dhpub);
 463     hash=safe_malloc(st->hash->len, "generate_msg");
 464     hst=st->hash->init();
 465     st->hash->update(hst,st->buffer.start,st->buffer.size);
 466     st->hash->final(hst,hash);
 467     sig=st->privkey->sign(st->privkey->st,hash,st->hash->len);
 468     buf_append_string(&st->buffer,sig);
 469     free(sig);
 470     free(hash);
 471     return True;
 472 }
 473
 474 static bool_t unpick_name(struct buffer_if *msg, struct parsedname *nm)
 475 {
 476     CHECK_AVAIL(msg,2);
 477     nm->len=buf_unprepend_uint16(msg);
 478     CHECK_AVAIL(msg,nm->len);
 479     nm->name=buf_unprepend(msg,nm->len);
 480     uint8_t *nul=memchr(nm->name,0,nm->len);
 481     if (!nul) {
 482         buffer_readonly_view(&nm->extrainfo,0,0);
 483     } else {
 484         buffer_readonly_view(&nm->extrainfo, nul+1, msg->start-(nul+1));
 485         nm->len=nul-nm->name;
 486     }
 487     return True;
 488 }
 489
 490 static bool_t unpick_msg(struct site *st, uint32_t type,
 491                          struct buffer_if *msg, struct msg *m)
 492 {
 493     m->hashstart=msg->start;
 494     CHECK_AVAIL(msg,4);
 495     m->dest=buf_unprepend_uint32(msg);
 496     CHECK_AVAIL(msg,4);
 497     m->source=buf_unprepend_uint32(msg);
 498     CHECK_TYPE(msg,type);
 499     if (!unpick_name(msg,&m->remote)) return False;
 500     m->remote_capabilities=0;
 501     if (m->remote.extrainfo.size) {
 502         CHECK_AVAIL(&m->remote.extrainfo,4);
 503         m->remote_capabilities=buf_unprepend_uint32(&m->remote.extrainfo);
 504     }
 505     if (!unpick_name(msg,&m->local)) return False;
 506     CHECK_AVAIL(msg,NONCELEN);
 507     m->nR=buf_unprepend(msg,NONCELEN);
 508     if (type==LABEL_MSG1) {
 509         CHECK_EMPTY(msg);
 510         return True;
 511     }
 512     CHECK_AVAIL(msg,NONCELEN);
 513     m->nL=buf_unprepend(msg,NONCELEN);
 514     if (type==LABEL_MSG2) {
 515         CHECK_EMPTY(msg);
 516         return True;
 517     }
 518     CHECK_AVAIL(msg,2);
 519     m->pklen=buf_unprepend_uint16(msg);
 520     CHECK_AVAIL(msg,m->pklen);
 521     m->pk=buf_unprepend(msg,m->pklen);
 522     m->hashlen=msg->start-m->hashstart;
 523     CHECK_AVAIL(msg,2);
 524     m->siglen=buf_unprepend_uint16(msg);
 525     CHECK_AVAIL(msg,m->siglen);
 526     m->sig=buf_unprepend(msg,m->siglen);
 527     CHECK_EMPTY(msg);
 528     return True;
 529 }
 530
 531 static bool_t name_matches(const struct parsedname *nm, const char *expected)
 532 {
 533     int expected_len=strlen(expected);
 534     return
 535         nm->len == expected_len &&
 536         !memcmp(nm->name, expected, expected_len);
 537 }
 538
 539 static bool_t check_msg(struct site *st, uint32_t type, struct msg *m,
 540                         cstring_t *error)
 541 {
 542     if (type==LABEL_MSG1) return True;
 543
 544     /* Check that the site names and our nonce have been sent
 545        back correctly, and then store our peer's nonce. */
 546     if (!name_matches(&m->remote,st->remotename)) {
 547         *error="wrong remote site name";
 548         return False;
 549     }
 550     if (!name_matches(&m->local,st->localname)) {
 551         *error="wrong local site name";
 552         return False;
 553     }
 554     if (memcmp(m->nL,st->localN,NONCELEN)!=0) {
 555         *error="wrong locally-generated nonce";
 556         return False;
 557     }
 558     if (type==LABEL_MSG2) return True;
 559     if (!consttime_memeq(m->nR,st->remoteN,NONCELEN)!=0) {
 560         *error="wrong remotely-generated nonce";
 561         return False;
 562     }
 563     /* MSG3 has complicated rules about capabilities, which are
 564      * handled in process_msg3. */
 565     if (type==LABEL_MSG3) return True;
 566     if (m->remote_capabilities!=st->remote_capabilities) {
 567         *error="remote capabilities changed";
 568         return False;
 569     }
 570     if (type==LABEL_MSG4) return True;
 571     *error="unknown message type";
 572     return False;
 573 }
 574
 575 static bool_t generate_msg1(struct site *st)
 576 {
 577     st->random->generate(st->random->st,NONCELEN,st->localN);
 578     return generate_msg(st,LABEL_MSG1,"site:MSG1");
 579 }
 580
 581 static bool_t process_msg1(struct site *st, struct buffer_if *msg1,
 582                            const struct comm_addr *src, struct msg *m)
 583 {
 584     /* We've already determined we're in an appropriate state to
 585        process an incoming MSG1, and that the MSG1 has correct values
 586        of A and B. */
 587
 588     transport_record_peer(st,&st->setup_peers,src,"msg1");
 589     st->setup_session_id=m->source;
 590     st->remote_capabilities=m->remote_capabilities;
 591     memcpy(st->remoteN,m->nR,NONCELEN);
 592     return True;
 593 }
 594
 595 static bool_t generate_msg2(struct site *st)
 596 {
 597     st->random->generate(st->random->st,NONCELEN,st->localN);
 598     return generate_msg(st,LABEL_MSG2,"site:MSG2");
 599 }
 600
 601 static bool_t process_msg2(struct site *st, struct buffer_if *msg2,
 602                            const struct comm_addr *src)
 603 {
 604     struct msg m;
 605     cstring_t err;
 606
 607     if (!unpick_msg(st,LABEL_MSG2,msg2,&m)) return False;
 608     if (!check_msg(st,LABEL_MSG2,&m,&err)) {
 609         slog(st,LOG_SEC,"msg2: %s",err);
 610         return False;
 611     }
 612     st->setup_session_id=m.source;
 613     st->remote_capabilities=m.remote_capabilities;
 614     memcpy(st->remoteN,m.nR,NONCELEN);
 615     return True;
 616 }
 617
 618 static bool_t generate_msg3(struct site *st)
 619 {
 620     /* Now we have our nonce and their nonce. Think of a secret key,
 621        and create message number 3. */
 622     st->random->generate(st->random->st,st->dh->len,st->dhsecret);
 623     return generate_msg(st,LABEL_MSG3,"site:MSG3");
 624 }
 625
 626 static bool_t process_msg3(struct site *st, struct buffer_if *msg3,
 627                            const struct comm_addr *src)
 628 {
 629     struct msg m;
 630     uint8_t *hash;
 631     void *hst;
 632     cstring_t err;
 633
 634     if (!unpick_msg(st,LABEL_MSG3,msg3,&m)) return False;
 635     if (!check_msg(st,LABEL_MSG3,&m,&err)) {
 636         slog(st,LOG_SEC,"msg3: %s",err);
 637         return False;
 638     }
 639     uint32_t capab_adv_late = m.remote_capabilities
 640         & ~st->remote_capabilities & CAPAB_EARLY;
 641     if (capab_adv_late) {
 642         slog(st,LOG_SEC,"msg3 impermissibly adds early capability flag(s)"
 643              " %#"PRIx32" (was %#"PRIx32", now %#"PRIx32")",
 644              capab_adv_late, st->remote_capabilities, m.remote_capabilities);
 645         return False;
 646     }
 647     st->remote_capabilities|=m.remote_capabilities;
 648
 649     /* Check signature and store g^x mod m */
 650     hash=safe_malloc(st->hash->len, "process_msg3");
 651     hst=st->hash->init();
 652     st->hash->update(hst,m.hashstart,m.hashlen);
 653     st->hash->final(hst,hash);
 654     /* Terminate signature with a '0' - cheating, but should be ok */
 655     m.sig[m.siglen]=0;
 656     if (!st->pubkey->check(st->pubkey->st,hash,st->hash->len,m.sig)) {
 657         slog(st,LOG_SEC,"msg3 signature failed check!");
 658         free(hash);
 659         return False;
 660     }
 661     free(hash);
 662
 663     /* Terminate their DH public key with a '0' */
 664     m.pk[m.pklen]=0;
 665     /* Invent our DH secret key */
 666     st->random->generate(st->random->st,st->dh->len,st->dhsecret);
 667
 668     /* Generate the shared key */
 669     st->dh->makeshared(st->dh->st,st->dhsecret,st->dh->len,m.pk,
 670                        st->sharedsecret,st->sharedsecretlen);
 671
 672     /* Set up the transform */
 673     set_new_transform(st);
 674
 675     return True;
 676 }
 677
 678 static bool_t generate_msg4(struct site *st)
 679 {
 680     /* We have both nonces, their public key and our private key. Generate
 681        our public key, sign it and send it to them. */
 682     return generate_msg(st,LABEL_MSG4,"site:MSG4");
 683 }
 684
 685 static bool_t process_msg4(struct site *st, struct buffer_if *msg4,
 686                            const struct comm_addr *src)
 687 {
 688     struct msg m;
 689     uint8_t *hash;
 690     void *hst;
 691     cstring_t err;
 692
 693     if (!unpick_msg(st,LABEL_MSG4,msg4,&m)) return False;
 694     if (!check_msg(st,LABEL_MSG4,&m,&err)) {
 695         slog(st,LOG_SEC,"msg4: %s",err);
 696         return False;
 697     }
 698
 699     /* Check signature and store g^x mod m */
 700     hash=safe_malloc(st->hash->len, "process_msg4");
 701     hst=st->hash->init();
 702     st->hash->update(hst,m.hashstart,m.hashlen);
 703     st->hash->final(hst,hash);
 704     /* Terminate signature with a '0' - cheating, but should be ok */
 705     m.sig[m.siglen]=0;
 706     if (!st->pubkey->check(st->pubkey->st,hash,st->hash->len,m.sig)) {
 707         slog(st,LOG_SEC,"msg4 signature failed check!");
 708         free(hash);
 709         return False;
 710     }
 711     free(hash);
 712
 713     /* Terminate their DH public key with a '0' */
 714     m.pk[m.pklen]=0;
 715     /* Generate the shared key */
 716     st->dh->makeshared(st->dh->st,st->dhsecret,st->dh->len,m.pk,
 717                        st->sharedsecret,st->sharedsecretlen);
 718     /* Set up the transform */
 719     set_new_transform(st);
 720
 721     return True;
 722 }
 723
 724 struct msg0 {
 725     uint32_t dest;
 726     uint32_t source;
 727     uint32_t type;
 728 };
 729
 730 static bool_t unpick_msg0(struct site *st, struct buffer_if *msg0,
 731                           struct msg0 *m)
 732 {
 733     CHECK_AVAIL(msg0,4);
 734     m->dest=buf_unprepend_uint32(msg0);
 735     CHECK_AVAIL(msg0,4);
 736     m->source=buf_unprepend_uint32(msg0);
 737     CHECK_AVAIL(msg0,4);
 738     m->type=buf_unprepend_uint32(msg0);
 739     return True;
 740     /* Leaves transformed part of buffer untouched */
 741 }
 742
 743 static bool_t generate_msg5(struct site *st)
 744 {
 745     cstring_t transform_err;
 746
 747     BUF_ALLOC(&st->buffer,"site:MSG5");
 748     /* We are going to add four words to the message */
 749     buffer_init(&st->buffer,st->transform->max_start_pad+(4*4));
 750     /* Give the netlink code an opportunity to put its own stuff in the
 751        message (configuration information, etc.) */
 752     buf_prepend_uint32(&st->buffer,LABEL_MSG5);
 753     if (call_transform_forwards(st,st->new_transform,
 754                                 &st->buffer,&transform_err))
 755         return False;
 756     buf_prepend_uint32(&st->buffer,LABEL_MSG5);
 757     buf_prepend_uint32(&st->buffer,st->index);
 758     buf_prepend_uint32(&st->buffer,st->setup_session_id);
 759
 760     st->retries=st->setup_retries;
 761     return True;
 762 }
 763
 764 static bool_t process_msg5(struct site *st, struct buffer_if *msg5,
 765                            const struct comm_addr *src,
 766                            struct transform_inst_if *transform)
 767 {
 768     struct msg0 m;
 769     cstring_t transform_err;
 770
 771     if (!unpick_msg0(st,msg5,&m)) return False;
 772
 773     if (call_transform_reverse(st,transform,msg5,&transform_err)) {
 774         /* There's a problem */
 775         slog(st,LOG_SEC,"process_msg5: transform: %s",transform_err);
 776         return False;
 777     }
 778     /* Buffer should now contain untransformed PING packet data */
 779     CHECK_AVAIL(msg5,4);
 780     if (buf_unprepend_uint32(msg5)!=LABEL_MSG5) {
 781         slog(st,LOG_SEC,"MSG5/PING packet contained wrong label");
 782         return False;
 783     }
 784     /* Older versions of secnet used to write some config data here
 785      * which we ignore.  So we don't CHECK_EMPTY */
 786     return True;
 787 }
 788
 789 static void create_msg6(struct site *st, struct transform_inst_if *transform,
 790                         uint32_t session_id)
 791 {
 792     cstring_t transform_err;
 793
 794     BUF_ALLOC(&st->buffer,"site:MSG6");
 795     /* We are going to add four words to the message */
 796     buffer_init(&st->buffer,st->transform->max_start_pad+(4*4));
 797     /* Give the netlink code an opportunity to put its own stuff in the
 798        message (configuration information, etc.) */
 799     buf_prepend_uint32(&st->buffer,LABEL_MSG6);
 800     int problem = call_transform_forwards(st,transform,
 801                                           &st->buffer,&transform_err);
 802     assert(!problem);
 803     buf_prepend_uint32(&st->buffer,LABEL_MSG6);
 804     buf_prepend_uint32(&st->buffer,st->index);
 805     buf_prepend_uint32(&st->buffer,session_id);
 806 }
 807
 808 static bool_t generate_msg6(struct site *st)
 809 {
 810     if (!is_transform_valid(st->new_transform))
 811         return False;
 812     create_msg6(st,st->new_transform,st->setup_session_id);
 813     st->retries=1; /* Peer will retransmit MSG5 if this packet gets lost */
 814     return True;
 815 }
 816
 817 static bool_t process_msg6(struct site *st, struct buffer_if *msg6,
 818                            const struct comm_addr *src)
 819 {
 820     struct msg0 m;
 821     cstring_t transform_err;
 822
 823     if (!unpick_msg0(st,msg6,&m)) return False;
 824
 825     if (call_transform_reverse(st,st->new_transform,msg6,&transform_err)) {
 826         /* There's a problem */
 827         slog(st,LOG_SEC,"process_msg6: transform: %s",transform_err);
 828         return False;
 829     }
 830     /* Buffer should now contain untransformed PING packet data */
 831     CHECK_AVAIL(msg6,4);
 832     if (buf_unprepend_uint32(msg6)!=LABEL_MSG6) {
 833         slog(st,LOG_SEC,"MSG6/PONG packet contained invalid data");
 834         return False;
 835     }
 836     /* Older versions of secnet used to write some config data here
 837      * which we ignore.  So we don't CHECK_EMPTY */
 838     return True;
 839 }
 840
 841 static bool_t decrypt_msg0(struct site *st, struct buffer_if *msg0,
 842                            const struct comm_addr *src)
 843 {
 844     cstring_t transform_err, auxkey_err, newkey_err="n/a";
 845     struct msg0 m;
 846     uint32_t problem;
 847
 848     if (!unpick_msg0(st,msg0,&m)) return False;
 849
 850     /* Keep a copy so we can try decrypting it with multiple keys */
 851     buffer_copy(&st->scratch, msg0);
 852
 853     problem = call_transform_reverse(st,st->current.transform,
 854                                      msg0,&transform_err);
 855     if (!problem) {
 856         if (!st->auxiliary_is_new)
 857             delete_one_key(st,&st->auxiliary_key,
 858                            "peer has used new key","auxiliary key",LOG_SEC);
 859         return True;
 860     }
 861     if (problem==2)
 862         goto skew;
 863
 864     buffer_copy(msg0, &st->scratch);
 865     problem = call_transform_reverse
 866         (st,st->auxiliary_key.transform->st,msg0,&auxkey_err);
 867     if (problem==0) {
 868         slog(st,LOG_DROP,"processing packet which uses auxiliary key");
 869         if (st->auxiliary_is_new) {
 870             /* We previously timed out in state SENTMSG5 but it turns
 871              * out that our peer did in fact get our MSG5 and is
 872              * using the new key.  So we should switch to it too. */
 873             /* This is a bit like activate_new_key. */
 874             struct data_key t;
 875             t=st->current;
 876             st->current=st->auxiliary_key;
 877             st->auxiliary_key=t;
 878
 879             delete_one_key(st,&st->auxiliary_key,"peer has used new key",
 880                            "previous key",LOG_SEC);
 881             st->auxiliary_is_new=0;
 882             st->renegotiate_key_time=st->auxiliary_renegotiate_key_time;
 883         }
 884         return True;
 885     }
 886     if (problem==2)
 887         goto skew;
 888
 889     if (st->state==SITE_SENTMSG5) {
 890         buffer_copy(msg0, &st->scratch);
 891         problem = call_transform_reverse(st,st->new_transform,
 892                                          msg0,&newkey_err);
 893         if (!problem) {
 894             /* It looks like we didn't get the peer's MSG6 */
 895             /* This is like a cut-down enter_new_state(SITE_RUN) */
 896             slog(st,LOG_STATE,"will enter state RUN (MSG0 with new key)");
 897             BUF_FREE(&st->buffer);
 898             st->timeout=0;
 899             activate_new_key(st);
 900             return True; /* do process the data in this packet */
 901         }
 902         if (problem==2)
 903             goto skew;
 904     }
 905
 906     slog(st,LOG_SEC,"transform: %s (aux: %s, new: %s)",
 907          transform_err,auxkey_err,newkey_err);
 908     initiate_key_setup(st,"incoming message would not decrypt");
 909     send_nak(src,m.dest,m.source,m.type,msg0,"message would not decrypt");
 910     return False;
 911
 912  skew:
 913     slog(st,LOG_DROP,"transform: %s (merely skew)",transform_err);
 914     return False;
 915 }
 916
 917 static bool_t process_msg0(struct site *st, struct buffer_if *msg0,
 918                            const struct comm_addr *src)
 919 {
 920     uint32_t type;
 921
 922     if (!decrypt_msg0(st,msg0,src))
 923         return False;
 924
 925     CHECK_AVAIL(msg0,4);
 926     type=buf_unprepend_uint32(msg0);
 927     switch(type) {
 928     case LABEL_MSG7:
 929         /* We must forget about the current session. */
 930         delete_keys(st,"request from peer",LOG_SEC);
 931         return True;
 932     case LABEL_MSG9:
 933         /* Deliver to netlink layer */
 934         st->netlink->deliver(st->netlink->st,msg0);
 935         transport_data_msgok(st,src);
 936         /* See whether we should start negotiating a new key */
 937         if (st->now > st->renegotiate_key_time)
 938             initiate_key_setup(st,"incoming packet in renegotiation window");
 939         return True;
 940     default:
 941         slog(st,LOG_SEC,"incoming encrypted message of type %08x "
 942              "(unknown)",type);
 943         break;
 944     }
 945     return False;
 946 }
 947
 948 static void dump_packet(struct site *st, struct buffer_if *buf,
 949                         const struct comm_addr *addr, bool_t incoming)
 950 {
 951     uint32_t dest=get_uint32(buf->start);
 952     uint32_t source=get_uint32(buf->start+4);
 953     uint32_t msgtype=get_uint32(buf->start+8);
 954
 955     if (st->log_events & LOG_DUMP)
 956         slilog(st->log,M_DEBUG,"%s: %s: %08x<-%08x: %08x:",
 957                st->tunname,incoming?"incoming":"outgoing",
 958                dest,source,msgtype);
 959 }
 960
 961 static uint32_t site_status(void *st)
 962 {
 963     return 0;
 964 }
 965
 966 static bool_t send_msg(struct site *st)
 967 {
 968     if (st->retries>0) {
 969         transport_xmit(st, &st->setup_peers, &st->buffer, True);
 970         st->timeout=st->now+st->setup_retry_interval;
 971         st->retries--;
 972         return True;
 973     } else if (st->state==SITE_SENTMSG5) {
 974         slog(st,LOG_SETUP_TIMEOUT,"timed out sending MSG5, stashing new key");
 975         /* We stash the key we have produced, in case it turns out that
 976          * our peer did see our MSG5 after all and starts using it. */
 977         /* This is a bit like some of activate_new_key */
 978         struct transform_inst_if *t;
 979         t=st->auxiliary_key.transform;
 980         st->auxiliary_key.transform=st->new_transform;
 981         st->new_transform=t;
 982         dispose_transform(&st->new_transform);
 983
 984         st->auxiliary_is_new=1;
 985         st->auxiliary_key.key_timeout=st->now+st->key_lifetime;
 986         st->auxiliary_renegotiate_key_time=st->now+st->key_renegotiate_time;
 987         st->auxiliary_key.remote_session_id=st->setup_session_id;
 988
 989         enter_state_wait(st);
 990         return False;
 991     } else {
 992         slog(st,LOG_SETUP_TIMEOUT,"timed out sending key setup packet "
 993             "(in state %s)",state_name(st->state));
 994         enter_state_wait(st);
 995         return False;
 996     }
 997 }
 998
 999 static void site_resolve_callback(void *sst, struct in_addr *address)
1000 {
1001     struct site *st=sst;
1002     struct comm_addr ca_buf, *ca_use;
1003
1004     if (st->state!=SITE_RESOLVE) {
1005         slog(st,LOG_UNEXPECTED,"site_resolve_callback called unexpectedly");
1006         return;
1007     }
1008     if (address) {
1009         FILLZERO(ca_buf);
1010         ca_buf.comm=st->comms[0];
1011         ca_buf.sin.sin_family=AF_INET;
1012         ca_buf.sin.sin_port=htons(st->remoteport);
1013         ca_buf.sin.sin_addr=*address;
1014         ca_use=&ca_buf;
1015     } else {
1016         slog(st,LOG_ERROR,"resolution of %s failed",st->address);
1017         ca_use=0;
1018     }
1019     if (transport_compute_setupinit_peers(st,ca_use)) {
1020         enter_new_state(st,SITE_SENTMSG1);
1021     } else {
1022         /* Can't figure out who to try to to talk to */
1023         slog(st,LOG_SETUP_INIT,"key exchange failed: cannot find peer address");
1024         enter_state_run(st);
1025     }
1026 }
1027
1028 static bool_t initiate_key_setup(struct site *st, cstring_t reason)
1029 {
1030     if (st->state!=SITE_RUN) return False;
1031     slog(st,LOG_SETUP_INIT,"initiating key exchange (%s)",reason);
1032     if (st->address) {
1033         slog(st,LOG_SETUP_INIT,"resolving peer address");
1034         return enter_state_resolve(st);
1035     } else if (transport_compute_setupinit_peers(st,0)) {
1036         return enter_new_state(st,SITE_SENTMSG1);
1037     }
1038     slog(st,LOG_SETUP_INIT,"key exchange failed: no address for peer");
1039     return False;
1040 }
1041
1042 static void activate_new_key(struct site *st)
1043 {
1044     struct transform_inst_if *t;
1045
1046     /* We have three transform instances, which we swap between old,
1047        active and setup */
1048     t=st->auxiliary_key.transform;
1049     st->auxiliary_key.transform=st->current.transform;
1050     st->current.transform=st->new_transform;
1051     st->new_transform=t;
1052     dispose_transform(&st->new_transform);
1053
1054     st->timeout=0;
1055     st->auxiliary_is_new=0;
1056     st->auxiliary_key.key_timeout=st->current.key_timeout;
1057     st->current.key_timeout=st->now+st->key_lifetime;
1058     st->renegotiate_key_time=st->now+st->key_renegotiate_time;
1059     transport_peers_copy(st,&st->peers,&st->setup_peers);
1060     st->current.remote_session_id=st->setup_session_id;
1061
1062     slog(st,LOG_ACTIVATE_KEY,"new key activated");
1063     enter_state_run(st);
1064 }
1065
1066 static void delete_one_key(struct site *st, struct data_key *key,
1067                            cstring_t reason, cstring_t which, uint32_t loglevel)
1068 {
1069     if (!is_transform_valid(key->transform)) return;
1070     if (reason) slog(st,loglevel,"%s deleted (%s)",which,reason);
1071     dispose_transform(&key->transform);
1072     key->key_timeout=0;
1073 }
1074
1075 static void delete_keys(struct site *st, cstring_t reason, uint32_t loglevel)
1076 {
1077     if (current_valid(st)) {
1078         slog(st,loglevel,"session closed (%s)",reason);
1079
1080         delete_one_key(st,&st->current,0,0,0);
1081         set_link_quality(st);
1082     }
1083     delete_one_key(st,&st->auxiliary_key,0,0,0);
1084 }
1085
1086 static void state_assert(struct site *st, bool_t ok)
1087 {
1088     if (!ok) fatal("site:state_assert");
1089 }
1090
1091 static void enter_state_stop(struct site *st)
1092 {
1093     st->state=SITE_STOP;
1094     st->timeout=0;
1095     delete_keys(st,"entering state STOP",LOG_TIMEOUT_KEY);
1096     dispose_transform(&st->new_transform);
1097 }
1098
1099 static void set_link_quality(struct site *st)
1100 {
1101     uint32_t quality;
1102     if (current_valid(st))
1103         quality=LINK_QUALITY_UP;
1104     else if (st->state==SITE_WAIT || st->state==SITE_STOP)
1105         quality=LINK_QUALITY_DOWN;
1106     else if (st->address)
1107         quality=LINK_QUALITY_DOWN_CURRENT_ADDRESS;
1108     else if (transport_peers_valid(&st->peers))
1109         quality=LINK_QUALITY_DOWN_STALE_ADDRESS;
1110     else
1111         quality=LINK_QUALITY_DOWN;
1112
1113     st->netlink->set_quality(st->netlink->st,quality);
1114 }
1115
1116 static void enter_state_run(struct site *st)
1117 {
1118     slog(st,LOG_STATE,"entering state RUN");
1119     st->state=SITE_RUN;
1120     st->timeout=0;
1121
1122     st->setup_session_id=0;
1123     transport_peers_clear(st,&st->setup_peers);
1124     memset(st->localN,0,NONCELEN);
1125     memset(st->remoteN,0,NONCELEN);
1126     dispose_transform(&st->new_transform);
1127     memset(st->dhsecret,0,st->dh->len);
1128     memset(st->sharedsecret,0,st->sharedsecretlen);
1129     set_link_quality(st);
1130 }
1131
1132 static bool_t enter_state_resolve(struct site *st)
1133 {
1134     state_assert(st,st->state==SITE_RUN);
1135     slog(st,LOG_STATE,"entering state RESOLVE");
1136     st->state=SITE_RESOLVE;
1137     st->resolver->request(st->resolver->st,st->address,
1138                           site_resolve_callback,st);
1139     return True;
1140 }
1141
1142 static bool_t enter_new_state(struct site *st, uint32_t next)
1143 {
1144     bool_t (*gen)(struct site *st);
1145     int r;
1146
1147     slog(st,LOG_STATE,"entering state %s",state_name(next));
1148     switch(next) {
1149     case SITE_SENTMSG1:
1150         state_assert(st,st->state==SITE_RUN || st->state==SITE_RESOLVE);
1151         gen=generate_msg1;
1152         break;
1153     case SITE_SENTMSG2:
1154         state_assert(st,st->state==SITE_RUN || st->state==SITE_RESOLVE ||
1155                      st->state==SITE_SENTMSG1 || st->state==SITE_WAIT);
1156         gen=generate_msg2;
1157         break;
1158     case SITE_SENTMSG3:
1159         state_assert(st,st->state==SITE_SENTMSG1);
1160         BUF_FREE(&st->buffer);
1161         gen=generate_msg3;
1162         break;
1163     case SITE_SENTMSG4:
1164         state_assert(st,st->state==SITE_SENTMSG2);
1165         BUF_FREE(&st->buffer);
1166         gen=generate_msg4;
1167         break;
1168     case SITE_SENTMSG5:
1169         state_assert(st,st->state==SITE_SENTMSG3);
1170         BUF_FREE(&st->buffer);
1171         gen=generate_msg5;
1172         break;
1173     case SITE_RUN:
1174         state_assert(st,st->state==SITE_SENTMSG4);
1175         BUF_FREE(&st->buffer);
1176         gen=generate_msg6;
1177         break;
1178     default:
1179         gen=NULL;
1180         fatal("enter_new_state(%s): invalid new state",state_name(next));
1181         break;
1182     }
1183
1184     if (hacky_par_start_failnow()) return False;
1185
1186     r= gen(st) && send_msg(st);
1187
1188     hacky_par_end(&r,
1189                   st->setup_retries, st->setup_retry_interval,
1190                   send_msg, st);
1191
1192     if (r) {
1193         st->state=next;
1194         if (next==SITE_RUN) {
1195             BUF_FREE(&st->buffer); /* Never reused */
1196             st->timeout=0; /* Never retransmit */
1197             activate_new_key(st);
1198         }
1199         return True;
1200     }
1201     slog(st,LOG_ERROR,"error entering state %s",state_name(next));
1202     st->buffer.free=False; /* Unconditionally use the buffer; it may be
1203                               in either state, and enter_state_wait() will
1204                               do a BUF_FREE() */
1205     enter_state_wait(st);
1206     return False;
1207 }
1208
1209 /* msg7 tells our peer that we're about to forget our key */
1210 static bool_t send_msg7(struct site *st, cstring_t reason)
1211 {
1212     cstring_t transform_err;
1213
1214     if (current_valid(st) && st->buffer.free
1215         && transport_peers_valid(&st->peers)) {
1216         BUF_ALLOC(&st->buffer,"site:MSG7");
1217         buffer_init(&st->buffer,st->transform->max_start_pad+(4*3));
1218         buf_append_uint32(&st->buffer,LABEL_MSG7);
1219         buf_append_string(&st->buffer,reason);
1220         if (call_transform_forwards(st, st->current.transform,
1221                                     &st->buffer, &transform_err))
1222             goto free_out;
1223         buf_prepend_uint32(&st->buffer,LABEL_MSG0);
1224         buf_prepend_uint32(&st->buffer,st->index);
1225         buf_prepend_uint32(&st->buffer,st->current.remote_session_id);
1226         transport_xmit(st,&st->peers,&st->buffer,True);
1227         BUF_FREE(&st->buffer);
1228     free_out:
1229         return True;
1230     }
1231     return False;
1232 }
1233
1234 /* We go into this state if our peer becomes uncommunicative. Similar to
1235    the "stop" state, we forget all session keys for a while, before
1236    re-entering the "run" state. */
1237 static void enter_state_wait(struct site *st)
1238 {
1239     slog(st,LOG_STATE,"entering state WAIT");
1240     st->timeout=st->now+st->wait_timeout;
1241     st->state=SITE_WAIT;
1242     set_link_quality(st);
1243     BUF_FREE(&st->buffer); /* will have had an outgoing packet in it */
1244     /* XXX Erase keys etc. */
1245 }
1246
1247 static inline void site_settimeout(uint64_t timeout, int *timeout_io)
1248 {
1249     if (timeout) {
1250         int64_t offset=timeout-*now;
1251         if (offset<0) offset=0;
1252         if (offset>INT_MAX) offset=INT_MAX;
1253         if (*timeout_io<0 || offset<*timeout_io)
1254             *timeout_io=offset;
1255     }
1256 }
1257
1258 static int site_beforepoll(void *sst, struct pollfd *fds, int *nfds_io,
1259                            int *timeout_io)
1260 {
1261     struct site *st=sst;
1262
1263     *nfds_io=0; /* We don't use any file descriptors */
1264     st->now=*now;
1265
1266     /* Work out when our next timeout is. The earlier of 'timeout' or
1267        'current.key_timeout'. A stored value of '0' indicates no timeout
1268        active. */
1269     site_settimeout(st->timeout, timeout_io);
1270     site_settimeout(st->current.key_timeout, timeout_io);
1271     site_settimeout(st->auxiliary_key.key_timeout, timeout_io);
1272
1273     return 0; /* success */
1274 }
1275
1276 static void check_expiry(struct site *st, struct data_key *key,
1277                          const char *which)
1278 {
1279     if (key->key_timeout && *now>key->key_timeout) {
1280         delete_one_key(st,key,"maximum life exceeded",which,LOG_TIMEOUT_KEY);
1281     }
1282 }
1283
1284 /* NB site_afterpoll will be called before site_beforepoll is ever called */
1285 static void site_afterpoll(void *sst, struct pollfd *fds, int nfds)
1286 {
1287     struct site *st=sst;
1288
1289     st->now=*now;
1290     if (st->timeout && *now>st->timeout) {
1291         st->timeout=0;
1292         if (st->state>=SITE_SENTMSG1 && st->state<=SITE_SENTMSG5) {
1293             if (!hacky_par_start_failnow())
1294                 send_msg(st);
1295         } else if (st->state==SITE_WAIT) {
1296             enter_state_run(st);
1297         } else {
1298             slog(st,LOG_ERROR,"site_afterpoll: unexpected timeout, state=%d",
1299                  st->state);
1300         }
1301     }
1302     check_expiry(st,&st->current,"current key");
1303     check_expiry(st,&st->auxiliary_key,"auxiliary key");
1304 }
1305
1306 /* This function is called by the netlink device to deliver packets
1307    intended for the remote network. The packet is in "raw" wire
1308    format, but is guaranteed to be word-aligned. */
1309 static void site_outgoing(void *sst, struct buffer_if *buf)
1310 {
1311     struct site *st=sst;
1312     cstring_t transform_err;
1313
1314     if (st->state==SITE_STOP) {
1315         BUF_FREE(buf);
1316         return;
1317     }
1318
1319     /* In all other states we consider delivering the packet if we have
1320        a valid key and a valid address to send it to. */
1321     if (current_valid(st) && transport_peers_valid(&st->peers)) {
1322         /* Transform it and send it */
1323         if (buf->size>0) {
1324             buf_prepend_uint32(buf,LABEL_MSG9);
1325             if (call_transform_forwards(st, st->current.transform,
1326                                         buf, &transform_err))
1327                 goto free_out;
1328             buf_prepend_uint32(buf,LABEL_MSG0);
1329             buf_prepend_uint32(buf,st->index);
1330             buf_prepend_uint32(buf,st->current.remote_session_id);
1331             transport_xmit(st,&st->peers,buf,False);
1332         }
1333     free_out:
1334         BUF_FREE(buf);
1335         return;
1336     }
1337
1338     slog(st,LOG_DROP,"discarding outgoing packet of size %d",buf->size);
1339     BUF_FREE(buf);
1340     initiate_key_setup(st,"outgoing packet");
1341 }
1342
1343 static bool_t named_for_us(struct site *st, const struct buffer_if *buf_in,
1344                            uint32_t type, struct msg *m)
1345     /* For packets which are identified by the local and remote names.
1346      * If it has our name and our peer's name in it it's for us. */
1347 {
1348     struct buffer_if buf[1];
1349     buffer_readonly_clone(buf,buf_in);
1350     return unpick_msg(st,type,buf,m)
1351         && name_matches(&m->remote,st->remotename)
1352         && name_matches(&m->local,st->localname);
1353 }
1354
1355 /* This function is called by the communication device to deliver
1356    packets from our peers. */
1357 static bool_t site_incoming(void *sst, struct buffer_if *buf,
1358                             const struct comm_addr *source)
1359 {
1360     struct site *st=sst;
1361
1362     if (buf->size < 12) return False;
1363
1364     uint32_t dest=get_uint32(buf->start);
1365     uint32_t msgtype=get_uint32(buf->start+8);
1366     struct msg named_msg;
1367
1368     if (msgtype==LABEL_MSG1) {
1369         if (!named_for_us(st,buf,msgtype,&named_msg))
1370             return False;
1371         /* It's a MSG1 addressed to us. Decide what to do about it. */
1372         dump_packet(st,buf,source,True);
1373         if (st->state==SITE_RUN || st->state==SITE_RESOLVE ||
1374             st->state==SITE_WAIT) {
1375             /* We should definitely process it */
1376             if (process_msg1(st,buf,source,&named_msg)) {
1377                 slog(st,LOG_SETUP_INIT,"key setup initiated by peer");
1378                 enter_new_state(st,SITE_SENTMSG2);
1379             } else {
1380                 slog(st,LOG_ERROR,"failed to process incoming msg1");
1381             }
1382             BUF_FREE(buf);
1383             return True;
1384         } else if (st->state==SITE_SENTMSG1) {
1385             /* We've just sent a message 1! They may have crossed on
1386                the wire. If we have priority then we ignore the
1387                incoming one, otherwise we process it as usual. */
1388             if (st->setup_priority) {
1389                 BUF_FREE(buf);
1390                 slog(st,LOG_DUMP,"crossed msg1s; we are higher "
1391                      "priority => ignore incoming msg1");
1392                 return True;
1393             } else {
1394                 slog(st,LOG_DUMP,"crossed msg1s; we are lower "
1395                      "priority => use incoming msg1");
1396                 if (process_msg1(st,buf,source,&named_msg)) {
1397                     BUF_FREE(&st->buffer); /* Free our old message 1 */
1398                     enter_new_state(st,SITE_SENTMSG2);
1399                 } else {
1400                     slog(st,LOG_ERROR,"failed to process an incoming "
1401                          "crossed msg1 (we have low priority)");
1402                 }
1403                 BUF_FREE(buf);
1404                 return True;
1405             }
1406         }
1407         /* The message 1 was received at an unexpected stage of the
1408            key setup. XXX POLICY - what do we do? */
1409         slog(st,LOG_UNEXPECTED,"unexpected incoming message 1");
1410         BUF_FREE(buf);
1411         return True;
1412     }
1413     if (dest==st->index) {
1414         /* Explicitly addressed to us */
1415         if (msgtype!=LABEL_MSG0) dump_packet(st,buf,source,True);
1416         switch (msgtype) {
1417         case LABEL_NAK:
1418             /* If the source is our current peer then initiate a key setup,
1419                because our peer's forgotten the key */
1420             if (get_uint32(buf->start+4)==st->current.remote_session_id) {
1421                 initiate_key_setup(st,"received a NAK");
1422             } else {
1423                 slog(st,LOG_SEC,"bad incoming NAK");
1424             }
1425             break;
1426         case LABEL_MSG0:
1427             process_msg0(st,buf,source);
1428             break;
1429         case LABEL_MSG1:
1430             /* Setup packet: should not have been explicitly addressed
1431                to us */
1432             slog(st,LOG_SEC,"incoming explicitly addressed msg1");
1433             break;
1434         case LABEL_MSG2:
1435             /* Setup packet: expected only in state SENTMSG1 */
1436             if (st->state!=SITE_SENTMSG1) {
1437                 slog(st,LOG_UNEXPECTED,"unexpected MSG2");
1438             } else if (process_msg2(st,buf,source)) {
1439                 transport_setup_msgok(st,source);
1440                 enter_new_state(st,SITE_SENTMSG3);
1441             } else {
1442                 slog(st,LOG_SEC,"invalid MSG2");
1443             }
1444             break;
1445         case LABEL_MSG3:
1446             /* Setup packet: expected only in state SENTMSG2 */
1447             if (st->state!=SITE_SENTMSG2) {
1448                 slog(st,LOG_UNEXPECTED,"unexpected MSG3");
1449             } else if (process_msg3(st,buf,source)) {
1450                 transport_setup_msgok(st,source);
1451                 enter_new_state(st,SITE_SENTMSG4);
1452             } else {
1453                 slog(st,LOG_SEC,"invalid MSG3");
1454             }
1455             break;
1456         case LABEL_MSG4:
1457             /* Setup packet: expected only in state SENTMSG3 */
1458             if (st->state!=SITE_SENTMSG3) {
1459                 slog(st,LOG_UNEXPECTED,"unexpected MSG4");
1460             } else if (process_msg4(st,buf,source)) {
1461                 transport_setup_msgok(st,source);
1462                 enter_new_state(st,SITE_SENTMSG5);
1463             } else {
1464                 slog(st,LOG_SEC,"invalid MSG4");
1465             }
1466             break;
1467         case LABEL_MSG5:
1468             /* Setup packet: expected only in state SENTMSG4 */
1469             /* (may turn up in state RUN if our return MSG6 was lost
1470                and the new key has already been activated. In that
1471                case we discard it. The peer will realise that we
1472                are using the new key when they see our data packets.
1473                Until then the peer's data packets to us get discarded. */
1474             if (st->state==SITE_SENTMSG4) {
1475                 if (process_msg5(st,buf,source,st->new_transform)) {
1476                     transport_setup_msgok(st,source);
1477                     enter_new_state(st,SITE_RUN);
1478                 } else {
1479                     slog(st,LOG_SEC,"invalid MSG5");
1480                 }
1481             } else if (st->state==SITE_RUN) {
1482                 if (process_msg5(st,buf,source,st->current.transform)) {
1483                     slog(st,LOG_DROP,"got MSG5, retransmitting MSG6");
1484                     transport_setup_msgok(st,source);
1485                     create_msg6(st,st->current.transform,
1486                                 st->current.remote_session_id);
1487                     transport_xmit(st,&st->peers,&st->buffer,True);
1488                     BUF_FREE(&st->buffer);
1489                 } else {
1490                     slog(st,LOG_SEC,"invalid MSG5 (in state RUN)");
1491                 }
1492             } else {
1493                 slog(st,LOG_UNEXPECTED,"unexpected MSG5");
1494             }
1495             break;
1496         case LABEL_MSG6:
1497             /* Setup packet: expected only in state SENTMSG5 */
1498             if (st->state!=SITE_SENTMSG5) {
1499                 slog(st,LOG_UNEXPECTED,"unexpected MSG6");
1500             } else if (process_msg6(st,buf,source)) {
1501                 BUF_FREE(&st->buffer); /* Free message 5 */
1502                 transport_setup_msgok(st,source);
1503                 activate_new_key(st);
1504             } else {
1505                 slog(st,LOG_SEC,"invalid MSG6");
1506             }
1507             break;
1508         default:
1509             slog(st,LOG_SEC,"received message of unknown type 0x%08x",
1510                  msgtype);
1511             break;
1512         }
1513         BUF_FREE(buf);
1514         return True;
1515     }
1516
1517     return False;
1518 }
1519
1520 static void site_control(void *vst, bool_t run)
1521 {
1522     struct site *st=vst;
1523     if (run) enter_state_run(st);
1524     else enter_state_stop(st);
1525 }
1526
1527 static void site_phase_hook(void *sst, uint32_t newphase)
1528 {
1529     struct site *st=sst;
1530
1531     /* The program is shutting down; tell our peer */
1532     send_msg7(st,"shutting down");
1533 }
1534
1535 static list_t *site_apply(closure_t *self, struct cloc loc, dict_t *context,
1536                           list_t *args)
1537 {
1538     static uint32_t index_sequence;
1539     struct site *st;
1540     item_t *item;
1541     dict_t *dict;
1542     int i;
1543
1544     st=safe_malloc(sizeof(*st),"site_apply");
1545
1546     st->cl.description="site";
1547     st->cl.type=CL_SITE;
1548     st->cl.apply=NULL;
1549     st->cl.interface=&st->ops;
1550     st->ops.st=st;
1551     st->ops.control=site_control;
1552     st->ops.status=site_status;
1553
1554     /* First parameter must be a dict */
1555     item=list_elem(args,0);
1556     if (!item || item->type!=t_dict)
1557         cfgfatal(loc,"site","parameter must be a dictionary\n");
1558
1559     dict=item->data.dict;
1560     st->localname=dict_read_string(dict, "local-name", True, "site", loc);
1561     st->remotename=dict_read_string(dict, "name", True, "site", loc);
1562
1563     st->peer_mobile=dict_read_bool(dict,"mobile",False,"site",loc,False);
1564     bool_t local_mobile=
1565         dict_read_bool(dict,"local-mobile",False,"site",loc,False);
1566
1567     /* Sanity check (which also allows the 'sites' file to include
1568        site() closures for all sites including our own): refuse to
1569        talk to ourselves */
1570     if (strcmp(st->localname,st->remotename)==0) {
1571         Message(M_DEBUG,"site %s: local-name==name -> ignoring this site\n",
1572                 st->localname);
1573         if (st->peer_mobile != local_mobile)
1574             cfgfatal(loc,"site","site %s's peer-mobile=%d"
1575                     " but our local-mobile=%d\n",
1576                     st->localname, st->peer_mobile, local_mobile);
1577         free(st);
1578         return NULL;
1579     }
1580     if (st->peer_mobile && local_mobile) {
1581         Message(M_WARNING,"site %s: site is mobile but so are we"
1582                 " -> ignoring this site\n", st->remotename);
1583         free(st);
1584         return NULL;
1585     }
1586
1587     assert(index_sequence < 0xffffffffUL);
1588     st->index = ++index_sequence;
1589     st->local_capabilities = 0;
1590     st->netlink=find_cl_if(dict,"link",CL_NETLINK,True,"site",loc);
1591
1592     list_t *comms_cfg=dict_lookup(dict,"comm");
1593     if (!comms_cfg) cfgfatal(loc,"site","closure list \"comm\" not found\n");
1594     st->ncomms=list_length(comms_cfg);
1595     st->comms=safe_malloc_ary(sizeof(*st->comms),st->ncomms,"comms");
1596     assert(st->ncomms);
1597     for (i=0; i<st->ncomms; i++) {
1598         item_t *item=list_elem(comms_cfg,i);
1599         if (item->type!=t_closure)
1600             cfgfatal(loc,"site","comm is not a closure\n");
1601         closure_t *cl=item->data.closure;
1602         if (cl->type!=CL_COMM) cfgfatal(loc,"site","comm closure wrong type\n");
1603         st->comms[i]=cl->interface;
1604     }
1605
1606     st->resolver=find_cl_if(dict,"resolver",CL_RESOLVER,True,"site",loc);
1607     st->log=find_cl_if(dict,"log",CL_LOG,True,"site",loc);
1608     st->random=find_cl_if(dict,"random",CL_RANDOMSRC,True,"site",loc);
1609
1610     st->privkey=find_cl_if(dict,"local-key",CL_RSAPRIVKEY,True,"site",loc);
1611     st->address=dict_read_string(dict, "address", False, "site", loc);
1612     if (st->address)
1613         st->remoteport=dict_read_number(dict,"port",True,"site",loc,0);
1614     else st->remoteport=0;
1615     st->pubkey=find_cl_if(dict,"key",CL_RSAPUBKEY,True,"site",loc);
1616
1617     st->transform=
1618         find_cl_if(dict,"transform",CL_TRANSFORM,True,"site",loc);
1619
1620     st->dh=find_cl_if(dict,"dh",CL_DH,True,"site",loc);
1621     st->hash=find_cl_if(dict,"hash",CL_HASH,True,"site",loc);
1622
1623 #define DEFAULT(D) (st->peer_mobile || local_mobile     \
1624                     ? DEFAULT_MOBILE_##D : DEFAULT_##D)
1625 #define CFG_NUMBER(k,D) dict_read_number(dict,(k),False,"site",loc,DEFAULT(D));
1626
1627     st->key_lifetime=         CFG_NUMBER("key-lifetime",  KEY_LIFETIME);
1628     st->setup_retries=        CFG_NUMBER("setup-retries", SETUP_RETRIES);
1629     st->setup_retry_interval= CFG_NUMBER("setup-timeout", SETUP_RETRY_INTERVAL);
1630     st->wait_timeout=         CFG_NUMBER("wait-time",     WAIT_TIME);
1631
1632     st->mobile_peer_expiry= dict_read_number(
1633        dict,"mobile-peer-expiry",False,"site",loc,DEFAULT_MOBILE_PEER_EXPIRY);
1634
1635     st->transport_peers_max= !st->peer_mobile ? 1 : dict_read_number(
1636         dict,"mobile-peers-max",False,"site",loc,DEFAULT_MOBILE_PEERS_MAX);
1637     if (st->transport_peers_max<1 ||
1638         st->transport_peers_max>=MAX_MOBILE_PEERS_MAX) {
1639         cfgfatal(loc,"site","mobile-peers-max must be in range 1.."
1640                  STRING(MAX_MOBILE_PEERS_MAX) "\n");
1641     }
1642
1643     if (st->key_lifetime < DEFAULT(KEY_RENEGOTIATE_GAP)*2)
1644         st->key_renegotiate_time=st->key_lifetime/2;
1645     else
1646         st->key_renegotiate_time=st->key_lifetime-DEFAULT(KEY_RENEGOTIATE_GAP);
1647     st->key_renegotiate_time=dict_read_number(
1648         dict,"renegotiate-time",False,"site",loc,st->key_renegotiate_time);
1649     if (st->key_renegotiate_time > st->key_lifetime) {
1650         cfgfatal(loc,"site",
1651                  "renegotiate-time must be less than key-lifetime\n");
1652     }
1653
1654     st->log_events=string_list_to_word(dict_lookup(dict,"log-events"),
1655                                        log_event_table,"site");
1656
1657     st->tunname=safe_malloc(strlen(st->localname)+strlen(st->remotename)+5,
1658                             "site_apply");
1659     sprintf(st->tunname,"%s<->%s",st->localname,st->remotename);
1660
1661     /* The information we expect to see in incoming messages of type 1 */
1662     /* fixme: lots of unchecked overflows here, but the results are only
1663        corrupted packets rather than undefined behaviour */
1664     st->setup_priority=(strcmp(st->localname,st->remotename)>0);
1665
1666     buffer_new(&st->buffer,SETUP_BUFFER_LEN);
1667
1668     buffer_new(&st->scratch,0);
1669     BUF_ALLOC(&st->scratch,"site:scratch");
1670
1671     /* We are interested in poll(), but only for timeouts. We don't have
1672        any fds of our own. */
1673     register_for_poll(st, site_beforepoll, site_afterpoll, 0, "site");
1674     st->timeout=0;
1675
1676     st->remote_capabilities=0;
1677     st->current.key_timeout=0;
1678     st->auxiliary_key.key_timeout=0;
1679     transport_peers_clear(st,&st->peers);
1680     transport_peers_clear(st,&st->setup_peers);
1681     /* XXX mlock these */
1682     st->dhsecret=safe_malloc(st->dh->len,"site:dhsecret");
1683     st->sharedsecretlen=st->transform->keylen?:st->dh->ceil_len;
1684     st->sharedsecret=safe_malloc(st->sharedsecretlen,"site:sharedsecret");
1685
1686     /* We need to compute some properties of our comms */
1687 #define COMPUTE_WORST(pad)                      \
1688     int worst_##pad=0;                          \
1689     for (i=0; i<st->ncomms; i++) {              \
1690         int thispad=st->comms[i]->pad;          \
1691         if (thispad > worst_##pad)              \
1692             worst_##pad=thispad;                \
1693     }
1694     COMPUTE_WORST(min_start_pad)
1695     COMPUTE_WORST(min_end_pad)
1696
1697     /* We need to register the remote networks with the netlink device */
1698     st->netlink->reg(st->netlink->st, site_outgoing, st,
1699                      st->transform->max_start_pad+(4*4)+
1700                      worst_min_start_pad,
1701                      st->transform->max_end_pad+worst_min_end_pad);
1702
1703     for (i=0; i<st->ncomms; i++)
1704         st->comms[i]->request_notify(st->comms[i]->st, st, site_incoming);
1705
1706     st->current.transform=st->transform->create(st->transform->st);
1707     st->auxiliary_key.transform=st->transform->create(st->transform->st);
1708     st->new_transform=st->transform->create(st->transform->st);
1709     st->auxiliary_is_new=0;
1710
1711     enter_state_stop(st);
1712
1713     add_hook(PHASE_SHUTDOWN,site_phase_hook,st);
1714
1715     return new_closure(&st->cl);
1716 }
1717
1718 void site_module(dict_t *dict)
1719 {
1720     add_closure(dict,"site",site_apply);
1721 }
1722
1723
1724 /***** TRANSPORT PEERS definitions *****/
1725
1726 static void transport_peers_debug(struct site *st, transport_peers *dst,
1727                                   const char *didwhat,
1728                                   int nargs, const struct comm_addr *args,
1729                                   size_t stride) {
1730     int i;
1731     char *argp;
1732
1733     if (!(st->log_events & LOG_PEER_ADDRS))
1734         return; /* an optimisation */
1735
1736     slog(st, LOG_PEER_ADDRS, "peers (%s) %s nargs=%d => npeers=%d",
1737          (dst==&st->peers ? "data" :
1738           dst==&st->setup_peers ? "setup" : "UNKNOWN"),
1739          didwhat, nargs, dst->npeers);
1740
1741     for (i=0, argp=(void*)args;
1742          i<nargs;
1743          i++, (argp+=stride?stride:sizeof(*args))) {
1744         const struct comm_addr *ca=(void*)argp;
1745         slog(st, LOG_PEER_ADDRS, " args: addrs[%d]=%s",
1746              i, ca->comm->addr_to_string(ca->comm->st,ca));
1747     }
1748     for (i=0; i<dst->npeers; i++) {
1749         struct timeval diff;
1750         timersub(tv_now,&dst->peers[i].last,&diff);
1751         const struct comm_addr *ca=&dst->peers[i].addr;
1752         slog(st, LOG_PEER_ADDRS, " peers: addrs[%d]=%s T-%ld.%06ld",
1753              i, ca->comm->addr_to_string(ca->comm->st,ca),
1754              (unsigned long)diff.tv_sec, (unsigned long)diff.tv_usec);
1755     }
1756 }
1757
1758 static int transport_peer_compar(const void *av, const void *bv) {
1759     const transport_peer *a=av;
1760     const transport_peer *b=bv;
1761     /* put most recent first in the array */
1762     if (timercmp(&a->last, &b->last, <)) return +1;
1763     if (timercmp(&a->last, &b->last, >)) return -11;
1764     return 0;
1765 }
1766
1767 static void transport_peers_expire(struct site *st, transport_peers *peers) {
1768     /* peers must be sorted first */
1769     int previous_peers=peers->npeers;
1770     struct timeval oldest;
1771     oldest.tv_sec  = tv_now->tv_sec - st->mobile_peer_expiry;
1772     oldest.tv_usec = tv_now->tv_usec;
1773     while (peers->npeers>1 &&
1774            timercmp(&peers->peers[peers->npeers-1].last, &oldest, <))
1775         peers->npeers--;
1776     if (peers->npeers != previous_peers)
1777         transport_peers_debug(st,peers,"expire", 0,0,0);
1778 }
1779
1780 static void transport_record_peer(struct site *st, transport_peers *peers,
1781                                   const struct comm_addr *addr, const char *m) {
1782     int slot, changed=0;
1783
1784     for (slot=0; slot<peers->npeers; slot++)
1785         if (!memcmp(&peers->peers[slot].addr, addr, sizeof(*addr)))
1786             goto found;
1787
1788     changed=1;
1789     if (peers->npeers==st->transport_peers_max)
1790         slot=st->transport_peers_max;
1791     else
1792         slot=peers->npeers++;
1793
1794  found:
1795     peers->peers[slot].addr=*addr;
1796     peers->peers[slot].last=*tv_now;
1797
1798     if (peers->npeers>1)
1799         qsort(peers->peers, peers->npeers,
1800               sizeof(*peers->peers), transport_peer_compar);
1801
1802     if (changed || peers->npeers!=1)
1803         transport_peers_debug(st,peers,m, 1,addr,0);
1804     transport_peers_expire(st, peers);
1805 }
1806
1807 static bool_t transport_compute_setupinit_peers(struct site *st,
1808         const struct comm_addr *configured_addr /* 0 if none or not found */) {
1809
1810     if (!configured_addr && !transport_peers_valid(&st->peers))
1811         return False;
1812
1813     slog(st,LOG_SETUP_INIT,
1814          (!configured_addr ? "using only %d old peer address(es)"
1815           : "using configured address, and/or perhaps %d old peer address(es)"),
1816          st->peers);
1817
1818     /* Non-mobile peers havve st->peers.npeers==0 or ==1, since they
1819      * have transport_peers_max==1.  The effect is that this code
1820      * always uses the configured address if supplied, or otherwise
1821      * the existing data peer if one exists; this is as desired. */
1822
1823     transport_peers_copy(st,&st->setup_peers,&st->peers);
1824
1825     if (configured_addr)
1826         transport_record_peer(st,&st->setup_peers,configured_addr,"setupinit");
1827
1828     assert(transport_peers_valid(&st->setup_peers));
1829     return True;
1830 }
1831
1832 static void transport_setup_msgok(struct site *st, const struct comm_addr *a) {
1833     if (st->peer_mobile)
1834         transport_record_peer(st,&st->setup_peers,a,"setupmsg");
1835 }
1836 static void transport_data_msgok(struct site *st, const struct comm_addr *a) {
1837     if (st->peer_mobile)
1838         transport_record_peer(st,&st->peers,a,"datamsg");
1839 }
1840
1841 static int transport_peers_valid(transport_peers *peers) {
1842     return peers->npeers;
1843 }
1844 static void transport_peers_clear(struct site *st, transport_peers *peers) {
1845     peers->npeers= 0;
1846     transport_peers_debug(st,peers,"clear",0,0,0);
1847 }
1848 static void transport_peers_copy(struct site *st, transport_peers *dst,
1849                                  const transport_peers *src) {
1850     dst->npeers=src->npeers;
1851     memcpy(dst->peers, src->peers, sizeof(*dst->peers) * dst->npeers);
1852     transport_peers_debug(st,dst,"copy",
1853                           src->npeers, &src->peers->addr, sizeof(*src->peers));
1854 }
1855
1856 void transport_xmit(struct site *st, transport_peers *peers,
1857                     struct buffer_if *buf, bool_t candebug) {
1858     int slot;
1859     transport_peers_expire(st, peers);
1860     for (slot=0; slot<peers->npeers; slot++) {
1861         transport_peer *peer=&peers->peers[slot];
1862         if (candebug)
1863             dump_packet(st, buf, &peer->addr, False);
1864         peer->addr.comm->sendmsg(peer->addr.comm->st, buf, &peer->addr);
1865     }
1866 }
1867
1868 /***** END of transport peers declarations *****/