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