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