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 3600000 /* One hour */
  31 #define DEFAULT_KEY_RENEGOTIATE_GAP 300000 /* Five minutes */
  32 #define DEFAULT_SETUP_RETRIES 5
  33 #define DEFAULT_SETUP_TIMEOUT 2000
  34 #define DEFAULT_WAIT_TIME 20000
  35
  36 /* Each site can be in one of several possible states. */
  37
  38 /* States:
  39    SITE_STOP         - nothing is allowed to happen; tunnel is down;
  40                        all session keys have been erased
  41      -> SITE_RUN upon external instruction
  42    SITE_RUN          - site up, maybe with valid key
  43      -> SITE_RESOLVE upon outgoing packet and no valid key
  44          we start name resolution for the other end of the tunnel
  45      -> SITE_SENTMSG2 upon valid incoming message 1 and suitable time
  46          we send an appropriate message 2
  47    SITE_RESOLVE      - waiting for name resolution
  48      -> SITE_SENTMSG1 upon successful resolution
  49          we send an appropriate message 1
  50      -> SITE_SENTMSG2 upon valid incoming message 1 (then abort resolution)
  51          we abort resolution and
  52      -> SITE_WAIT on timeout or resolution failure
  53    SITE_SENTMSG1
  54      -> SITE_SENTMSG2 upon valid incoming message 1 from higher priority end
  55      -> SITE_SENTMSG3 upon valid incoming message 2
  56      -> SITE_WAIT on timeout
  57    SITE_SENTMSG2
  58      -> SITE_SENTMSG4 upon valid incoming message 3
  59      -> SITE_WAIT on timeout
  60    SITE_SENTMSG3
  61      -> SITE_SENTMSG5 upon valid incoming message 4
  62      -> SITE_WAIT on timeout
  63    SITE_SENTMSG4
  64      -> SITE_RUN upon valid incoming message 5
  65      -> SITE_WAIT on timeout
  66    SITE_SENTMSG5
  67      -> SITE_RUN upon valid incoming message 6
  68      -> SITE_WAIT on timeout
  69    SITE_WAIT         - failed to establish key; do nothing for a while
  70      -> SITE_RUN on timeout
  71    */
  72
  73 #define SITE_STOP     0
  74 #define SITE_RUN      1
  75 #define SITE_RESOLVE  2
  76 #define SITE_SENTMSG1 3
  77 #define SITE_SENTMSG2 4
  78 #define SITE_SENTMSG3 5
  79 #define SITE_SENTMSG4 6
  80 #define SITE_SENTMSG5 7
  81 #define SITE_WAIT     8
  82
  83 static cstring_t state_name(uint32_t state)
  84 {
  85     switch (state) {
  86     case 0: return "STOP";
  87     case 1: return "RUN";
  88     case 2: return "RESOLVE";
  89     case 3: return "SENTMSG1";
  90     case 4: return "SENTMSG2";
  91     case 5: return "SENTMSG3";
  92     case 6: return "SENTMSG4";
  93     case 7: return "SENTMSG5";
  94     case 8: return "WAIT";
  95     default: return "*bad state*";
  96     }
  97 }
  98
  99 #define NONCELEN 8
 100
 101 #define LOG_UNEXPECTED    0x00000001
 102 #define LOG_SETUP_INIT    0x00000002
 103 #define LOG_SETUP_TIMEOUT 0x00000004
 104 #define LOG_ACTIVATE_KEY  0x00000008
 105 #define LOG_TIMEOUT_KEY   0x00000010
 106 #define LOG_SEC           0x00000020
 107 #define LOG_STATE         0x00000040
 108 #define LOG_DROP          0x00000080
 109 #define LOG_DUMP          0x00000100
 110 #define LOG_ERROR         0x00000400
 111
 112 static struct flagstr log_event_table[]={
 113     { "unexpected", LOG_UNEXPECTED },
 114     { "setup-init", LOG_SETUP_INIT },
 115     { "setup-timeout", LOG_SETUP_TIMEOUT },
 116     { "activate-key", LOG_ACTIVATE_KEY },
 117     { "timeout-key", LOG_TIMEOUT_KEY },
 118     { "security", LOG_SEC },
 119     { "state-change", LOG_STATE },
 120     { "packet-drop", LOG_DROP },
 121     { "dump-packets", LOG_DUMP },
 122     { "errors", LOG_ERROR },
 123     { "default", LOG_SETUP_INIT|LOG_SETUP_TIMEOUT|
 124       LOG_ACTIVATE_KEY|LOG_TIMEOUT_KEY|LOG_SEC|LOG_ERROR },
 125     { "all", 0xffffffff },
 126     { NULL, 0 }
 127 };
 128
 129 struct site {
 130     closure_t cl;
 131     struct site_if ops;
 132 /* configuration information */
 133     string_t localname;
 134     string_t remotename;
 135     string_t tunname; /* localname<->remotename by default, used in logs */
 136     string_t address; /* DNS name for bootstrapping, optional */
 137     int remoteport; /* Port for bootstrapping, optional */
 138     struct netlink_if *netlink;
 139     struct comm_if *comm;
 140     struct resolver_if *resolver;
 141     struct log_if *log;
 142     struct random_if *random;
 143     struct rsaprivkey_if *privkey;
 144     struct rsapubkey_if *pubkey;
 145     struct transform_if *transform;
 146     struct dh_if *dh;
 147     struct hash_if *hash;
 148
 149     uint32_t index; /* Index of this site */
 150     int32_t setup_retries; /* How many times to send setup packets */
 151     int32_t setup_timeout; /* Initial timeout for setup packets */
 152     int32_t wait_timeout; /* How long to wait if setup unsuccessful */
 153     int32_t key_lifetime; /* How long a key lasts once set up */
 154     int32_t key_renegotiate_time; /* If we see traffic (or a keepalive)
 155                                       after this time, initiate a new
 156                                       key exchange */
 157
 158     uint8_t *setupsig; /* Expected signature of incoming MSG1 packets */
 159     int32_t setupsiglen; /* Allows us to discard packets quickly if
 160                             they are not for us */
 161     bool_t setup_priority; /* Do we have precedence if both sites emit
 162                               message 1 simultaneously? */
 163     uint32_t log_events;
 164
 165 /* runtime information */
 166     uint32_t state;
 167     uint64_t now; /* Most recently seen time */
 168
 169     /* The currently established session */
 170     uint32_t remote_session_id;
 171     struct transform_inst_if *current_transform;
 172     bool_t current_valid;
 173     uint64_t current_key_timeout; /* End of life of current key */
 174     uint64_t renegotiate_key_time; /* When we can negotiate a new key */
 175     struct sockaddr_in peer; /* Current address of peer */
 176     bool_t peer_valid; /* Peer address becomes invalid when key times out,
 177                           but only if we have a DNS name for our peer */
 178
 179     /* The current key setup protocol exchange.  We can only be
 180        involved in one of these at a time.  There's a potential for
 181        denial of service here (the attacker keeps sending a setup
 182        packet; we keep trying to continue the exchange, and have to
 183        timeout before we can listen for another setup packet); perhaps
 184        we should keep a list of 'bad' sources for setup packets. */
 185     uint32_t setup_session_id;
 186     struct sockaddr_in setup_peer;
 187     uint8_t localN[NONCELEN]; /* Nonces for key exchange */
 188     uint8_t remoteN[NONCELEN];
 189     struct buffer_if buffer; /* Current outgoing key exchange packet */
 190     int32_t retries; /* Number of retries remaining */
 191     uint64_t timeout; /* Timeout for current state */
 192     uint8_t *dhsecret;
 193     uint8_t *sharedsecret;
 194     struct transform_inst_if *new_transform; /* For key setup/verify */
 195 };
 196
 197 static void slog(struct site *st, uint32_t event, cstring_t msg, ...)
 198 {
 199     va_list ap;
 200     char buf[240];
 201     uint32_t class;
 202
 203     va_start(ap,msg);
 204
 205     if (event&st->log_events) {
 206         switch(event) {
 207         case LOG_UNEXPECTED: class=M_INFO; break;
 208         case LOG_SETUP_INIT: class=M_INFO; break;
 209         case LOG_SETUP_TIMEOUT: class=M_NOTICE; break;
 210         case LOG_ACTIVATE_KEY: class=M_INFO; break;
 211         case LOG_TIMEOUT_KEY: class=M_INFO; break;
 212         case LOG_SEC: class=M_SECURITY; break;
 213         case LOG_STATE: class=M_DEBUG; break;
 214         case LOG_DROP: class=M_DEBUG; break;
 215         case LOG_DUMP: class=M_DEBUG; break;
 216         case LOG_ERROR: class=M_ERR; break;
 217         default: class=M_ERR; break;
 218         }
 219
 220         vsnprintf(buf,sizeof(buf),msg,ap);
 221         st->log->log(st->log->st,class,"%s: %s",st->tunname,buf);
 222     }
 223     va_end(ap);
 224 }
 225
 226 static void set_link_quality(struct site *st);
 227 static void delete_key(struct site *st, cstring_t reason, uint32_t loglevel);
 228 static bool_t initiate_key_setup(struct site *st, cstring_t reason);
 229 static void enter_state_run(struct site *st);
 230 static bool_t enter_state_resolve(struct site *st);
 231 static bool_t enter_new_state(struct site *st,uint32_t next);
 232 static void enter_state_wait(struct site *st);
 233
 234 #define CHECK_AVAIL(b,l) do { if ((b)->size<(l)) return False; } while(0)
 235 #define CHECK_EMPTY(b) do { if ((b)->size!=0) return False; } while(0)
 236 #define CHECK_TYPE(b,t) do { uint32_t type; \
 237     CHECK_AVAIL((b),4); \
 238     type=buf_unprepend_uint32((b)); \
 239     if (type!=(t)) return False; } while(0)
 240
 241 struct msg {
 242     uint8_t *hashstart;
 243     uint32_t dest;
 244     uint32_t source;
 245     int32_t remlen;
 246     uint8_t *remote;
 247     int32_t loclen;
 248     uint8_t *local;
 249     uint8_t *nR;
 250     uint8_t *nL;
 251     int32_t pklen;
 252     char *pk;
 253     int32_t hashlen;
 254     int32_t siglen;
 255     char *sig;
 256 };
 257
 258 /* Build any of msg1 to msg4. msg5 and msg6 are built from the inside
 259    out using a transform of config data supplied by netlink */
 260 static bool_t generate_msg(struct site *st, uint32_t type, cstring_t what)
 261 {
 262     void *hst;
 263     uint8_t *hash;
 264     string_t dhpub, sig;
 265
 266     st->retries=st->setup_retries;
 267     BUF_ALLOC(&st->buffer,what);
 268     buffer_init(&st->buffer,0);
 269     buf_append_uint32(&st->buffer,
 270         (type==LABEL_MSG1?0:st->setup_session_id));
 271     buf_append_uint32(&st->buffer,st->index);
 272     buf_append_uint32(&st->buffer,type);
 273     buf_append_string(&st->buffer,st->localname);
 274     buf_append_string(&st->buffer,st->remotename);
 275     memcpy(buf_append(&st->buffer,NONCELEN),st->localN,NONCELEN);
 276     if (type==LABEL_MSG1) return True;
 277     memcpy(buf_append(&st->buffer,NONCELEN),st->remoteN,NONCELEN);
 278     if (type==LABEL_MSG2) return True;
 279
 280     if (hacky_par_mid_failnow()) return False;
 281
 282     dhpub=st->dh->makepublic(st->dh->st,st->dhsecret,st->dh->len);
 283     buf_append_string(&st->buffer,dhpub);
 284     free(dhpub);
 285     hash=safe_malloc(st->hash->len, "generate_msg");
 286     hst=st->hash->init();
 287     st->hash->update(hst,st->buffer.start,st->buffer.size);
 288     st->hash->final(hst,hash);
 289     sig=st->privkey->sign(st->privkey->st,hash,st->hash->len);
 290     buf_append_string(&st->buffer,sig);
 291     free(sig);
 292     free(hash);
 293     return True;
 294 }
 295
 296 static bool_t unpick_msg(struct site *st, uint32_t type,
 297                          struct buffer_if *msg, struct msg *m)
 298 {
 299     m->hashstart=msg->start;
 300     CHECK_AVAIL(msg,4);
 301     m->dest=buf_unprepend_uint32(msg);
 302     CHECK_AVAIL(msg,4);
 303     m->source=buf_unprepend_uint32(msg);
 304     CHECK_TYPE(msg,type);
 305     CHECK_AVAIL(msg,2);
 306     m->remlen=buf_unprepend_uint16(msg);
 307     CHECK_AVAIL(msg,m->remlen);
 308     m->remote=buf_unprepend(msg,m->remlen);
 309     CHECK_AVAIL(msg,2);
 310     m->loclen=buf_unprepend_uint16(msg);
 311     CHECK_AVAIL(msg,m->loclen);
 312     m->local=buf_unprepend(msg,m->loclen);
 313     CHECK_AVAIL(msg,NONCELEN);
 314     m->nR=buf_unprepend(msg,NONCELEN);
 315     if (type==LABEL_MSG1) {
 316         CHECK_EMPTY(msg);
 317         return True;
 318     }
 319     CHECK_AVAIL(msg,NONCELEN);
 320     m->nL=buf_unprepend(msg,NONCELEN);
 321     if (type==LABEL_MSG2) {
 322         CHECK_EMPTY(msg);
 323         return True;
 324     }
 325     CHECK_AVAIL(msg,2);
 326     m->pklen=buf_unprepend_uint16(msg);
 327     CHECK_AVAIL(msg,m->pklen);
 328     m->pk=buf_unprepend(msg,m->pklen);
 329     m->hashlen=msg->start-m->hashstart;
 330     CHECK_AVAIL(msg,2);
 331     m->siglen=buf_unprepend_uint16(msg);
 332     CHECK_AVAIL(msg,m->siglen);
 333     m->sig=buf_unprepend(msg,m->siglen);
 334     CHECK_EMPTY(msg);
 335     return True;
 336 }
 337
 338 static bool_t check_msg(struct site *st, uint32_t type, struct msg *m,
 339                         cstring_t *error)
 340 {
 341     if (type==LABEL_MSG1) return True;
 342
 343     /* Check that the site names and our nonce have been sent
 344        back correctly, and then store our peer's nonce. */
 345     if (memcmp(m->remote,st->remotename,strlen(st->remotename)!=0)) {
 346         *error="wrong remote site name";
 347         return False;
 348     }
 349     if (memcmp(m->local,st->localname,strlen(st->localname)!=0)) {
 350         *error="wrong local site name";
 351         return False;
 352     }
 353     if (memcmp(m->nL,st->localN,NONCELEN)!=0) {
 354         *error="wrong locally-generated nonce";
 355         return False;
 356     }
 357     if (type==LABEL_MSG2) return True;
 358     if (memcmp(m->nR,st->remoteN,NONCELEN)!=0) {
 359         *error="wrong remotely-generated nonce";
 360         return False;
 361     }
 362     if (type==LABEL_MSG3) return True;
 363     if (type==LABEL_MSG4) return True;
 364     *error="unknown message type";
 365     return False;
 366 }
 367
 368 static bool_t generate_msg1(struct site *st)
 369 {
 370     st->random->generate(st->random->st,NONCELEN,st->localN);
 371     return generate_msg(st,LABEL_MSG1,"site:MSG1");
 372 }
 373
 374 static bool_t process_msg1(struct site *st, struct buffer_if *msg1,
 375                            struct sockaddr_in *src)
 376 {
 377     struct msg m;
 378
 379     /* We've already determined we're in an appropriate state to
 380        process an incoming MSG1, and that the MSG1 has correct values
 381        of A and B. */
 382
 383     if (!unpick_msg(st,LABEL_MSG1,msg1,&m)) return False;
 384
 385     st->setup_peer=*src;
 386     st->setup_session_id=m.source;
 387     memcpy(st->remoteN,m.nR,NONCELEN);
 388     return True;
 389 }
 390
 391 static bool_t generate_msg2(struct site *st)
 392 {
 393     st->random->generate(st->random->st,NONCELEN,st->localN);
 394     return generate_msg(st,LABEL_MSG2,"site:MSG2");
 395 }
 396
 397 static bool_t process_msg2(struct site *st, struct buffer_if *msg2,
 398                            struct sockaddr_in *src)
 399 {
 400     struct msg m;
 401     cstring_t err;
 402
 403     if (!unpick_msg(st,LABEL_MSG2,msg2,&m)) return False;
 404     if (!check_msg(st,LABEL_MSG2,&m,&err)) {
 405         slog(st,LOG_SEC,"msg2: %s",err);
 406         return False;
 407     }
 408     st->setup_session_id=m.source;
 409     memcpy(st->remoteN,m.nR,NONCELEN);
 410     return True;
 411 }
 412
 413 static bool_t generate_msg3(struct site *st)
 414 {
 415     /* Now we have our nonce and their nonce. Think of a secret key,
 416        and create message number 3. */
 417     st->random->generate(st->random->st,st->dh->len,st->dhsecret);
 418     return generate_msg(st,LABEL_MSG3,"site:MSG3");
 419 }
 420
 421 static bool_t process_msg3(struct site *st, struct buffer_if *msg3,
 422                            struct sockaddr_in *src)
 423 {
 424     struct msg m;
 425     uint8_t *hash;
 426     void *hst;
 427     cstring_t err;
 428
 429     if (!unpick_msg(st,LABEL_MSG3,msg3,&m)) return False;
 430     if (!check_msg(st,LABEL_MSG3,&m,&err)) {
 431         slog(st,LOG_SEC,"msg3: %s",err);
 432         return False;
 433     }
 434
 435     /* Check signature and store g^x mod m */
 436     hash=safe_malloc(st->hash->len, "process_msg3");
 437     hst=st->hash->init();
 438     st->hash->update(hst,m.hashstart,m.hashlen);
 439     st->hash->final(hst,hash);
 440     /* Terminate signature with a '0' - cheating, but should be ok */
 441     m.sig[m.siglen]=0;
 442     if (!st->pubkey->check(st->pubkey->st,hash,st->hash->len,m.sig)) {
 443         slog(st,LOG_SEC,"msg3 signature failed check!");
 444         free(hash);
 445         return False;
 446     }
 447     free(hash);
 448
 449     /* Terminate their DH public key with a '0' */
 450     m.pk[m.pklen]=0;
 451     /* Invent our DH secret key */
 452     st->random->generate(st->random->st,st->dh->len,st->dhsecret);
 453
 454     /* Generate the shared key */
 455     st->dh->makeshared(st->dh->st,st->dhsecret,st->dh->len,m.pk,
 456                        st->sharedsecret,st->transform->keylen);
 457
 458     /* Set up the transform */
 459     st->new_transform->setkey(st->new_transform->st,st->sharedsecret,
 460                               st->transform->keylen);
 461
 462     return True;
 463 }
 464
 465 static bool_t generate_msg4(struct site *st)
 466 {
 467     /* We have both nonces, their public key and our private key. Generate
 468        our public key, sign it and send it to them. */
 469     return generate_msg(st,LABEL_MSG4,"site:MSG4");
 470 }
 471
 472 static bool_t process_msg4(struct site *st, struct buffer_if *msg4,
 473                            struct sockaddr_in *src)
 474 {
 475     struct msg m;
 476     uint8_t *hash;
 477     void *hst;
 478     cstring_t err;
 479
 480     if (!unpick_msg(st,LABEL_MSG4,msg4,&m)) return False;
 481     if (!check_msg(st,LABEL_MSG4,&m,&err)) {
 482         slog(st,LOG_SEC,"msg4: %s",err);
 483         return False;
 484     }
 485
 486     /* Check signature and store g^x mod m */
 487     hash=safe_malloc(st->hash->len, "process_msg4");
 488     hst=st->hash->init();
 489     st->hash->update(hst,m.hashstart,m.hashlen);
 490     st->hash->final(hst,hash);
 491     /* Terminate signature with a '0' - cheating, but should be ok */
 492     m.sig[m.siglen]=0;
 493     if (!st->pubkey->check(st->pubkey->st,hash,st->hash->len,m.sig)) {
 494         slog(st,LOG_SEC,"msg4 signature failed check!");
 495         free(hash);
 496         return False;
 497     }
 498     free(hash);
 499
 500     /* Terminate their DH public key with a '0' */
 501     m.pk[m.pklen]=0;
 502     /* Generate the shared key */
 503     st->dh->makeshared(st->dh->st,st->dhsecret,st->dh->len,m.pk,
 504                        st->sharedsecret,st->transform->keylen);
 505     /* Set up the transform */
 506     st->new_transform->setkey(st->new_transform->st,st->sharedsecret,
 507                               st->transform->keylen);
 508
 509     return True;
 510 }
 511
 512 struct msg0 {
 513     uint32_t dest;
 514     uint32_t source;
 515     uint32_t type;
 516 };
 517
 518 static bool_t unpick_msg0(struct site *st, struct buffer_if *msg0,
 519                           struct msg0 *m)
 520 {
 521     CHECK_AVAIL(msg0,4);
 522     m->dest=buf_unprepend_uint32(msg0);
 523     CHECK_AVAIL(msg0,4);
 524     m->source=buf_unprepend_uint32(msg0);
 525     CHECK_AVAIL(msg0,4);
 526     m->type=buf_unprepend_uint32(msg0);
 527     return True;
 528     /* Leaves transformed part of buffer untouched */
 529 }
 530
 531 static bool_t generate_msg5(struct site *st)
 532 {
 533     cstring_t transform_err;
 534
 535     BUF_ALLOC(&st->buffer,"site:MSG5");
 536     /* We are going to add four words to the message */
 537     buffer_init(&st->buffer,st->transform->max_start_pad+(4*4));
 538     /* Give the netlink code an opportunity to put its own stuff in the
 539        message (configuration information, etc.) */
 540     st->netlink->output_config(st->netlink->st,&st->buffer);
 541     buf_prepend_uint32(&st->buffer,LABEL_MSG5);
 542     st->new_transform->forwards(st->new_transform->st,&st->buffer,
 543                                 &transform_err);
 544     buf_prepend_uint32(&st->buffer,LABEL_MSG5);
 545     buf_prepend_uint32(&st->buffer,st->index);
 546     buf_prepend_uint32(&st->buffer,st->setup_session_id);
 547
 548     st->retries=st->setup_retries;
 549     return True;
 550 }
 551
 552 static bool_t process_msg5(struct site *st, struct buffer_if *msg5,
 553                            struct sockaddr_in *src)
 554 {
 555     struct msg0 m;
 556     cstring_t transform_err;
 557
 558     if (!unpick_msg0(st,msg5,&m)) return False;
 559
 560     if (st->new_transform->reverse(st->new_transform->st,
 561                                    msg5,&transform_err)) {
 562         /* There's a problem */
 563         slog(st,LOG_SEC,"process_msg5: transform: %s",transform_err);
 564         return False;
 565     }
 566     /* Buffer should now contain untransformed PING packet data */
 567     CHECK_AVAIL(msg5,4);
 568     if (buf_unprepend_uint32(msg5)!=LABEL_MSG5) {
 569         slog(st,LOG_SEC,"MSG5/PING packet contained wrong label");
 570         return False;
 571     }
 572     if (!st->netlink->check_config(st->netlink->st,msg5)) {
 573         slog(st,LOG_SEC,"MSG5/PING packet contained bad netlink config");
 574         return False;
 575     }
 576     CHECK_EMPTY(msg5);
 577     return True;
 578 }
 579
 580 static bool_t generate_msg6(struct site *st)
 581 {
 582     cstring_t transform_err;
 583
 584     BUF_ALLOC(&st->buffer,"site:MSG6");
 585     /* We are going to add four words to the message */
 586     buffer_init(&st->buffer,st->transform->max_start_pad+(4*4));
 587     /* Give the netlink code an opportunity to put its own stuff in the
 588        message (configuration information, etc.) */
 589     st->netlink->output_config(st->netlink->st,&st->buffer);
 590     buf_prepend_uint32(&st->buffer,LABEL_MSG6);
 591     st->new_transform->forwards(st->new_transform->st,&st->buffer,
 592                                 &transform_err);
 593     buf_prepend_uint32(&st->buffer,LABEL_MSG6);
 594     buf_prepend_uint32(&st->buffer,st->index);
 595     buf_prepend_uint32(&st->buffer,st->setup_session_id);
 596
 597     st->retries=1; /* Peer will retransmit MSG5 if this packet gets lost */
 598     return True;
 599 }
 600
 601 static bool_t process_msg6(struct site *st, struct buffer_if *msg6,
 602                            struct sockaddr_in *src)
 603 {
 604     struct msg0 m;
 605     cstring_t transform_err;
 606
 607     if (!unpick_msg0(st,msg6,&m)) return False;
 608
 609     if (st->new_transform->reverse(st->new_transform->st,
 610                                    msg6,&transform_err)) {
 611         /* There's a problem */
 612         slog(st,LOG_SEC,"process_msg6: transform: %s",transform_err);
 613         return False;
 614     }
 615     /* Buffer should now contain untransformed PING packet data */
 616     CHECK_AVAIL(msg6,4);
 617     if (buf_unprepend_uint32(msg6)!=LABEL_MSG6) {
 618         slog(st,LOG_SEC,"MSG6/PONG packet contained invalid data");
 619         return False;
 620     }
 621     if (!st->netlink->check_config(st->netlink->st,msg6)) {
 622         slog(st,LOG_SEC,"MSG6/PONG packet contained bad netlink config");
 623         return False;
 624     }
 625     CHECK_EMPTY(msg6);
 626     return True;
 627 }
 628
 629 static bool_t process_msg0(struct site *st, struct buffer_if *msg0,
 630                            struct sockaddr_in *src)
 631 {
 632     struct msg0 m;
 633     cstring_t transform_err;
 634     uint32_t type;
 635
 636     if (!st->current_valid) {
 637         slog(st,LOG_DROP,"incoming message but no current key -> dropping");
 638         return initiate_key_setup(st,"incoming message but no current key");
 639     }
 640
 641     if (!unpick_msg0(st,msg0,&m)) return False;
 642
 643     if (st->current_transform->reverse(st->current_transform->st,
 644                                        msg0,&transform_err)) {
 645         /* There's a problem */
 646         slog(st,LOG_SEC,"transform: %s",transform_err);
 647         return initiate_key_setup(st,"incoming message would not decrypt");
 648     }
 649     CHECK_AVAIL(msg0,4);
 650     type=buf_unprepend_uint32(msg0);
 651     switch(type) {
 652     case LABEL_MSG7:
 653         /* We must forget about the current session. */
 654         delete_key(st,"request from peer",LOG_SEC);
 655         return True;
 656     case LABEL_MSG9:
 657         /* Deliver to netlink layer */
 658         st->netlink->deliver(st->netlink->st,msg0);
 659         return True;
 660     default:
 661         slog(st,LOG_SEC,"incoming encrypted message of type %08x "
 662              "(unknown)",type);
 663         break;
 664     }
 665     return False;
 666 }
 667
 668 static void dump_packet(struct site *st, struct buffer_if *buf,
 669                         struct sockaddr_in *addr, bool_t incoming)
 670 {
 671     uint32_t dest=ntohl(*(uint32_t *)buf->start);
 672     uint32_t source=ntohl(*(uint32_t *)(buf->start+4));
 673     uint32_t msgtype=ntohl(*(uint32_t *)(buf->start+8));
 674
 675     if (st->log_events & LOG_DUMP)
 676         slilog(st->log,M_DEBUG,"%s: %s: %08x<-%08x: %08x:",
 677                st->tunname,incoming?"incoming":"outgoing",
 678                dest,source,msgtype);
 679 }
 680
 681 static uint32_t site_status(void *st)
 682 {
 683     return 0;
 684 }
 685
 686 static bool_t send_msg(struct site *st)
 687 {
 688     if (st->retries>0) {
 689         dump_packet(st,&st->buffer,&st->setup_peer,False);
 690         st->comm->sendmsg(st->comm->st,&st->buffer,&st->setup_peer);
 691         st->timeout=st->now+st->setup_timeout;
 692         st->retries--;
 693         return True;
 694     } else {
 695         slog(st,LOG_SETUP_TIMEOUT,"timed out sending key setup packet "
 696             "(in state %s)",state_name(st->state));
 697         enter_state_wait(st);
 698         return False;
 699     }
 700 }
 701
 702 static void site_resolve_callback(void *sst, struct in_addr *address)
 703 {
 704     struct site *st=sst;
 705
 706     if (st->state!=SITE_RESOLVE) {
 707         slog(st,LOG_UNEXPECTED,"site_resolve_callback called unexpectedly");
 708         return;
 709     }
 710     if (address) {
 711         memset(&st->setup_peer,0,sizeof(st->setup_peer));
 712         st->setup_peer.sin_family=AF_INET;
 713         st->setup_peer.sin_port=htons(st->remoteport);
 714         st->setup_peer.sin_addr=*address;
 715         enter_new_state(st,SITE_SENTMSG1);
 716     } else {
 717         /* Resolution failed */
 718         slog(st,LOG_ERROR,"resolution of %s failed",st->address);
 719         enter_state_run(st);
 720     }
 721 }
 722
 723 static bool_t initiate_key_setup(struct site *st, cstring_t reason)
 724 {
 725     if (st->state!=SITE_RUN) return False;
 726     slog(st,LOG_SETUP_INIT,"initiating key exchange (%s)",reason);
 727     if (st->address) {
 728         slog(st,LOG_SETUP_INIT,"resolving peer address");
 729         return enter_state_resolve(st);
 730     } else if (st->peer_valid) {
 731         slog(st,LOG_SETUP_INIT,"using old peer address");
 732         st->setup_peer=st->peer;
 733         return enter_new_state(st,SITE_SENTMSG1);
 734     }
 735     slog(st,LOG_SETUP_INIT,"key exchange failed: no address for peer");
 736     return False;
 737 }
 738
 739 static void activate_new_key(struct site *st)
 740 {
 741     struct transform_inst_if *t;
 742
 743     /* We have two transform instances, which we swap between active
 744        and setup */
 745     t=st->current_transform;
 746     st->current_transform=st->new_transform;
 747     st->new_transform=t;
 748
 749     t->delkey(t->st);
 750     st->timeout=0;
 751     st->current_valid=True;
 752     st->current_key_timeout=st->now+st->key_lifetime;
 753     st->renegotiate_key_time=st->now+st->key_renegotiate_time;
 754     st->peer=st->setup_peer;
 755     st->peer_valid=True;
 756     st->remote_session_id=st->setup_session_id;
 757
 758     slog(st,LOG_ACTIVATE_KEY,"new key activated");
 759     enter_state_run(st);
 760 }
 761
 762 static void delete_key(struct site *st, cstring_t reason, uint32_t loglevel)
 763 {
 764     if (st->current_valid) {
 765         slog(st,loglevel,"session closed (%s)",reason);
 766
 767         st->current_valid=False;
 768         st->current_transform->delkey(st->current_transform->st);
 769         st->current_key_timeout=0;
 770         set_link_quality(st);
 771     }
 772 }
 773
 774 static void state_assert(struct site *st, bool_t ok)
 775 {
 776     if (!ok) fatal("site:state_assert");
 777 }
 778
 779 static void enter_state_stop(struct site *st)
 780 {
 781     st->state=SITE_STOP;
 782     st->timeout=0;
 783     delete_key(st,"entering state STOP",LOG_TIMEOUT_KEY);
 784     st->new_transform->delkey(st->new_transform->st);
 785 }
 786
 787 static void set_link_quality(struct site *st)
 788 {
 789     uint32_t quality;
 790     if (st->current_valid)
 791         quality=LINK_QUALITY_UP;
 792     else if (st->state==SITE_WAIT || st->state==SITE_STOP)
 793         quality=LINK_QUALITY_DOWN;
 794     else if (st->address)
 795         quality=LINK_QUALITY_DOWN_CURRENT_ADDRESS;
 796     else if (st->peer_valid)
 797         quality=LINK_QUALITY_DOWN_STALE_ADDRESS;
 798     else
 799         quality=LINK_QUALITY_DOWN;
 800
 801     st->netlink->set_quality(st->netlink->st,quality);
 802 }
 803
 804 static void enter_state_run(struct site *st)
 805 {
 806     slog(st,LOG_STATE,"entering state RUN");
 807     st->state=SITE_RUN;
 808     st->timeout=0;
 809
 810     st->setup_session_id=0;
 811     memset(&st->setup_peer,0,sizeof(st->setup_peer));
 812     memset(st->localN,0,NONCELEN);
 813     memset(st->remoteN,0,NONCELEN);
 814     st->new_transform->delkey(st->new_transform->st);
 815     memset(st->dhsecret,0,st->dh->len);
 816     memset(st->sharedsecret,0,st->transform->keylen);
 817     set_link_quality(st);
 818 }
 819
 820 static bool_t enter_state_resolve(struct site *st)
 821 {
 822     state_assert(st,st->state==SITE_RUN);
 823     slog(st,LOG_STATE,"entering state RESOLVE");
 824     st->state=SITE_RESOLVE;
 825     st->resolver->request(st->resolver->st,st->address,
 826                           site_resolve_callback,st);
 827     return True;
 828 }
 829
 830 static bool_t enter_new_state(struct site *st, uint32_t next)
 831 {
 832     bool_t (*gen)(struct site *st);
 833     int r;
 834
 835     slog(st,LOG_STATE,"entering state %s",state_name(next));
 836     switch(next) {
 837     case SITE_SENTMSG1:
 838         state_assert(st,st->state==SITE_RUN || st->state==SITE_RESOLVE);
 839         gen=generate_msg1;
 840         break;
 841     case SITE_SENTMSG2:
 842         state_assert(st,st->state==SITE_RUN || st->state==SITE_RESOLVE ||
 843                      st->state==SITE_SENTMSG1 || st->state==SITE_WAIT);
 844         gen=generate_msg2;
 845         break;
 846     case SITE_SENTMSG3:
 847         state_assert(st,st->state==SITE_SENTMSG1);
 848         BUF_FREE(&st->buffer);
 849         gen=generate_msg3;
 850         break;
 851     case SITE_SENTMSG4:
 852         state_assert(st,st->state==SITE_SENTMSG2);
 853         BUF_FREE(&st->buffer);
 854         gen=generate_msg4;
 855         break;
 856     case SITE_SENTMSG5:
 857         state_assert(st,st->state==SITE_SENTMSG3);
 858         BUF_FREE(&st->buffer);
 859         gen=generate_msg5;
 860         break;
 861     case SITE_RUN:
 862         state_assert(st,st->state==SITE_SENTMSG4);
 863         BUF_FREE(&st->buffer);
 864         gen=generate_msg6;
 865         break;
 866     default:
 867         gen=NULL;
 868         fatal("enter_new_state(%s): invalid new state",state_name(next));
 869         break;
 870     }
 871
 872     if (hacky_par_start_failnow()) return False;
 873
 874     r= gen(st) && send_msg(st);
 875
 876     hacky_par_end(&r,
 877                   st->setup_retries, st->setup_timeout,
 878                   send_msg, st);
 879
 880     if (r) {
 881         st->state=next;
 882         if (next==SITE_RUN) {
 883             BUF_FREE(&st->buffer); /* Never reused */
 884             st->timeout=0; /* Never retransmit */
 885             activate_new_key(st);
 886         }
 887         return True;
 888     }
 889     slog(st,LOG_ERROR,"error entering state %s",state_name(next));
 890     st->buffer.free=False; /* Unconditionally use the buffer; it may be
 891                               in either state, and enter_state_wait() will
 892                               do a BUF_FREE() */
 893     enter_state_wait(st);
 894     return False;
 895 }
 896
 897 /* msg7 tells our peer that we're about to forget our key */
 898 static bool_t send_msg7(struct site *st, cstring_t reason)
 899 {
 900     cstring_t transform_err;
 901
 902     if (st->current_valid && st->peer_valid && st->buffer.free) {
 903         BUF_ALLOC(&st->buffer,"site:MSG7");
 904         buffer_init(&st->buffer,st->transform->max_start_pad+(4*3));
 905         buf_append_uint32(&st->buffer,LABEL_MSG7);
 906         buf_append_string(&st->buffer,reason);
 907         st->current_transform->forwards(st->current_transform->st,
 908                                         &st->buffer, &transform_err);
 909         buf_prepend_uint32(&st->buffer,LABEL_MSG0);
 910         buf_prepend_uint32(&st->buffer,st->index);
 911         buf_prepend_uint32(&st->buffer,st->remote_session_id);
 912         dump_packet(st,&st->buffer,&st->peer,False);
 913         st->comm->sendmsg(st->comm->st,&st->buffer,&st->peer);
 914         BUF_FREE(&st->buffer);
 915         return True;
 916     }
 917     return False;
 918 }
 919
 920 /* We go into this state if our peer becomes uncommunicative. Similar to
 921    the "stop" state, we forget all session keys for a while, before
 922    re-entering the "run" state. */
 923 static void enter_state_wait(struct site *st)
 924 {
 925     slog(st,LOG_STATE,"entering state WAIT");
 926     st->timeout=st->now+st->wait_timeout;
 927     st->state=SITE_WAIT;
 928     set_link_quality(st);
 929     BUF_FREE(&st->buffer); /* will have had an outgoing packet in it */
 930     /* XXX Erase keys etc. */
 931 }
 932
 933 static inline void site_settimeout(uint64_t timeout, int *timeout_io)
 934 {
 935     if (timeout) {
 936         int64_t offset=timeout-*now;
 937         if (offset<0) offset=0;
 938         if (offset>INT_MAX) offset=INT_MAX;
 939         if (*timeout_io<0 || offset<*timeout_io)
 940             *timeout_io=offset;
 941     }
 942 }
 943
 944 static int site_beforepoll(void *sst, struct pollfd *fds, int *nfds_io,
 945                            int *timeout_io)
 946 {
 947     struct site *st=sst;
 948
 949     *nfds_io=0; /* We don't use any file descriptors */
 950     st->now=*now;
 951
 952     /* Work out when our next timeout is. The earlier of 'timeout' or
 953        'current_key_timeout'. A stored value of '0' indicates no timeout
 954        active. */
 955     site_settimeout(st->timeout, timeout_io);
 956     site_settimeout(st->current_key_timeout, timeout_io);
 957
 958     return 0; /* success */
 959 }
 960
 961 /* NB site_afterpoll will be called before site_beforepoll is ever called */
 962 static void site_afterpoll(void *sst, struct pollfd *fds, int nfds)
 963 {
 964     struct site *st=sst;
 965
 966     st->now=*now;
 967     if (st->timeout && *now>st->timeout) {
 968         st->timeout=0;
 969         if (st->state>=SITE_SENTMSG1 && st->state<=SITE_SENTMSG5) {
 970             if (!hacky_par_start_failnow())
 971                 send_msg(st);
 972         } else if (st->state==SITE_WAIT) {
 973             enter_state_run(st);
 974         } else {
 975             slog(st,LOG_ERROR,"site_afterpoll: unexpected timeout, state=%d",
 976                  st->state);
 977         }
 978     }
 979     if (st->current_key_timeout && *now>st->current_key_timeout) {
 980         delete_key(st,"maximum key life exceeded",LOG_TIMEOUT_KEY);
 981     }
 982 }
 983
 984 /* This function is called by the netlink device to deliver packets
 985    intended for the remote network. The packet is in "raw" wire
 986    format, but is guaranteed to be word-aligned. */
 987 static void site_outgoing(void *sst, struct buffer_if *buf)
 988 {
 989     struct site *st=sst;
 990     cstring_t transform_err;
 991
 992     if (st->state==SITE_STOP) {
 993         BUF_FREE(buf);
 994         return;
 995     }
 996
 997     /* In all other states we consider delivering the packet if we have
 998        a valid key and a valid address to send it to. */
 999     if (st->current_valid && st->peer_valid) {
1000         /* Transform it and send it */
1001         if (buf->size>0) {
1002             buf_prepend_uint32(buf,LABEL_MSG9);
1003             st->current_transform->forwards(st->current_transform->st,
1004                                             buf, &transform_err);
1005             buf_prepend_uint32(buf,LABEL_MSG0);
1006             buf_prepend_uint32(buf,st->index);
1007             buf_prepend_uint32(buf,st->remote_session_id);
1008             st->comm->sendmsg(st->comm->st,buf,&st->peer);
1009         }
1010         BUF_FREE(buf);
1011         /* See whether we should start negotiating a new key */
1012         if (st->now > st->renegotiate_key_time)
1013             initiate_key_setup(st,"outgoing packet in renegotiation window");
1014         return;
1015     }
1016
1017     slog(st,LOG_DROP,"discarding outgoing packet of size %d",buf->size);
1018     BUF_FREE(buf);
1019     initiate_key_setup(st,"outgoing packet");
1020 }
1021
1022 /* This function is called by the communication device to deliver
1023    packets from our peers. */
1024 static bool_t site_incoming(void *sst, struct buffer_if *buf,
1025                             struct sockaddr_in *source)
1026 {
1027     struct site *st=sst;
1028     uint32_t dest=ntohl(*(uint32_t *)buf->start);
1029
1030     if (dest==0) {
1031         /* It could be for any site - it should have LABEL_MSG1 and
1032            might have our name and our peer's name in it */
1033         if (buf->size<(st->setupsiglen+8+NONCELEN)) return False;
1034         if (memcmp(buf->start+8,st->setupsig,st->setupsiglen)==0) {
1035             /* It's addressed to us. Decide what to do about it. */
1036             dump_packet(st,buf,source,True);
1037             if (st->state==SITE_RUN || st->state==SITE_RESOLVE ||
1038                 st->state==SITE_WAIT) {
1039                 /* We should definitely process it */
1040                 if (process_msg1(st,buf,source)) {
1041                     slog(st,LOG_SETUP_INIT,"key setup initiated by peer");
1042                     enter_new_state(st,SITE_SENTMSG2);
1043                 } else {
1044                     slog(st,LOG_ERROR,"failed to process incoming msg1");
1045                 }
1046                 BUF_FREE(buf);
1047                 return True;
1048             } else if (st->state==SITE_SENTMSG1) {
1049                 /* We've just sent a message 1! They may have crossed on
1050                    the wire. If we have priority then we ignore the
1051                    incoming one, otherwise we process it as usual. */
1052                 if (st->setup_priority) {
1053                     BUF_FREE(buf);
1054                     slog(st,LOG_DUMP,"crossed msg1s; we are higher "
1055                          "priority => ignore incoming msg1");
1056                     return True;
1057                 } else {
1058                     slog(st,LOG_DUMP,"crossed msg1s; we are lower "
1059                          "priority => use incoming msg1");
1060                     if (process_msg1(st,buf,source)) {
1061                         BUF_FREE(&st->buffer); /* Free our old message 1 */
1062                         enter_new_state(st,SITE_SENTMSG2);
1063                     } else {
1064                         slog(st,LOG_ERROR,"failed to process an incoming "
1065                              "crossed msg1 (we have low priority)");
1066                     }
1067                     BUF_FREE(buf);
1068                     return True;
1069                 }
1070             }
1071             /* The message 1 was received at an unexpected stage of the
1072                key setup. XXX POLICY - what do we do? */
1073             slog(st,LOG_UNEXPECTED,"unexpected incoming message 1");
1074             BUF_FREE(buf);
1075             return True;
1076         }
1077         return False; /* Not for us. */
1078     }
1079     if (dest==st->index) {
1080         /* Explicitly addressed to us */
1081         uint32_t msgtype=ntohl(get_uint32(buf->start+8));
1082         if (msgtype!=LABEL_MSG0) dump_packet(st,buf,source,True);
1083         switch (msgtype) {
1084         case 0: /* NAK */
1085             /* If the source is our current peer then initiate a key setup,
1086                because our peer's forgotten the key */
1087             if (get_uint32(buf->start+4)==st->remote_session_id) {
1088                 initiate_key_setup(st,"received a NAK");
1089             } else {
1090                 slog(st,LOG_SEC,"bad incoming NAK");
1091             }
1092             break;
1093         case LABEL_MSG0:
1094             process_msg0(st,buf,source);
1095             break;
1096         case LABEL_MSG1:
1097             /* Setup packet: should not have been explicitly addressed
1098                to us */
1099             slog(st,LOG_SEC,"incoming explicitly addressed msg1");
1100             break;
1101         case LABEL_MSG2:
1102             /* Setup packet: expected only in state SENTMSG1 */
1103             if (st->state!=SITE_SENTMSG1) {
1104                 slog(st,LOG_UNEXPECTED,"unexpected MSG2");
1105             } else if (process_msg2(st,buf,source))
1106                 enter_new_state(st,SITE_SENTMSG3);
1107             else {
1108                 slog(st,LOG_SEC,"invalid MSG2");
1109             }
1110             break;
1111         case LABEL_MSG3:
1112             /* Setup packet: expected only in state SENTMSG2 */
1113             if (st->state!=SITE_SENTMSG2) {
1114                 slog(st,LOG_UNEXPECTED,"unexpected MSG3");
1115             } else if (process_msg3(st,buf,source))
1116                 enter_new_state(st,SITE_SENTMSG4);
1117             else {
1118                 slog(st,LOG_SEC,"invalid MSG3");
1119             }
1120             break;
1121         case LABEL_MSG4:
1122             /* Setup packet: expected only in state SENTMSG3 */
1123             if (st->state!=SITE_SENTMSG3) {
1124                 slog(st,LOG_UNEXPECTED,"unexpected MSG4");
1125             } else if (process_msg4(st,buf,source))
1126                 enter_new_state(st,SITE_SENTMSG5);
1127             else {
1128                 slog(st,LOG_SEC,"invalid MSG4");
1129             }
1130             break;
1131         case LABEL_MSG5:
1132             /* Setup packet: expected only in state SENTMSG4 */
1133             /* (may turn up in state RUN if our return MSG6 was lost
1134                and the new key has already been activated. In that
1135                case we should treat it as an ordinary PING packet. We
1136                can't pass it to process_msg5() because the
1137                new_transform will now be unkeyed. XXX) */
1138             if (st->state!=SITE_SENTMSG4) {
1139                 slog(st,LOG_UNEXPECTED,"unexpected MSG5");
1140             } else if (process_msg5(st,buf,source)) {
1141                 enter_new_state(st,SITE_RUN);
1142             } else {
1143                 slog(st,LOG_SEC,"invalid MSG5");
1144             }
1145             break;
1146         case LABEL_MSG6:
1147             /* Setup packet: expected only in state SENTMSG5 */
1148             if (st->state!=SITE_SENTMSG5) {
1149                 slog(st,LOG_UNEXPECTED,"unexpected MSG6");
1150             } else if (process_msg6(st,buf,source)) {
1151                 BUF_FREE(&st->buffer); /* Free message 5 */
1152                 activate_new_key(st);
1153             } else {
1154                 slog(st,LOG_SEC,"invalid MSG6");
1155             }
1156             break;
1157         default:
1158             slog(st,LOG_SEC,"received message of unknown type 0x%08x",
1159                  msgtype);
1160             break;
1161         }
1162         BUF_FREE(buf);
1163         return True;
1164     }
1165
1166     return False;
1167 }
1168
1169 static void site_control(void *vst, bool_t run)
1170 {
1171     struct site *st=vst;
1172     if (run) enter_state_run(st);
1173     else enter_state_stop(st);
1174 }
1175
1176 static void site_phase_hook(void *sst, uint32_t newphase)
1177 {
1178     struct site *st=sst;
1179
1180     /* The program is shutting down; tell our peer */
1181     send_msg7(st,"shutting down");
1182 }
1183
1184 static list_t *site_apply(closure_t *self, struct cloc loc, dict_t *context,
1185                           list_t *args)
1186 {
1187     static uint32_t index_sequence;
1188     struct site *st;
1189     item_t *item;
1190     dict_t *dict;
1191
1192     st=safe_malloc(sizeof(*st),"site_apply");
1193
1194     st->cl.description="site";
1195     st->cl.type=CL_SITE;
1196     st->cl.apply=NULL;
1197     st->cl.interface=&st->ops;
1198     st->ops.st=st;
1199     st->ops.control=site_control;
1200     st->ops.status=site_status;
1201
1202     /* First parameter must be a dict */
1203     item=list_elem(args,0);
1204     if (!item || item->type!=t_dict)
1205         cfgfatal(loc,"site","parameter must be a dictionary\n");
1206
1207     dict=item->data.dict;
1208     st->localname=dict_read_string(dict, "local-name", True, "site", loc);
1209     st->remotename=dict_read_string(dict, "name", True, "site", loc);
1210     /* Sanity check (which also allows the 'sites' file to include
1211        site() closures for all sites including our own): refuse to
1212        talk to ourselves */
1213     if (strcmp(st->localname,st->remotename)==0) {
1214         Message(M_DEBUG,"site %s: local-name==name -> ignoring this site\n",
1215                 st->localname);
1216         free(st);
1217         return NULL;
1218     }
1219     assert(index_sequence < 0xffffffffUL);
1220     st->index = ++index_sequence;
1221     st->netlink=find_cl_if(dict,"link",CL_NETLINK,True,"site",loc);
1222     st->comm=find_cl_if(dict,"comm",CL_COMM,True,"site",loc);
1223     st->resolver=find_cl_if(dict,"resolver",CL_RESOLVER,True,"site",loc);
1224     st->log=find_cl_if(dict,"log",CL_LOG,True,"site",loc);
1225     st->random=find_cl_if(dict,"random",CL_RANDOMSRC,True,"site",loc);
1226
1227     st->privkey=find_cl_if(dict,"local-key",CL_RSAPRIVKEY,True,"site",loc);
1228     st->address=dict_read_string(dict, "address", False, "site", loc);
1229     if (st->address)
1230         st->remoteport=dict_read_number(dict,"port",True,"site",loc,0);
1231     else st->remoteport=0;
1232     st->pubkey=find_cl_if(dict,"key",CL_RSAPUBKEY,True,"site",loc);
1233
1234     st->transform=
1235         find_cl_if(dict,"transform",CL_TRANSFORM,True,"site",loc);
1236
1237     st->dh=find_cl_if(dict,"dh",CL_DH,True,"site",loc);
1238     st->hash=find_cl_if(dict,"hash",CL_HASH,True,"site",loc);
1239
1240     st->key_lifetime=dict_read_number(
1241         dict,"key-lifetime",False,"site",loc,DEFAULT_KEY_LIFETIME);
1242     st->setup_retries=dict_read_number(
1243         dict,"setup-retries",False,"site",loc,DEFAULT_SETUP_RETRIES);
1244     st->setup_timeout=dict_read_number(
1245         dict,"setup-timeout",False,"site",loc,DEFAULT_SETUP_TIMEOUT);
1246     st->wait_timeout=dict_read_number(
1247         dict,"wait-time",False,"site",loc,DEFAULT_WAIT_TIME);
1248
1249     if (st->key_lifetime < DEFAULT_KEY_RENEGOTIATE_GAP*2)
1250         st->key_renegotiate_time=st->key_lifetime/2;
1251     else
1252         st->key_renegotiate_time=st->key_lifetime-DEFAULT_KEY_RENEGOTIATE_GAP;
1253     st->key_renegotiate_time=dict_read_number(
1254         dict,"renegotiate-time",False,"site",loc,st->key_renegotiate_time);
1255     if (st->key_renegotiate_time > st->key_lifetime) {
1256         cfgfatal(loc,"site",
1257                  "renegotiate-time must be less than key-lifetime\n");
1258     }
1259
1260     st->log_events=string_list_to_word(dict_lookup(dict,"log-events"),
1261                                        log_event_table,"site");
1262
1263     st->tunname=safe_malloc(strlen(st->localname)+strlen(st->remotename)+5,
1264                             "site_apply");
1265     sprintf(st->tunname,"%s<->%s",st->localname,st->remotename);
1266
1267     /* The information we expect to see in incoming messages of type 1 */
1268     /* fixme: lots of unchecked overflows here, but the results are only
1269        corrupted packets rather than undefined behaviour */
1270     st->setupsiglen=strlen(st->remotename)+strlen(st->localname)+8;
1271     st->setupsig=safe_malloc(st->setupsiglen,"site_apply");
1272     put_uint32(st->setupsig+0,LABEL_MSG1);
1273     put_uint16(st->setupsig+4,strlen(st->remotename));
1274     memcpy(&st->setupsig[6],st->remotename,strlen(st->remotename));
1275     put_uint16(st->setupsig+(6+strlen(st->remotename)),strlen(st->localname));
1276     memcpy(&st->setupsig[8+strlen(st->remotename)],st->localname,
1277            strlen(st->localname));
1278     st->setup_priority=(strcmp(st->localname,st->remotename)>0);
1279
1280     buffer_new(&st->buffer,SETUP_BUFFER_LEN);
1281
1282     /* We are interested in poll(), but only for timeouts. We don't have
1283        any fds of our own. */
1284     register_for_poll(st, site_beforepoll, site_afterpoll, 0, "site");
1285     st->timeout=0;
1286
1287     st->current_valid=False;
1288     st->current_key_timeout=0;
1289     st->peer_valid=False;
1290     /* XXX mlock these */
1291     st->dhsecret=safe_malloc(st->dh->len,"site:dhsecret");
1292     st->sharedsecret=safe_malloc(st->transform->keylen,"site:sharedsecret");
1293
1294     /* We need to register the remote networks with the netlink device */
1295     st->netlink->reg(st->netlink->st, site_outgoing, st,
1296                      st->transform->max_start_pad+(4*4)+
1297                      st->comm->min_start_pad,
1298                      st->transform->max_end_pad+st->comm->min_end_pad);
1299
1300     st->comm->request_notify(st->comm->st, st, site_incoming);
1301
1302     st->current_transform=st->transform->create(st->transform->st);
1303     st->new_transform=st->transform->create(st->transform->st);
1304
1305     enter_state_stop(st);
1306
1307     add_hook(PHASE_SHUTDOWN,site_phase_hook,st);
1308
1309     return new_closure(&st->cl);
1310 }
1311
1312 void site_module(dict_t *dict)
1313 {
1314     add_closure(dict,"site",site_apply);
1315 }