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