~mdw / secnet / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
site: Log when resolution completes
[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;
0391d9ee 232 bool_t local_mobile, peer_mobile; /* Mobile client support */
446353cd 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;
4ac8a7d2
IJ		 1164 slog(st,LOG_STATE,"resolution of %s completed: %s",
1165 st->address, comm_addr_to_string(ca_use));;
2fe58dfd 1166 } else {
2fe58dfd 1167 slog(st,LOG_ERROR,"resolution of %s failed",st->address);
446353cd
IJ		 1168 ca_use=0;
1169 }
dd9209d1 1170 if (transport_compute_setupinit_peers(st,ca_use,0)) {
446353cd
IJ		 1171 enter_new_state(st,SITE_SENTMSG1);
1172 } else {
1173 /* Can't figure out who to try to to talk to */
1174 slog(st,LOG_SETUP_INIT,"key exchange failed: cannot find peer address");
2fe58dfd
SE		 1175 enter_state_run(st);
1176 }
1177}
1178
dd9209d1
IJ		 1179static bool_t initiate_key_setup(struct site *st, cstring_t reason,
1180 const struct comm_addr *prod_hint)
9d3a4132 1181{
77effe1d 1182 /* Reentrancy hazard: can call enter_new_state/enter_state_* */
9d3a4132 1183 if (st->state!=SITE_RUN) return False;
794f2398 1184 slog(st,LOG_SETUP_INIT,"initiating key exchange (%s)",reason);
9d3a4132 1185 if (st->address) {
794f2398 1186 slog(st,LOG_SETUP_INIT,"resolving peer address");
9d3a4132 1187 return enter_state_resolve(st);
dd9209d1 1188 } else if (transport_compute_setupinit_peers(st,0,prod_hint)) {
ff05a229 1189 return enter_new_state(st,SITE_SENTMSG1);
9d3a4132 1190 }
ff05a229 1191 slog(st,LOG_SETUP_INIT,"key exchange failed: no address for peer");
9d3a4132
SE		 1192 return False;
1193}
1194
2fe58dfd
SE		 1195static void activate_new_key(struct site *st)
1196{
1197 struct transform_inst_if *t;
1198
02b0959b
IJ		 1199 /* We have three transform instances, which we swap between old,
1200 active and setup */
1201 t=st->auxiliary_key.transform;
1202 st->auxiliary_key.transform=st->current.transform;
19e9a588 1203 st->current.transform=st->new_transform;
2fe58dfd 1204 st->new_transform=t;
0afd257e 1205 dispose_transform(&st->new_transform);
2fe58dfd 1206
2fe58dfd 1207 st->timeout=0;
bd98cd6b 1208 st->auxiliary_is_new=0;
02b0959b 1209 st->auxiliary_key.key_timeout=st->current.key_timeout;
19e9a588 1210 st->current.key_timeout=st->now+st->key_lifetime;
ff05a229 1211 st->renegotiate_key_time=st->now+st->key_renegotiate_time;
446353cd 1212 transport_peers_copy(st,&st->peers,&st->setup_peers);
19e9a588 1213 st->current.remote_session_id=st->setup_session_id;
2fe58dfd 1214
3ed1846a
IJ		 1215 /* Compute the inter-site MTU. This is min( our_mtu, their_mtu ).
1216 * But their mtu be unspecified, in which case we just use ours. */
1217 uint32_t intersite_mtu=
1218 MIN(st->mtu_target, st->remote_adv_mtu ?: ~(uint32_t)0);
1219 st->netlink->set_mtu(st->netlink->st,intersite_mtu);
1220
1221 slog(st,LOG_ACTIVATE_KEY,"new key activated"
1222 " (mtu ours=%"PRId32" theirs=%"PRId32" intersite=%"PRId32")",
1223 st->mtu_target, st->remote_adv_mtu, intersite_mtu);
9d3a4132 1224 enter_state_run(st);
2fe58dfd
SE		 1225}
1226
1d388569
IJ		 1227static void delete_one_key(struct site *st, struct data_key *key,
1228 cstring_t reason, cstring_t which, uint32_t loglevel)
1229{
0afd257e 1230 if (!is_transform_valid(key->transform)) return;
1d388569 1231 if (reason) slog(st,loglevel,"%s deleted (%s)",which,reason);
0afd257e 1232 dispose_transform(&key->transform);
1d388569
IJ		 1233 key->key_timeout=0;
1234}
1235
1236static void delete_keys(struct site *st, cstring_t reason, uint32_t loglevel)
794f2398 1237{
3d8d8f4e 1238 if (current_valid(st)) {
794f2398
SE		 1239 slog(st,loglevel,"session closed (%s)",reason);
1240
1d388569 1241 delete_one_key(st,&st->current,0,0,0);
794f2398
SE		 1242 set_link_quality(st);
1243 }
02b0959b 1244 delete_one_key(st,&st->auxiliary_key,0,0,0);
794f2398
SE		 1245}
1246
2fe58dfd
SE		 1247static void state_assert(struct site *st, bool_t ok)
1248{
4f5e39ec 1249 if (!ok) fatal("site:state_assert");
2fe58dfd
SE		 1250}
1251
1252static void enter_state_stop(struct site *st)
1253{
1254 st->state=SITE_STOP;
1255 st->timeout=0;
1d388569 1256 delete_keys(st,"entering state STOP",LOG_TIMEOUT_KEY);
0afd257e 1257 dispose_transform(&st->new_transform);
2fe58dfd
SE		 1258}
1259
9d3a4132
SE		 1260static void set_link_quality(struct site *st)
1261{
1262 uint32_t quality;
3d8d8f4e 1263 if (current_valid(st))
9d3a4132
SE		 1264 quality=LINK_QUALITY_UP;
1265 else if (st->state==SITE_WAIT || st->state==SITE_STOP)
1266 quality=LINK_QUALITY_DOWN;
1267 else if (st->address)
1268 quality=LINK_QUALITY_DOWN_CURRENT_ADDRESS;
446353cd 1269 else if (transport_peers_valid(&st->peers))
9d3a4132
SE		 1270 quality=LINK_QUALITY_DOWN_STALE_ADDRESS;
1271 else
1272 quality=LINK_QUALITY_DOWN;
1273
469fd1d9 1274 st->netlink->set_quality(st->netlink->st,quality);
9d3a4132
SE		 1275}
1276
2fe58dfd
SE		 1277static void enter_state_run(struct site *st)
1278{
1279 slog(st,LOG_STATE,"entering state RUN");
1280 st->state=SITE_RUN;
1281 st->timeout=0;
9d3a4132 1282
ff05a229 1283 st->setup_session_id=0;
446353cd 1284 transport_peers_clear(st,&st->setup_peers);
ff05a229
SE		 1285 memset(st->localN,0,NONCELEN);
1286 memset(st->remoteN,0,NONCELEN);
0afd257e 1287 dispose_transform(&st->new_transform);
ff05a229 1288 memset(st->dhsecret,0,st->dh->len);
7c9ca4bd 1289 memset(st->sharedsecret,0,st->sharedsecretlen);
9d3a4132 1290 set_link_quality(st);
2fe58dfd
SE		 1291}
1292
5c19b79c
IJ		 1293static bool_t ensure_resolving(struct site *st)
1294{
1295 /* Reentrancy hazard: may call site_resolve_callback and hence
1296 * enter_new_state, enter_state_* and generate_msg*. */
1297 if (st->resolving)
1298 return True;
1299
4ac8a7d2
IJ		 1300 assert(st->address);
1301
5c19b79c
IJ		 1302 /* resolver->request might reentrantly call site_resolve_callback
1303 * which will clear st->resolving, so we need to set it beforehand
1304 * rather than afterwards; also, it might return False, in which
1305 * case we have to clear ->resolving again. */
1306 st->resolving=True;
1307 bool_t ok = st->resolver->request(st->resolver->st,st->address,
1308 site_resolve_callback,st);
1309 if (!ok)
1310 st->resolving=False;
1311
1312 return ok;
1313}
1314
2fe58dfd
SE		 1315static bool_t enter_state_resolve(struct site *st)
1316{
77effe1d 1317 /* Reentrancy hazard! See ensure_resolving. */
2fe58dfd
SE		 1318 state_assert(st,st->state==SITE_RUN);
1319 slog(st,LOG_STATE,"entering state RESOLVE");
1320 st->state=SITE_RESOLVE;
5c19b79c 1321 return ensure_resolving(st);
2fe58dfd
SE		 1322}
1323
ff05a229 1324static bool_t enter_new_state(struct site *st, uint32_t next)
2fe58dfd 1325{
ff05a229 1326 bool_t (*gen)(struct site *st);
3b83c932
SE		 1327 int r;
1328
ff05a229
SE		 1329 slog(st,LOG_STATE,"entering state %s",state_name(next));
1330 switch(next) {
1331 case SITE_SENTMSG1:
1332 state_assert(st,st->state==SITE_RUN || st->state==SITE_RESOLVE);
1333 gen=generate_msg1;
1334 break;
1335 case SITE_SENTMSG2:
1336 state_assert(st,st->state==SITE_RUN || st->state==SITE_RESOLVE ||
1337 st->state==SITE_SENTMSG1 || st->state==SITE_WAIT);
1338 gen=generate_msg2;
1339 break;
1340 case SITE_SENTMSG3:
1341 state_assert(st,st->state==SITE_SENTMSG1);
1342 BUF_FREE(&st->buffer);
1343 gen=generate_msg3;
1344 break;
1345 case SITE_SENTMSG4:
1346 state_assert(st,st->state==SITE_SENTMSG2);
1347 BUF_FREE(&st->buffer);
1348 gen=generate_msg4;
1349 break;
1350 case SITE_SENTMSG5:
1351 state_assert(st,st->state==SITE_SENTMSG3);
1352 BUF_FREE(&st->buffer);
1353 gen=generate_msg5;
1354 break;
1355 case SITE_RUN:
1356 state_assert(st,st->state==SITE_SENTMSG4);
1357 BUF_FREE(&st->buffer);
1358 gen=generate_msg6;
1359 break;
1360 default:
1361 gen=NULL;
4f5e39ec 1362 fatal("enter_new_state(%s): invalid new state",state_name(next));
ff05a229 1363 break;
2fe58dfd 1364 }
2fe58dfd 1365
3b83c932
SE		 1366 if (hacky_par_start_failnow()) return False;
1367
1368 r= gen(st) && send_msg(st);
1369
1370 hacky_par_end(&r,
e7f8ec2a 1371 st->setup_retries, st->setup_retry_interval,
3b83c932
SE		 1372 send_msg, st);
1373
1374 if (r) {
ff05a229
SE		 1375 st->state=next;
1376 if (next==SITE_RUN) {
1377 BUF_FREE(&st->buffer); /* Never reused */
1378 st->timeout=0; /* Never retransmit */
1379 activate_new_key(st);
1380 }
2fe58dfd
SE		 1381 return True;
1382 }
ff05a229
SE		 1383 slog(st,LOG_ERROR,"error entering state %s",state_name(next));
1384 st->buffer.free=False; /* Unconditionally use the buffer; it may be
1385 in either state, and enter_state_wait() will
1386 do a BUF_FREE() */
2fe58dfd
SE		 1387 enter_state_wait(st);
1388 return False;
1389}
1390
ff05a229 1391/* msg7 tells our peer that we're about to forget our key */
fe5e9cc4 1392static bool_t send_msg7(struct site *st, cstring_t reason)
794f2398 1393{
fe5e9cc4 1394 cstring_t transform_err;
794f2398 1395
3d8d8f4e 1396 if (current_valid(st) && st->buffer.free
446353cd 1397 && transport_peers_valid(&st->peers)) {
794f2398 1398 BUF_ALLOC(&st->buffer,"site:MSG7");
3abd18e8 1399 buffer_init(&st->buffer,calculate_max_start_pad());
794f2398
SE		 1400 buf_append_uint32(&st->buffer,LABEL_MSG7);
1401 buf_append_string(&st->buffer,reason);
0afd257e
IJ		 1402 if (call_transform_forwards(st, st->current.transform,
1403 &st->buffer, &transform_err))
1404 goto free_out;
794f2398 1405 buf_prepend_uint32(&st->buffer,LABEL_MSG0);
58650a70 1406 buf_prepend_uint32(&st->buffer,st->index);
19e9a588 1407 buf_prepend_uint32(&st->buffer,st->current.remote_session_id);
446353cd 1408 transport_xmit(st,&st->peers,&st->buffer,True);
794f2398 1409 BUF_FREE(&st->buffer);
0afd257e 1410 free_out:
794f2398
SE		 1411 return True;
1412 }
1413 return False;
1414}
1415
2fe58dfd
SE		 1416/* We go into this state if our peer becomes uncommunicative. Similar to
1417 the "stop" state, we forget all session keys for a while, before
1418 re-entering the "run" state. */
1419static void enter_state_wait(struct site *st)
1420{
1421 slog(st,LOG_STATE,"entering state WAIT");
1422 st->timeout=st->now+st->wait_timeout;
1423 st->state=SITE_WAIT;
9d3a4132 1424 set_link_quality(st);
2fe58dfd
SE		 1425 BUF_FREE(&st->buffer); /* will have had an outgoing packet in it */
1426 /* XXX Erase keys etc. */
1427}
1428
dd9209d1
IJ		 1429static void generate_prod(struct site *st, struct buffer_if *buf)
1430{
1431 buffer_init(buf,0);
1432 buf_append_uint32(buf,0);
1433 buf_append_uint32(buf,0);
1434 buf_append_uint32(buf,LABEL_PROD);
1435 buf_append_string(buf,st->localname);
1436 buf_append_string(buf,st->remotename);
1437}
1438
1439static void generate_send_prod(struct site *st,
1440 const struct comm_addr *source)
1441{
1442 if (!st->allow_send_prod) return; /* too soon */
1443 if (!(st->state==SITE_RUN || st->state==SITE_RESOLVE ||
1444 st->state==SITE_WAIT)) return; /* we'd ignore peer's MSG1 */
1445
1446 slog(st,LOG_SETUP_INIT,"prodding peer for key exchange");
1447 st->allow_send_prod=0;
1448 generate_prod(st,&st->scratch);
1449 dump_packet(st,&st->scratch,source,False);
1450 source->comm->sendmsg(source->comm->st, &st->scratch, source);
1451}
1452
16f73fa6 1453static inline void site_settimeout(uint64_t timeout, int *timeout_io)
fe5e9cc4
SE		 1454{
1455 if (timeout) {
0009e60a
IJ		 1456 int64_t offset=timeout-*now;
1457 if (offset<0) offset=0;
fe5e9cc4
SE		 1458 if (offset>INT_MAX) offset=INT_MAX;
1459 if (*timeout_io<0 || offset<*timeout_io)
1460 *timeout_io=offset;
1461 }
1462}
1463
2fe58dfd 1464static int site_beforepoll(void *sst, struct pollfd *fds, int *nfds_io,
90a39563 1465 int *timeout_io)
2fe58dfd
SE		 1466{
1467 struct site *st=sst;
1468
1469 *nfds_io=0; /* We don't use any file descriptors */
1470 st->now=*now;
1471
1472 /* Work out when our next timeout is. The earlier of 'timeout' or
19e9a588 1473 'current.key_timeout'. A stored value of '0' indicates no timeout
2fe58dfd 1474 active. */
16f73fa6 1475 site_settimeout(st->timeout, timeout_io);
19e9a588 1476 site_settimeout(st->current.key_timeout, timeout_io);
02b0959b 1477 site_settimeout(st->auxiliary_key.key_timeout, timeout_io);
2fe58dfd
SE		 1478
1479 return 0; /* success */
1480}
1481
1d388569
IJ		 1482static void check_expiry(struct site *st, struct data_key *key,
1483 const char *which)
1484{
1485 if (key->key_timeout && *now>key->key_timeout) {
1486 delete_one_key(st,key,"maximum life exceeded",which,LOG_TIMEOUT_KEY);
1487 }
1488}
1489
2fe58dfd 1490/* NB site_afterpoll will be called before site_beforepoll is ever called */
90a39563 1491static void site_afterpoll(void *sst, struct pollfd *fds, int nfds)
2fe58dfd
SE		 1492{
1493 struct site *st=sst;
1494
1495 st->now=*now;
1496 if (st->timeout && *now>st->timeout) {
2fe58dfd 1497 st->timeout=0;
3b83c932
SE		 1498 if (st->state>=SITE_SENTMSG1 && st->state<=SITE_SENTMSG5) {
1499 if (!hacky_par_start_failnow())
1500 send_msg(st);
1501 } else if (st->state==SITE_WAIT) {
2fe58dfd
SE		 1502 enter_state_run(st);
1503 } else {
1504 slog(st,LOG_ERROR,"site_afterpoll: unexpected timeout, state=%d",
1505 st->state);
1506 }
1507 }
1d388569 1508 check_expiry(st,&st->current,"current key");
02b0959b 1509 check_expiry(st,&st->auxiliary_key,"auxiliary key");
2fe58dfd
SE		 1510}
1511
1512/* This function is called by the netlink device to deliver packets
1513 intended for the remote network. The packet is in "raw" wire
1514 format, but is guaranteed to be word-aligned. */
469fd1d9 1515static void site_outgoing(void *sst, struct buffer_if *buf)
2fe58dfd
SE		 1516{
1517 struct site *st=sst;
fe5e9cc4 1518 cstring_t transform_err;
2fe58dfd
SE		 1519
1520 if (st->state==SITE_STOP) {
1521 BUF_FREE(buf);
1522 return;
1523 }
1524
dd9209d1
IJ		 1525 st->allow_send_prod=1;
1526
2fe58dfd
SE		 1527 /* In all other states we consider delivering the packet if we have
1528 a valid key and a valid address to send it to. */
3d8d8f4e 1529 if (current_valid(st) && transport_peers_valid(&st->peers)) {
2fe58dfd 1530 /* Transform it and send it */
70dc107b
SE		 1531 if (buf->size>0) {
1532 buf_prepend_uint32(buf,LABEL_MSG9);
0afd257e
IJ		 1533 if (call_transform_forwards(st, st->current.transform,
1534 buf, &transform_err))
1535 goto free_out;
70dc107b 1536 buf_prepend_uint32(buf,LABEL_MSG0);
58650a70 1537 buf_prepend_uint32(buf,st->index);
19e9a588 1538 buf_prepend_uint32(buf,st->current.remote_session_id);
446353cd 1539 transport_xmit(st,&st->peers,buf,False);
70dc107b 1540 }
0afd257e 1541 free_out:
2fe58dfd
SE		 1542 BUF_FREE(buf);
1543 return;
1544 }
1545
70dc107b 1546 slog(st,LOG_DROP,"discarding outgoing packet of size %d",buf->size);
2fe58dfd 1547 BUF_FREE(buf);
dd9209d1 1548 initiate_key_setup(st,"outgoing packet",0);
2fe58dfd
SE		 1549}
1550
7e29719e
IJ		 1551static bool_t named_for_us(struct site *st, const struct buffer_if *buf_in,
1552 uint32_t type, struct msg *m)
1553 /* For packets which are identified by the local and remote names.
1554 * If it has our name and our peer's name in it it's for us. */
1555{
1556 struct buffer_if buf[1];
1557 buffer_readonly_clone(buf,buf_in);
1558 return unpick_msg(st,type,buf,m)
1559 && name_matches(&m->remote,st->remotename)
1560 && name_matches(&m->local,st->localname);
1561}
1562
2fe58dfd 1563/* This function is called by the communication device to deliver
dd9209d1
IJ		 1564 packets from our peers.
1565 It should return True if the packet is recognised as being for
1566 this current site instance (and should therefore not be processed
1567 by other sites), even if the packet was otherwise ignored. */
2fe58dfd 1568static bool_t site_incoming(void *sst, struct buffer_if *buf,
a15faeb2 1569 const struct comm_addr *source)
2fe58dfd
SE		 1570{
1571 struct site *st=sst;
20138876
IJ		 1572
1573 if (buf->size < 12) return False;
1574
0a6cbade
IJ		 1575 uint32_t dest=get_uint32(buf->start);
1576 uint32_t msgtype=get_uint32(buf->start+8);
7e29719e
IJ		 1577 struct msg named_msg;
1578
1579 if (msgtype==LABEL_MSG1) {
1580 if (!named_for_us(st,buf,msgtype,&named_msg))
1581 return False;
1582 /* It's a MSG1 addressed to us. Decide what to do about it. */
1583 dump_packet(st,buf,source,True);
1584 if (st->state==SITE_RUN || st->state==SITE_RESOLVE ||
1585 st->state==SITE_WAIT) {
1586 /* We should definitely process it */
1587 if (process_msg1(st,buf,source,&named_msg)) {
1588 slog(st,LOG_SETUP_INIT,"key setup initiated by peer");
1589 enter_new_state(st,SITE_SENTMSG2);
1590 } else {
1591 slog(st,LOG_ERROR,"failed to process incoming msg1");
1592 }
1593 BUF_FREE(buf);
1594 return True;
1595 } else if (st->state==SITE_SENTMSG1) {
1596 /* We've just sent a message 1! They may have crossed on
1597 the wire. If we have priority then we ignore the
1598 incoming one, otherwise we process it as usual. */
1599 if (st->setup_priority) {
1600 BUF_FREE(buf);
1601 slog(st,LOG_DUMP,"crossed msg1s; we are higher "
1602 "priority => ignore incoming msg1");
1603 return True;
1604 } else {
1605 slog(st,LOG_DUMP,"crossed msg1s; we are lower "
1606 "priority => use incoming msg1");
1607 if (process_msg1(st,buf,source,&named_msg)) {
1608 BUF_FREE(&st->buffer); /* Free our old message 1 */
ff05a229 1609 enter_new_state(st,SITE_SENTMSG2);
2fe58dfd 1610 } else {
7e29719e
IJ		 1611 slog(st,LOG_ERROR,"failed to process an incoming "
1612 "crossed msg1 (we have low priority)");
2fe58dfd
SE		 1613 }
1614 BUF_FREE(buf);
1615 return True;
2fe58dfd 1616 }
2fe58dfd 1617 }
7e29719e
IJ		 1618 /* The message 1 was received at an unexpected stage of the
1619 key setup. XXX POLICY - what do we do? */
1620 slog(st,LOG_UNEXPECTED,"unexpected incoming message 1");
1621 BUF_FREE(buf);
1622 return True;
2fe58dfd 1623 }
dd9209d1
IJ		 1624 if (msgtype==LABEL_PROD) {
1625 if (!named_for_us(st,buf,msgtype,&named_msg))
1626 return False;
1627 dump_packet(st,buf,source,True);
1628 if (st->state!=SITE_RUN) {
1629 slog(st,LOG_DROP,"ignoring PROD when not in state RUN");
1630 } else if (current_valid(st)) {
1631 slog(st,LOG_DROP,"ignoring PROD when we think we have a key");
1632 } else {
1633 initiate_key_setup(st,"peer sent PROD packet",source);
1634 }
1635 BUF_FREE(buf);
1636 return True;
1637 }
58650a70 1638 if (dest==st->index) {
2fe58dfd
SE		 1639 /* Explicitly addressed to us */
1640 if (msgtype!=LABEL_MSG0) dump_packet(st,buf,source,True);
1641 switch (msgtype) {
136740e6 1642 case LABEL_NAK:
794f2398
SE		 1643 /* If the source is our current peer then initiate a key setup,
1644 because our peer's forgotten the key */
19e9a588 1645 if (get_uint32(buf->start+4)==st->current.remote_session_id) {
dd9209d1
IJ		 1646 bool_t initiated;
1647 initiated = initiate_key_setup(st,"received a NAK",0);
1648 if (!initiated) generate_send_prod(st,source);
794f2398
SE		 1649 } else {
1650 slog(st,LOG_SEC,"bad incoming NAK");
1651 }
1652 break;
2fe58dfd
SE		 1653 case LABEL_MSG0:
1654 process_msg0(st,buf,source);
1655 break;
1656 case LABEL_MSG1:
1657 /* Setup packet: should not have been explicitly addressed
1658 to us */
59635212 1659 slog(st,LOG_SEC,"incoming explicitly addressed msg1");
2fe58dfd
SE		 1660 break;
1661 case LABEL_MSG2:
1662 /* Setup packet: expected only in state SENTMSG1 */
1663 if (st->state!=SITE_SENTMSG1) {
1664 slog(st,LOG_UNEXPECTED,"unexpected MSG2");
446353cd
IJ		 1665 } else if (process_msg2(st,buf,source)) {
1666 transport_setup_msgok(st,source);
ff05a229 1667 enter_new_state(st,SITE_SENTMSG3);
446353cd 1668 } else {
59635212 1669 slog(st,LOG_SEC,"invalid MSG2");
2fe58dfd
SE		 1670 }
1671 break;
1672 case LABEL_MSG3:
5b5f297f 1673 case LABEL_MSG3BIS:
2fe58dfd
SE		 1674 /* Setup packet: expected only in state SENTMSG2 */
1675 if (st->state!=SITE_SENTMSG2) {
1676 slog(st,LOG_UNEXPECTED,"unexpected MSG3");
5b5f297f 1677 } else if (process_msg3(st,buf,source,msgtype)) {
446353cd 1678 transport_setup_msgok(st,source);
ff05a229 1679 enter_new_state(st,SITE_SENTMSG4);
446353cd 1680 } else {
59635212 1681 slog(st,LOG_SEC,"invalid MSG3");
2fe58dfd
SE		 1682 }
1683 break;
1684 case LABEL_MSG4:
1685 /* Setup packet: expected only in state SENTMSG3 */
1686 if (st->state!=SITE_SENTMSG3) {
1687 slog(st,LOG_UNEXPECTED,"unexpected MSG4");
446353cd
IJ		 1688 } else if (process_msg4(st,buf,source)) {
1689 transport_setup_msgok(st,source);
ff05a229 1690 enter_new_state(st,SITE_SENTMSG5);
446353cd 1691 } else {
59635212 1692 slog(st,LOG_SEC,"invalid MSG4");
2fe58dfd
SE		 1693 }
1694 break;
1695 case LABEL_MSG5:
4efd681a
SE		 1696 /* Setup packet: expected only in state SENTMSG4 */
1697 /* (may turn up in state RUN if our return MSG6 was lost
1698 and the new key has already been activated. In that
05f39b4d
IJ		 1699 case we discard it. The peer will realise that we
1700 are using the new key when they see our data packets.
1701 Until then the peer's data packets to us get discarded. */
c90cc2a7
IJ		 1702 if (st->state==SITE_SENTMSG4) {
1703 if (process_msg5(st,buf,source,st->new_transform)) {
1704 transport_setup_msgok(st,source);
1705 enter_new_state(st,SITE_RUN);
1706 } else {
1707 slog(st,LOG_SEC,"invalid MSG5");
1708 }
1709 } else if (st->state==SITE_RUN) {
19e9a588 1710 if (process_msg5(st,buf,source,st->current.transform)) {
c90cc2a7
IJ		 1711 slog(st,LOG_DROP,"got MSG5, retransmitting MSG6");
1712 transport_setup_msgok(st,source);
19e9a588
IJ		 1713 create_msg6(st,st->current.transform,
1714 st->current.remote_session_id);
c90cc2a7
IJ		 1715 transport_xmit(st,&st->peers,&st->buffer,True);
1716 BUF_FREE(&st->buffer);
1717 } else {
1718 slog(st,LOG_SEC,"invalid MSG5 (in state RUN)");
1719 }
2fe58dfd 1720 } else {
c90cc2a7 1721 slog(st,LOG_UNEXPECTED,"unexpected MSG5");
2fe58dfd
SE		 1722 }
1723 break;
1724 case LABEL_MSG6:
1725 /* Setup packet: expected only in state SENTMSG5 */
1726 if (st->state!=SITE_SENTMSG5) {
1727 slog(st,LOG_UNEXPECTED,"unexpected MSG6");
1728 } else if (process_msg6(st,buf,source)) {
1729 BUF_FREE(&st->buffer); /* Free message 5 */
446353cd 1730 transport_setup_msgok(st,source);
2fe58dfd
SE		 1731 activate_new_key(st);
1732 } else {
59635212 1733 slog(st,LOG_SEC,"invalid MSG6");
2fe58dfd
SE		 1734 }
1735 break;
2fe58dfd 1736 default:
59635212 1737 slog(st,LOG_SEC,"received message of unknown type 0x%08x",
2fe58dfd
SE		 1738 msgtype);
1739 break;
1740 }
1741 BUF_FREE(buf);
1742 return True;
1743 }
1744
1745 return False;
1746}
1747
1748static void site_control(void *vst, bool_t run)
1749{
1750 struct site *st=vst;
1751 if (run) enter_state_run(st);
1752 else enter_state_stop(st);
1753}
1754
794f2398
SE		 1755static void site_phase_hook(void *sst, uint32_t newphase)
1756{
1757 struct site *st=sst;
1758
1759 /* The program is shutting down; tell our peer */
1760 send_msg7(st,"shutting down");
1761}
1762
2fe58dfd
SE		 1763static list_t *site_apply(closure_t *self, struct cloc loc, dict_t *context,
1764 list_t *args)
1765{
58650a70 1766 static uint32_t index_sequence;
2fe58dfd
SE		 1767 struct site *st;
1768 item_t *item;
1769 dict_t *dict;
59533c16 1770 int i;
2fe58dfd
SE		 1771
1772 st=safe_malloc(sizeof(*st),"site_apply");
1773
1774 st->cl.description="site";
1775 st->cl.type=CL_SITE;
1776 st->cl.apply=NULL;
1777 st->cl.interface=&st->ops;
1778 st->ops.st=st;
1779 st->ops.control=site_control;
1780 st->ops.status=site_status;
1781
1782 /* First parameter must be a dict */
1783 item=list_elem(args,0);
1784 if (!item || item->type!=t_dict)
1785 cfgfatal(loc,"site","parameter must be a dictionary\n");
1786
1787 dict=item->data.dict;
558fa3fb
SE		 1788 st->localname=dict_read_string(dict, "local-name", True, "site", loc);
1789 st->remotename=dict_read_string(dict, "name", True, "site", loc);
dba19f84
IJ		 1790
1791 st->peer_mobile=dict_read_bool(dict,"mobile",False,"site",loc,False);
0391d9ee 1792 st->local_mobile=
dba19f84
IJ		 1793 dict_read_bool(dict,"local-mobile",False,"site",loc,False);
1794
558fa3fb
SE		 1795 /* Sanity check (which also allows the 'sites' file to include
1796 site() closures for all sites including our own): refuse to
1797 talk to ourselves */
1798 if (strcmp(st->localname,st->remotename)==0) {
b2a56f7c 1799 Message(M_DEBUG,"site %s: local-name==name -> ignoring this site\n",
baa06aeb 1800 st->localname);
0391d9ee 1801 if (st->peer_mobile != st->local_mobile)
dba19f84
IJ		 1802 cfgfatal(loc,"site","site %s's peer-mobile=%d"
1803 " but our local-mobile=%d\n",
0391d9ee 1804 st->localname, st->peer_mobile, st->local_mobile);
dba19f84
IJ		 1805 free(st);
1806 return NULL;
1807 }
0391d9ee 1808 if (st->peer_mobile && st->local_mobile) {
dba19f84
IJ		 1809 Message(M_WARNING,"site %s: site is mobile but so are we"
1810 " -> ignoring this site\n", st->remotename);
558fa3fb
SE		 1811 free(st);
1812 return NULL;
1813 }
dba19f84 1814
58650a70
RK		 1815 assert(index_sequence < 0xffffffffUL);
1816 st->index = ++index_sequence;
09a385fb 1817 st->local_capabilities = 0;
469fd1d9 1818 st->netlink=find_cl_if(dict,"link",CL_NETLINK,True,"site",loc);
59533c16 1819
5b5f297f
IJ		 1820#define GET_CLOSURE_LIST(dictkey,things,nthings,CL_TYPE) do{ \
1821 list_t *things##_cfg=dict_lookup(dict,dictkey); \
1822 if (!things##_cfg) \
1823 cfgfatal(loc,"site","closure list \"%s\" not found\n",dictkey); \
1824 st->nthings=list_length(things##_cfg); \
1825 st->things=safe_malloc_ary(sizeof(*st->things),st->nthings,dictkey "s"); \
1826 assert(st->nthings); \
1827 for (i=0; i<st->nthings; i++) { \
1828 item_t *item=list_elem(things##_cfg,i); \
1829 if (item->type!=t_closure) \
1830 cfgfatal(loc,"site","%s is not a closure\n",dictkey); \
1831 closure_t *cl=item->data.closure; \
1832 if (cl->type!=CL_TYPE) \
1833 cfgfatal(loc,"site","%s closure wrong type\n",dictkey); \
1834 st->things[i]=cl->interface; \
1835 } \
1836}while(0)
1837
1838 GET_CLOSURE_LIST("comm",comms,ncomms,CL_COMM);
59533c16 1839
2fe58dfd
SE		 1840 st->resolver=find_cl_if(dict,"resolver",CL_RESOLVER,True,"site",loc);
1841 st->log=find_cl_if(dict,"log",CL_LOG,True,"site",loc);
1842 st->random=find_cl_if(dict,"random",CL_RANDOMSRC,True,"site",loc);
1843
2fe58dfd 1844 st->privkey=find_cl_if(dict,"local-key",CL_RSAPRIVKEY,True,"site",loc);
2fe58dfd 1845 st->address=dict_read_string(dict, "address", False, "site", loc);
3454dce4
SE		 1846 if (st->address)
1847 st->remoteport=dict_read_number(dict,"port",True,"site",loc,0);
1848 else st->remoteport=0;
2fe58dfd
SE		 1849 st->pubkey=find_cl_if(dict,"key",CL_RSAPUBKEY,True,"site",loc);
1850
5b5f297f 1851 GET_CLOSURE_LIST("transform",transforms,ntransforms,CL_TRANSFORM);
2fe58dfd
SE		 1852
1853 st->dh=find_cl_if(dict,"dh",CL_DH,True,"site",loc);
1854 st->hash=find_cl_if(dict,"hash",CL_HASH,True,"site",loc);
1855
0391d9ee 1856#define DEFAULT(D) (st->peer_mobile || st->local_mobile \
e57264d6 1857 ? DEFAULT_MOBILE_##D : DEFAULT_##D)
e7f8ec2a 1858#define CFG_NUMBER(k,D) dict_read_number(dict,(k),False,"site",loc,DEFAULT(D));
c27ca22f 1859
e7f8ec2a
IJ		 1860 st->key_lifetime= CFG_NUMBER("key-lifetime", KEY_LIFETIME);
1861 st->setup_retries= CFG_NUMBER("setup-retries", SETUP_RETRIES);
1862 st->setup_retry_interval= CFG_NUMBER("setup-timeout", SETUP_RETRY_INTERVAL);
1863 st->wait_timeout= CFG_NUMBER("wait-time", WAIT_TIME);
3ed1846a 1864 st->mtu_target= dict_read_number(dict,"mtu-target",False,"site",loc,0);
e7f8ec2a 1865
446353cd
IJ		 1866 st->mobile_peer_expiry= dict_read_number(
1867 dict,"mobile-peer-expiry",False,"site",loc,DEFAULT_MOBILE_PEER_EXPIRY);
1868
1869 st->transport_peers_max= !st->peer_mobile ? 1 : dict_read_number(
1870 dict,"mobile-peers-max",False,"site",loc,DEFAULT_MOBILE_PEERS_MAX);
1871 if (st->transport_peers_max<1 ||
1872 st->transport_peers_max>=MAX_MOBILE_PEERS_MAX) {
1873 cfgfatal(loc,"site","mobile-peers-max must be in range 1.."
1874 STRING(MAX_MOBILE_PEERS_MAX) "\n");
1875 }
1876
e7f8ec2a 1877 if (st->key_lifetime < DEFAULT(KEY_RENEGOTIATE_GAP)*2)
c27ca22f
IJ		 1878 st->key_renegotiate_time=st->key_lifetime/2;
1879 else
e7f8ec2a 1880 st->key_renegotiate_time=st->key_lifetime-DEFAULT(KEY_RENEGOTIATE_GAP);
9d3a4132 1881 st->key_renegotiate_time=dict_read_number(
cce0051f 1882 dict,"renegotiate-time",False,"site",loc,st->key_renegotiate_time);
9d3a4132
SE		 1883 if (st->key_renegotiate_time > st->key_lifetime) {
1884 cfgfatal(loc,"site",
1885 "renegotiate-time must be less than key-lifetime\n");
1886 }
9d3a4132
SE		 1887
1888 st->log_events=string_list_to_word(dict_lookup(dict,"log-events"),
1889 log_event_table,"site");
2fe58dfd 1890
5c19b79c 1891 st->resolving=False;
dd9209d1
IJ		 1892 st->allow_send_prod=0;
1893
4efd681a
SE		 1894 st->tunname=safe_malloc(strlen(st->localname)+strlen(st->remotename)+5,
1895 "site_apply");
1896 sprintf(st->tunname,"%s<->%s",st->localname,st->remotename);
1897
2fe58dfd 1898 /* The information we expect to see in incoming messages of type 1 */
59230b9b
IJ		 1899 /* fixme: lots of unchecked overflows here, but the results are only
1900 corrupted packets rather than undefined behaviour */
2fe58dfd
SE		 1901 st->setup_priority=(strcmp(st->localname,st->remotename)>0);
1902
1903 buffer_new(&st->buffer,SETUP_BUFFER_LEN);
1904
8aaaa634 1905 buffer_new(&st->scratch,SETUP_BUFFER_LEN);
05f39b4d
IJ		 1906 BUF_ALLOC(&st->scratch,"site:scratch");
1907
2fe58dfd
SE		 1908 /* We are interested in poll(), but only for timeouts. We don't have
1909 any fds of our own. */
1910 register_for_poll(st, site_beforepoll, site_afterpoll, 0, "site");
1911 st->timeout=0;
1912
09a385fb 1913 st->remote_capabilities=0;
5b5f297f 1914 st->chosen_transform=0;
19e9a588 1915 st->current.key_timeout=0;
02b0959b 1916 st->auxiliary_key.key_timeout=0;
446353cd
IJ		 1917 transport_peers_clear(st,&st->peers);
1918 transport_peers_clear(st,&st->setup_peers);
2fe58dfd
SE		 1919 /* XXX mlock these */
1920 st->dhsecret=safe_malloc(st->dh->len,"site:dhsecret");
5b5f297f
IJ		 1921 st->sharedsecretlen=st->sharedsecretallocd=0;
1922 st->sharedsecret=0;
1923
5b5f297f
IJ		 1924 for (i=0; i<st->ntransforms; i++) {
1925 struct transform_if *ti=st->transforms[i];
1926 uint32_t capbit = 1UL << ti->capab_transformnum;
1927 if (st->local_capabilities & capbit)
1928 slog(st,LOG_ERROR,"transformnum capability bit"
1929 " %d (%#"PRIx32") reused", ti->capab_transformnum, capbit);
1930 st->local_capabilities |= capbit;
59533c16 1931 }
59533c16 1932
2fe58dfd 1933 /* We need to register the remote networks with the netlink device */
3ed1846a
IJ		 1934 uint32_t netlink_mtu; /* local virtual interface mtu */
1935 st->netlink->reg(st->netlink->st, site_outgoing, st, &netlink_mtu);
1936 if (!st->mtu_target)
1937 st->mtu_target=netlink_mtu;
ff05a229 1938
59533c16
IJ		 1939 for (i=0; i<st->ncomms; i++)
1940 st->comms[i]->request_notify(st->comms[i]->st, st, site_incoming);
2fe58dfd 1941
fcad4b0b
IJ		 1942 st->current.transform=0;
1943 st->auxiliary_key.transform=0;
1944 st->new_transform=0;
bd98cd6b 1945 st->auxiliary_is_new=0;
2fe58dfd
SE		 1946
1947 enter_state_stop(st);
1948
794f2398
SE		 1949 add_hook(PHASE_SHUTDOWN,site_phase_hook,st);
1950
2fe58dfd
SE		 1951 return new_closure(&st->cl);
1952}
1953
2fe58dfd
SE		 1954void site_module(dict_t *dict)
1955{
1956 add_closure(dict,"site",site_apply);
1957}
446353cd
IJ		 1958
1959
1960/***** TRANSPORT PEERS definitions *****/
1961
1962static void transport_peers_debug(struct site *st, transport_peers *dst,
1963 const char *didwhat,
1964 int nargs, const struct comm_addr *args,
1965 size_t stride) {
1966 int i;
1967 char *argp;
1968
1969 if (!(st->log_events & LOG_PEER_ADDRS))
1970 return; /* an optimisation */
1971
1972 slog(st, LOG_PEER_ADDRS, "peers (%s) %s nargs=%d => npeers=%d",
1973 (dst==&st->peers ? "data" :
1974 dst==&st->setup_peers ? "setup" : "UNKNOWN"),
1975 didwhat, nargs, dst->npeers);
1976
1977 for (i=0, argp=(void*)args;
1978 i<nargs;
1979 i++, (argp+=stride?stride:sizeof(*args))) {
1980 const struct comm_addr *ca=(void*)argp;
1981 slog(st, LOG_PEER_ADDRS, " args: addrs[%d]=%s",
1a448682 1982 i, comm_addr_to_string(ca));
446353cd
IJ		 1983 }
1984 for (i=0; i<dst->npeers; i++) {
1985 struct timeval diff;
1986 timersub(tv_now,&dst->peers[i].last,&diff);
1987 const struct comm_addr *ca=&dst->peers[i].addr;
1988 slog(st, LOG_PEER_ADDRS, " peers: addrs[%d]=%s T-%ld.%06ld",
1a448682 1989 i, comm_addr_to_string(ca),
446353cd
IJ		 1990 (unsigned long)diff.tv_sec, (unsigned long)diff.tv_usec);
1991 }
1992}
1993
1994static int transport_peer_compar(const void *av, const void *bv) {
1995 const transport_peer *a=av;
1996 const transport_peer *b=bv;
1997 /* put most recent first in the array */
1998 if (timercmp(&a->last, &b->last, <)) return +1;
1999 if (timercmp(&a->last, &b->last, >)) return -11;
2000 return 0;
2001}
2002
2003static void transport_peers_expire(struct site *st, transport_peers *peers) {
2004 /* peers must be sorted first */
2005 int previous_peers=peers->npeers;
2006 struct timeval oldest;
2007 oldest.tv_sec = tv_now->tv_sec - st->mobile_peer_expiry;
2008 oldest.tv_usec = tv_now->tv_usec;
2009 while (peers->npeers>1 &&
2010 timercmp(&peers->peers[peers->npeers-1].last, &oldest, <))
2011 peers->npeers--;
2012 if (peers->npeers != previous_peers)
2013 transport_peers_debug(st,peers,"expire", 0,0,0);
2014}
2015
2016static void transport_record_peer(struct site *st, transport_peers *peers,
2017 const struct comm_addr *addr, const char *m) {
2018 int slot, changed=0;
2019
2020 for (slot=0; slot<peers->npeers; slot++)
2021 if (!memcmp(&peers->peers[slot].addr, addr, sizeof(*addr)))
2022 goto found;
2023
2024 changed=1;
2025 if (peers->npeers==st->transport_peers_max)
925c5ca8 2026 slot=st->transport_peers_max-1;
446353cd
IJ		 2027 else
2028 slot=peers->npeers++;
2029
2030 found:
2031 peers->peers[slot].addr=*addr;
2032 peers->peers[slot].last=*tv_now;
2033
2034 if (peers->npeers>1)
2035 qsort(peers->peers, peers->npeers,
2036 sizeof(*peers->peers), transport_peer_compar);
2037
2038 if (changed || peers->npeers!=1)
2039 transport_peers_debug(st,peers,m, 1,addr,0);
2040 transport_peers_expire(st, peers);
2041}
2042
2043static bool_t transport_compute_setupinit_peers(struct site *st,
dd9209d1
IJ		 2044 const struct comm_addr *configured_addr /* 0 if none or not found */,
2045 const struct comm_addr *prod_hint_addr /* 0 if none */) {
446353cd 2046
dd9209d1
IJ		 2047 if (!configured_addr && !prod_hint_addr &&
2048 !transport_peers_valid(&st->peers))
446353cd
IJ		 2049 return False;
2050
2051 slog(st,LOG_SETUP_INIT,
dd9209d1
IJ		 2052 "using:%s%s %d old peer address(es)",
2053 configured_addr ? " configured address;" : "",
2054 prod_hint_addr ? " PROD hint address;" : "",
779837e1 2055 st->peers.npeers);
446353cd 2056
0391d9ee 2057 /* Non-mobile peers have st->peers.npeers==0 or ==1, since they
446353cd
IJ		 2058 * have transport_peers_max==1. The effect is that this code
2059 * always uses the configured address if supplied, or otherwise
dd9209d1
IJ		 2060 * the address of the incoming PROD, or the existing data peer if
2061 * one exists; this is as desired. */
446353cd
IJ		 2062
2063 transport_peers_copy(st,&st->setup_peers,&st->peers);
2064
dd9209d1
IJ		 2065 if (prod_hint_addr)
2066 transport_record_peer(st,&st->setup_peers,prod_hint_addr,"prod");
2067
446353cd
IJ		 2068 if (configured_addr)
2069 transport_record_peer(st,&st->setup_peers,configured_addr,"setupinit");
2070
2071 assert(transport_peers_valid(&st->setup_peers));
2072 return True;
2073}
2074
2075static void transport_setup_msgok(struct site *st, const struct comm_addr *a) {
2076 if (st->peer_mobile)
2077 transport_record_peer(st,&st->setup_peers,a,"setupmsg");
2078}
2079static void transport_data_msgok(struct site *st, const struct comm_addr *a) {
2080 if (st->peer_mobile)
2081 transport_record_peer(st,&st->peers,a,"datamsg");
2082}
2083
2084static int transport_peers_valid(transport_peers *peers) {
2085 return peers->npeers;
2086}
2087static void transport_peers_clear(struct site *st, transport_peers *peers) {
2088 peers->npeers= 0;
2089 transport_peers_debug(st,peers,"clear",0,0,0);
2090}
2091static void transport_peers_copy(struct site *st, transport_peers *dst,
2092 const transport_peers *src) {
2093 dst->npeers=src->npeers;
2094 memcpy(dst->peers, src->peers, sizeof(*dst->peers) * dst->npeers);
2095 transport_peers_debug(st,dst,"copy",
a620a048 2096 src->npeers, &src->peers->addr, sizeof(*src->peers));
446353cd
IJ		 2097}
2098
2099void transport_xmit(struct site *st, transport_peers *peers,
2100 struct buffer_if *buf, bool_t candebug) {
2101 int slot;
2102 transport_peers_expire(st, peers);
2103 for (slot=0; slot<peers->npeers; slot++) {
2104 transport_peer *peer=&peers->peers[slot];
2105 if (candebug)
2106 dump_packet(st, buf, &peer->addr, False);
2107 peer->addr.comm->sendmsg(peer->addr.comm->st, buf, &peer->addr);
2108 }
2109}
2110
2111/***** END of transport peers declarations *****/
Secnet virtual private network: clone of http://www.chiark.greenend.org.uk/ucgi/~ian/git/secnet.git/