Statistics
| Branch: | Revision:

iof-bird-daemon / proto / rpki / rpki.c @ 62e64905

History | View | Annotate | Download (26.6 KB)

1
/*
2
 *        BIRD -- The Resource Public Key Infrastructure (RPKI) to Router Protocol
3
 *
4
 *        (c) 2015 CZ.NIC
5
 *        (c) 2015 Pavel Tvrdik <pawel.tvrdik@gmail.com>
6
 *
7
 *        Using RTRlib: http://rpki.realmv6.org/
8
 *
9
 *        Can be freely distributed and used under the terms of the GNU GPL.
10
 */
11

    
12
/**
13
 * DOC: RPKI To Router (RPKI-RTR)
14
 *
15
 * The RPKI-RTR protocol is implemented in several files: |rpki.c| containing
16
 * the routes handling, protocol logic, timer events, cache connection,
17
 * reconfiguration, configuration and protocol glue with BIRD core, |packets.c|
18
 * containing the RPKI packets handling and finally all transports files:
19
 * |transport.c|, |tcp_transport.c| and |ssh_transport.c|.
20
 *
21
 * The |transport.c| is a middle layer and interface for each specific
22
 * transport. Transport is a way how to wrap a communication with a cache
23
 * server. There is supported an unprotected TCP transport and an encrypted
24
 * SSHv2 transport. The SSH transport requires LibSSH library. LibSSH is
25
 * loading dynamically using |dlopen()| function. SSH support is integrated in
26
 * |sysdep/unix/io.c|. Each transport must implement an initialization
27
 * function, an open function and a socket identification function. That's all.
28
 *
29
 * This implementation is based on the RTRlib (http://rpki.realmv6.org/). The
30
 * BIRD takes over files |packets.c|, |rtr.c| (inside |rpki.c|), |transport.c|,
31
 * |tcp_transport.c| and |ssh_transport.c| from RTRlib.
32
 *
33
 * A RPKI-RTR connection is described by a structure &rpki_cache. The main
34
 * logic is located in |rpki_cache_change_state()| function. There is a state
35
 * machine. The standard starting state flow looks like |Down| ~> |Connecting|
36
 * ~> |Sync-Start| ~> |Sync-Running| ~> |Established| and then the last three
37
 * states are periodically repeated.
38
 *
39
 * |Connecting| state establishes the transport connection. The state from a
40
 * call |rpki_cache_change_state(CONNECTING)| to a call |rpki_connected_hook()|
41
 *
42
 * |Sync-Start| state starts with sending |Reset Query| or |Serial Query| and
43
 * then waits for |Cache Response|. The state from |rpki_connected_hook()| to
44
 * |rpki_handle_cache_response_pdu()|
45
 *
46
 * During |Sync-Running| BIRD receives data with IPv4/IPv6 Prefixes from cache
47
 * server. The state starts from |rpki_handle_cache_response_pdu()| and ends
48
 * in |rpki_handle_end_of_data_pdu()|.
49
 *
50
 * |Established| state means that BIRD has synced all data with cache server.
51
 * Schedules a refresh timer event that invokes |Sync-Start|. Schedules Expire
52
 * timer event and stops a Retry timer event.
53
 *
54
 * |Transport Error| state means that we have some troubles with a network
55
 * connection. We cannot connect to a cache server or we wait too long for some
56
 * expected PDU for received - |Cache Response| or |End of Data|. It closes
57
 * current connection and schedules a Retry timer event.
58
 *
59
 * |Fatal Protocol Error| is occurred e.g. by received a bad Session ID. We
60
 * restart a protocol, so all ROAs are flushed immediately.
61
 *
62
 * The RPKI-RTR protocol (RFC 6810 bis) defines configurable refresh, retry and
63
 * expire intervals. For maintaining a connection are used timer events that
64
 * are scheduled by |rpki_schedule_next_refresh()|,
65
 * |rpki_schedule_next_retry()| and |rpki_schedule_next_expire()| functions.
66
 *
67
 * A Refresh timer event performs a sync of |Established| connection. So it
68
 * shifts state to |Sync-Start|. If at the beginning of second call of a
69
 * refresh event is connection in |Sync-Start| state then we didn't receive a
70
 * |Cache Response| from a cache server and we invoke |Transport Error| state.
71
 *
72
 * A Retry timer event attempts to connect cache server. It is activated after
73
 * |Transport Error| state and terminated by reaching |Established| state.
74
 * If cache connection is still connecting to the cache server at the beginning
75
 * of an event call then the Retry timer event invokes |Transport Error| state.
76
 *
77
 * An Expire timer event checks expiration of ROAs. If a last successful sync
78
 * was more ago than the expire interval then the Expire timer event invokes a
79
 * protocol restart thereby removes all ROAs learned from that cache server and
80
 * continue trying to connect to cache server. The Expire event is activated
81
 * by initial successful loading of ROAs, receiving End of Data PDU.
82
 *
83
 * A reconfiguration of cache connection works well without restarting when we
84
 * change only intervals values.
85
 *
86
 * Supported standards:
87
 * - RFC 6810 - main RPKI-RTR standard
88
 * - RFC 6810 bis - an explicit timing parameters and protocol version number negotiation
89
 */
90

    
91
#include <stdlib.h>
92
#include <netdb.h>
93

    
94
#undef LOCAL_DEBUG
95

    
96
#include "rpki.h"
97
#include "lib/string.h"
98
#include "nest/cli.h"
99

    
100
/* Return values for reconfiguration functions */
101
#define NEED_RESTART                 0
102
#define SUCCESSFUL_RECONF         1
103

    
104
static int rpki_open_connection(struct rpki_cache *cache);
105
static void rpki_close_connection(struct rpki_cache *cache);
106
static void rpki_schedule_next_refresh(struct rpki_cache *cache);
107
static void rpki_schedule_next_retry(struct rpki_cache *cache);
108
static void rpki_schedule_next_expire_check(struct rpki_cache *cache);
109
static void rpki_stop_refresh_timer_event(struct rpki_cache *cache);
110
static void rpki_stop_retry_timer_event(struct rpki_cache *cache);
111
static void rpki_stop_expire_timer_event(struct rpki_cache *cache);
112

    
113

    
114
/*
115
 *         Routes handling
116
 */
117

    
118
void
119
rpki_table_add_roa(struct rpki_cache *cache, struct channel *channel, const net_addr_union *pfxr)
120
{
121
  struct rpki_proto *p = cache->p;
122

    
123
  rta a0 = {
124
    .src = p->p.main_source,
125
    .source = RTS_RPKI,
126
    .scope = SCOPE_UNIVERSE,
127
    .dest = RTD_NONE,
128
  };
129

    
130
  rta *a = rta_lookup(&a0);
131
  rte *e = rte_get_temp(a);
132

    
133
  e->pflags = 0;
134

    
135
  rte_update2(channel, &pfxr->n, e, a0.src);
136
}
137

    
138
void
139
rpki_table_remove_roa(struct rpki_cache *cache, struct channel *channel, const net_addr_union *pfxr)
140
{
141
  struct rpki_proto *p = cache->p;
142
  rte_update2(channel, &pfxr->n, NULL, p->p.main_source);
143
}
144

    
145

    
146
/*
147
 *        RPKI Protocol Logic
148
 */
149

    
150
static const char *str_cache_states[] = {
151
  [RPKI_CS_CONNECTING]                 = "Connecting",
152
  [RPKI_CS_ESTABLISHED]         = "Established",
153
  [RPKI_CS_RESET]                 = "Reseting",
154
  [RPKI_CS_SYNC_START]                 = "Sync-Start",
155
  [RPKI_CS_SYNC_RUNNING]         = "Sync-Running",
156
  [RPKI_CS_FAST_RECONNECT]         = "Fast-Reconnect",
157
  [RPKI_CS_NO_INCR_UPDATE_AVAIL]= "No-Increment-Update-Available",
158
  [RPKI_CS_ERROR_NO_DATA_AVAIL] = "Cache-Error-No-Data-Available",
159
  [RPKI_CS_ERROR_FATAL]         = "Fatal-Protocol-Error",
160
  [RPKI_CS_ERROR_TRANSPORT]         = "Transport-Error",
161
  [RPKI_CS_SHUTDOWN]                 = "Down"
162
};
163

    
164
/**
165
 * rpki_cache_state_to_str - give a text representation of cache state
166
 * @state: A cache state
167
 *
168
 * The function converts logic cache state into string.
169
 */
170
const char *
171
rpki_cache_state_to_str(enum rpki_cache_state state)
172
{
173
  return str_cache_states[state];
174
}
175

    
176
/**
177
 * rpki_start_cache - connect to a cache server
178
 * @cache: RPKI connection instance
179
 *
180
 * This function is a high level method to kick up a connection to a cache server.
181
 */
182
static void
183
rpki_start_cache(struct rpki_cache *cache)
184
{
185
  rpki_cache_change_state(cache, RPKI_CS_CONNECTING);
186
}
187

    
188
/**
189
 * rpki_force_restart_proto - force shutdown and start protocol again
190
 * @p: RPKI protocol instance
191
 *
192
 * This function calls shutdown and frees all protocol resources as well.
193
 * After calling this function should be no operations with protocol data,
194
 * they could be freed already.
195
 */
196
static void
197
rpki_force_restart_proto(struct rpki_proto *p)
198
{
199
  if (p->cache)
200
  {
201
    CACHE_DBG(p->cache, "Connection object destroying");
202
  }
203

    
204
  /* Sign as freed */
205
  p->cache = NULL;
206

    
207
  proto_notify_state(&p->p, PS_DOWN);
208
}
209

    
210
/**
211
 * rpki_cache_change_state - check and change cache state
212
 * @cache: RPKI cache instance
213
 * @new_state: suggested new state
214
 *
215
 * This function makes transitions between internal states.
216
 * It represents the core of logic management of RPKI protocol.
217
 * Cannot transit into the same state as cache is in already.
218
 */
219
void
220
rpki_cache_change_state(struct rpki_cache *cache, const enum rpki_cache_state new_state)
221
{
222
  const enum rpki_cache_state old_state = cache->state;
223

    
224
  if (old_state == new_state)
225
    return;
226

    
227
  cache->state = new_state;
228
  CACHE_TRACE(D_EVENTS, cache, "Changing from %s to %s state", rpki_cache_state_to_str(old_state), rpki_cache_state_to_str(new_state));
229

    
230
  switch (new_state)
231
  {
232
  case RPKI_CS_CONNECTING:
233
  {
234
    sock *sk = cache->tr_sock->sk;
235

    
236
    if (sk == NULL || sk->fd < 0)
237
      rpki_open_connection(cache);
238
    else
239
      rpki_cache_change_state(cache, RPKI_CS_SYNC_START);
240

    
241
    rpki_schedule_next_retry(cache);
242
    break;
243
  }
244

    
245
  case RPKI_CS_ESTABLISHED:
246
    rpki_schedule_next_refresh(cache);
247
    rpki_schedule_next_expire_check(cache);
248
    rpki_stop_retry_timer_event(cache);
249
    break;
250

    
251
  case RPKI_CS_RESET:
252
    /* Resetting cache connection. */
253
    cache->request_session_id = 1;
254
    cache->serial_num = 0;
255
    rpki_cache_change_state(cache, RPKI_CS_SYNC_START);
256
    break;
257

    
258
  case RPKI_CS_SYNC_START:
259
    /* Requesting for receive ROAs from a cache server. */
260
    if (cache->request_session_id)
261
    {
262
      /* Send request for Session ID */
263
      if (rpki_send_reset_query(cache) != RPKI_SUCCESS)
264
        rpki_cache_change_state(cache, RPKI_CS_ERROR_TRANSPORT);
265
    }
266
    else
267
    {
268
      /* We have already a session_id. So send a Serial Query and start an incremental sync */
269
      if (rpki_send_serial_query(cache) != RPKI_SUCCESS)
270
        rpki_cache_change_state(cache, RPKI_CS_ERROR_TRANSPORT);
271
    }
272
    break;
273

    
274
  case RPKI_CS_SYNC_RUNNING:
275
    /* The state between Cache Response and End of Data. Only waiting for
276
     * receiving all IP Prefix PDUs and finally a End of Data PDU. */
277
    break;
278

    
279
  case RPKI_CS_NO_INCR_UPDATE_AVAIL:
280
    /* Server was unable to answer the last Serial Query and sent Cache Reset. */
281
    rpki_cache_change_state(cache, RPKI_CS_RESET);
282
    break;
283

    
284
  case RPKI_CS_ERROR_NO_DATA_AVAIL:
285
    /* No validation records are available on the cache server. */
286
    rpki_cache_change_state(cache, RPKI_CS_RESET);
287
    break;
288

    
289
  case RPKI_CS_ERROR_FATAL:
290
    /* Fatal protocol error occurred. */
291
    rpki_force_restart_proto(cache->p);
292
    break;
293

    
294
  case RPKI_CS_ERROR_TRANSPORT:
295
    /* Error on the transport socket occurred. */
296
    rpki_close_connection(cache);
297
    rpki_schedule_next_retry(cache);
298
    rpki_stop_refresh_timer_event(cache);
299
    break;
300

    
301
  case RPKI_CS_FAST_RECONNECT:
302
    /* Reconnect without any waiting period */
303
    rpki_close_connection(cache);
304
    rpki_cache_change_state(cache, RPKI_CS_CONNECTING);
305
    break;
306

    
307
  case RPKI_CS_SHUTDOWN:
308
    bug("This isn't never really called.");
309
    break;
310
  };
311
}
312

    
313

    
314
/*
315
 *         RPKI Timer Events
316
 */
317

    
318
static void
319
rpki_schedule_next_refresh(struct rpki_cache *cache)
320
{
321
  uint time_to_wait = cache->refresh_interval;
322

    
323
  CACHE_DBG(cache, "after %u seconds", time_to_wait);
324
  tm_start(cache->refresh_timer, time_to_wait);
325
}
326

    
327
static void
328
rpki_schedule_next_retry(struct rpki_cache *cache)
329
{
330
  uint time_to_wait = cache->retry_interval;
331

    
332
  CACHE_DBG(cache, "after %u seconds", time_to_wait);
333
  tm_start(cache->retry_timer, time_to_wait);
334
}
335

    
336
static void
337
rpki_schedule_next_expire_check(struct rpki_cache *cache)
338
{
339
  /* A minimum time to wait is 1 second */
340
  uint time_to_wait = MAX(((int)cache->expire_interval - (int)(now - cache->last_update)), 1);
341

    
342
  CACHE_DBG(cache, "after %u seconds", time_to_wait);
343
  tm_start(cache->expire_timer, time_to_wait);
344
}
345

    
346
static void
347
rpki_stop_refresh_timer_event(struct rpki_cache *cache)
348
{
349
  CACHE_DBG(cache, "Stop");
350
  tm_stop(cache->refresh_timer);
351
}
352

    
353
static void
354
rpki_stop_retry_timer_event(struct rpki_cache *cache)
355
{
356
  CACHE_DBG(cache, "Stop");
357
  tm_stop(cache->retry_timer);
358
}
359

    
360
static void
361
rpki_stop_expire_timer_event(struct rpki_cache *cache)
362
{
363
  CACHE_DBG(cache, "Stop");
364
  tm_stop(cache->expire_timer);
365
}
366

    
367
static int
368
rpki_do_we_recv_prefix_pdu_in_last_seconds(struct rpki_cache *cache)
369
{
370
  if (cache->last_rx_prefix == 0)
371
    return 0;
372

    
373
  return ((now - cache->last_rx_prefix) <= 2);
374
}
375

    
376
/**
377
 * rpki_refresh_hook - control a scheduling of downloading data from cache server
378
 * @tm: refresh timer with cache connection instance in data
379
 *
380
 * This function is periodically called during &ESTABLISHED or &SYNC* state
381
 * cache connection.  The first refresh schedule is invoked after receiving a
382
 * |End of Data| PDU and has run by some &ERROR is occurred.
383
 */
384
static void
385
rpki_refresh_hook(struct timer *tm)
386
{
387
  struct rpki_cache *cache = tm->data;
388

    
389
  CACHE_DBG(cache, "%s", rpki_cache_state_to_str(cache->state));
390

    
391
  switch (cache->state)
392
  {
393
  case RPKI_CS_ESTABLISHED:
394
    rpki_cache_change_state(cache, RPKI_CS_SYNC_START);
395
    break;
396

    
397
  case RPKI_CS_SYNC_START:
398
    /* We sent Serial/Reset Query in last refresh hook call
399
     * and didn't receive Cache Response yet. It is probably
400
     * troubles with network. */
401
  case RPKI_CS_SYNC_RUNNING:
402
    /* We sent Serial/Reset Query in last refresh hook call
403
     * and we got Cache Response but didn't get End-Of-Data yet.
404
     * It could be a trouble with network or only too long synchronization. */
405
    if (!rpki_do_we_recv_prefix_pdu_in_last_seconds(cache))
406
    {
407
      CACHE_TRACE(D_EVENTS, cache, "Sync takes more time than refresh interval %us, resetting connection", cache->refresh_interval);
408
      rpki_cache_change_state(cache, RPKI_CS_ERROR_TRANSPORT);
409
    }
410
    break;
411

    
412
  default:
413
    break;
414
  }
415

    
416
  if (cache->state != RPKI_CS_SHUTDOWN && cache->state != RPKI_CS_ERROR_TRANSPORT)
417
    rpki_schedule_next_refresh(cache);
418
  else
419
    rpki_stop_refresh_timer_event(cache);
420
}
421

    
422
/**
423
 * rpki_retry_hook - control a scheduling of retrying connection to cache server
424
 * @tm: retry timer with cache connection instance in data
425
 *
426
 * This function is periodically called during &ERROR* state cache connection.
427
 * The first retry schedule is invoked after any &ERROR* state occurred and
428
 * ends by reaching of &ESTABLISHED state again.
429
 */
430
static void
431
rpki_retry_hook(struct timer *tm)
432
{
433
  struct rpki_cache *cache = tm->data;
434

    
435
  CACHE_DBG(cache, "%s", rpki_cache_state_to_str(cache->state));
436

    
437
  switch (cache->state)
438
  {
439
  case RPKI_CS_ESTABLISHED:
440
  case RPKI_CS_SHUTDOWN:
441
    break;
442

    
443
  case RPKI_CS_CONNECTING:
444
  case RPKI_CS_SYNC_START:
445
  case RPKI_CS_SYNC_RUNNING:
446
    if (!rpki_do_we_recv_prefix_pdu_in_last_seconds(cache))
447
    {
448
      /* We tried to establish a connection in last retry hook call and haven't done
449
       * yet. It looks like troubles with network. We are aggressive here. */
450
      CACHE_TRACE(D_EVENTS, cache, "Sync takes more time than retry interval %us, resetting connection.", cache->retry_interval);
451
      rpki_cache_change_state(cache, RPKI_CS_ERROR_TRANSPORT);
452
    }
453
    break;
454

    
455
  default:
456
    rpki_cache_change_state(cache, RPKI_CS_CONNECTING);
457
    break;
458
  }
459

    
460
  if (cache->state != RPKI_CS_ESTABLISHED)
461
    rpki_schedule_next_retry(cache);
462
  else
463
    rpki_stop_retry_timer_event(cache);
464
}
465

    
466
/**
467
 * rpki_expire_hook - control a expiration of ROA entries
468
 * @tm: expire timer with cache connection instance in data
469
 *
470
 * This function is scheduled after received a |End of Data| PDU.
471
 * A waiting interval is calculated dynamically by last update.
472
 * If we reach an expiration time then we invoke a restarting
473
 * of the protocol.
474
 */
475
static void
476
rpki_expire_hook(struct timer *tm)
477
{
478
  struct rpki_cache *cache = tm->data;
479

    
480
  if (cache->last_update == 0)
481
    return;
482

    
483
  CACHE_DBG(cache, "%s", rpki_cache_state_to_str(cache->state));
484

    
485
  if ((cache->last_update + cache->expire_interval) < now)
486
  {
487
    CACHE_TRACE(D_EVENTS, cache, "All ROAs expired");
488
    rpki_force_restart_proto(cache->p);
489
  }
490
  else
491
  {
492
    CACHE_DBG(cache, "Remains %d seconds to become ROAs obsolete", (int)cache->expire_interval - (int)(now - cache->last_update));
493
    rpki_schedule_next_expire_check(cache);
494
  }
495
}
496

    
497
/**
498
 * rpki_check_refresh_interval - check validity of refresh interval value
499
 * @seconds: suggested value
500
 *
501
 * This function validates value and should return |NULL|.
502
 * If the check doesn't pass then returns error message.
503
 */
504
const char *
505
rpki_check_refresh_interval(uint seconds)
506
{
507
  if (seconds < 1)
508
    return "Minimum allowed refresh interval is 1 second";
509
  if (seconds > 86400)
510
    return "Maximum allowed refresh interval is 86400 seconds";
511
  return NULL;
512
}
513

    
514
/**
515
 * rpki_check_retry_interval - check validity of retry interval value
516
 * @seconds: suggested value
517
 *
518
 * This function validates value and should return |NULL|.
519
 * If the check doesn't pass then returns error message.
520
 */
521
const char *
522
rpki_check_retry_interval(uint seconds)
523
{
524
  if (seconds < 1)
525
    return "Minimum allowed retry interval is 1 second";
526
  if (seconds > 7200)
527
    return "Maximum allowed retry interval is 7200 seconds";
528
  return NULL;
529
}
530

    
531
/**
532
 * rpki_check_expire_interval - check validity of expire interval value
533
 * @seconds: suggested value
534
 *
535
 * This function validates value and should return |NULL|.
536
 * If the check doesn't pass then returns error message.
537
 */
538
const char *
539
rpki_check_expire_interval(uint seconds)
540
{
541
  if (seconds < 600)
542
    return "Minimum allowed expire interval is 600 seconds";
543
  if (seconds > 172800)
544
    return "Maximum allowed expire interval is 172800 seconds";
545
  return NULL;
546
}
547

    
548

    
549
/*
550
 *         RPKI Cache
551
 */
552

    
553
static struct rpki_cache *
554
rpki_init_cache(struct rpki_proto *p, struct rpki_config *cf)
555
{
556
  pool *pool = rp_new(p->p.pool, cf->hostname);
557

    
558
  struct rpki_cache *cache = mb_allocz(pool, sizeof(struct rpki_cache));
559

    
560
  cache->pool = pool;
561
  cache->p = p;
562

    
563
  cache->state = RPKI_CS_SHUTDOWN;
564
  cache->request_session_id = 1;
565
  cache->version = RPKI_MAX_VERSION;
566

    
567
  cache->refresh_interval = cf->refresh_interval;
568
  cache->retry_interval = cf->retry_interval;
569
  cache->expire_interval = cf->expire_interval;
570
  cache->refresh_timer = tm_new_set(pool, &rpki_refresh_hook, cache, 0, 0);
571
  cache->retry_timer = tm_new_set(pool, &rpki_retry_hook, cache, 0, 0);
572
  cache->expire_timer = tm_new_set(pool, &rpki_expire_hook, cache, 0, 0);
573

    
574
  cache->tr_sock = mb_allocz(pool, sizeof(struct rpki_tr_sock));
575
  cache->tr_sock->cache = cache;
576

    
577
  switch (cf->tr_config.type)
578
  {
579
  case RPKI_TR_TCP: rpki_tr_tcp_init(cache->tr_sock); break;
580
  case RPKI_TR_SSH: rpki_tr_ssh_init(cache->tr_sock); break;
581
  };
582

    
583
  CACHE_DBG(cache, "Connection object created");
584

    
585
  return cache;
586
}
587

    
588
/**
589
 * rpki_get_cache_ident - give a text representation of cache server name
590
 * @cache: RPKI connection instance
591
 *
592
 * The function converts cache connection into string.
593
 */
594
const char *
595
rpki_get_cache_ident(struct rpki_cache *cache)
596
{
597
  return rpki_tr_ident(cache->tr_sock);
598
}
599

    
600
static int
601
rpki_open_connection(struct rpki_cache *cache)
602
{
603
  CACHE_TRACE(D_EVENTS, cache, "Opening a connection");
604

    
605
  if (rpki_tr_open(cache->tr_sock) == RPKI_TR_ERROR)
606
  {
607
    rpki_cache_change_state(cache, RPKI_CS_ERROR_TRANSPORT);
608
    return RPKI_TR_ERROR;
609
  }
610

    
611
  return RPKI_TR_SUCCESS;
612
}
613

    
614
static void
615
rpki_close_connection(struct rpki_cache *cache)
616
{
617
  CACHE_TRACE(D_EVENTS, cache, "Closing a connection");
618
  rpki_tr_close(cache->tr_sock);
619
  proto_notify_state(&cache->p->p, PS_START);
620
}
621

    
622
static int
623
rpki_shutdown(struct proto *P)
624
{
625
  struct rpki_proto *p = (void *) P;
626

    
627
  rpki_force_restart_proto(p);
628

    
629
  /* Protocol memory pool will be automatically freed */
630
  return PS_DOWN;
631
}
632

    
633

    
634
/*
635
 *         RPKI Reconfiguration
636
 */
637

    
638
static int
639
rpki_try_fast_reconnect(struct rpki_cache *cache, struct rpki_config *new, struct rpki_config *old)
640
{
641
  if (cache->state == RPKI_CS_ESTABLISHED)
642
  {
643
    rpki_cache_change_state(cache, RPKI_CS_FAST_RECONNECT);
644
    return SUCCESSFUL_RECONF;
645
  }
646

    
647
  return NEED_RESTART;
648
}
649

    
650
/**
651
 * rpki_reconfigure_cache - a cache reconfiguration
652
 * @p: RPKI protocol instance
653
 * @cache: a cache connection
654
 * @new: new RPKI configuration
655
 * @old: old RPKI configuration
656
 *
657
 * This function reconfigures existing single cache server connection with new
658
 * existing configuration.  Generally, a change of time intervals could be
659
 * reconfigured without restarting and all others changes requires a restart of
660
 * protocol.  Returns |NEED_TO_RESTART| or |SUCCESSFUL_RECONF|.
661
 */
662
static int
663
rpki_reconfigure_cache(struct rpki_proto *p, struct rpki_cache *cache, struct rpki_config *new, struct rpki_config *old)
664
{
665
  u8 try_fast_reconnect = 0;
666

    
667

    
668
  if (strcmp(old->hostname, new->hostname) != 0)
669
  {
670
    CACHE_TRACE(D_EVENTS, cache, "Cache server address changed to %s", new->hostname);
671
    return NEED_RESTART;
672
  }
673

    
674
  if (old->port != new->port)
675
  {
676
    CACHE_TRACE(D_EVENTS, cache, "Cache server port changed to %u", new->port);
677
    return NEED_RESTART;
678
  }
679

    
680
  if (old->tr_config.type != new->tr_config.type)
681
  {
682
    CACHE_TRACE(D_EVENTS, cache, "Transport type changed");
683
    return NEED_RESTART;
684
  }
685
  else if (new->tr_config.type == RPKI_TR_SSH)
686
  {
687
    struct rpki_tr_ssh_config *ssh_old = (void *) old->tr_config.spec;
688
    struct rpki_tr_ssh_config *ssh_new = (void *) new->tr_config.spec;
689
    if ((strcmp(ssh_old->bird_private_key, ssh_new->bird_private_key) != 0) ||
690
        (strcmp(ssh_old->cache_public_key, ssh_new->cache_public_key) != 0) ||
691
        (strcmp(ssh_old->user, ssh_new->user) != 0))
692
    {
693
      CACHE_TRACE(D_EVENTS, cache, "Settings of SSH transport configuration changed");
694
      try_fast_reconnect = 1;
695
    }
696
  }
697

    
698
#define TEST_INTERVAL(name, Name)                                                 \
699
    if (cache->name##_interval != new->name##_interval ||                        \
700
        old->keep_##name##_interval != new->keep_##name##_interval)                 \
701
    {                                                                                 \
702
      cache->name##_interval = new->name##_interval;                                \
703
      CACHE_TRACE(D_EVENTS, cache, #Name " interval changed to %u seconds %s", cache->name##_interval, (new->keep_##name##_interval ? "and keep it" : "")); \
704
      try_fast_reconnect = 1;                                                         \
705
    }
706
  TEST_INTERVAL(refresh, Refresh);
707
  TEST_INTERVAL(retry, Retry);
708
  TEST_INTERVAL(expire, Expire);
709
#undef TEST_INTERVAL
710

    
711
  if (try_fast_reconnect)
712
    return rpki_try_fast_reconnect(cache, new, old);
713

    
714
  return SUCCESSFUL_RECONF;
715
}
716

    
717
/**
718
 * rpki_reconfigure - a protocol reconfiguration hook
719
 * @P: a protocol instance
720
 * @CF: a new protocol configuration
721
 *
722
 * This function reconfigures whole protocol.
723
 * It sets new protocol configuration into a protocol structure.
724
 * Returns |NEED_TO_RESTART| or |SUCCESSFUL_RECONF|.
725
 */
726
static int
727
rpki_reconfigure(struct proto *P, struct proto_config *CF)
728
{
729
  struct rpki_proto *p = (void *) P;
730
  struct rpki_config *new = (void *) CF;
731
  struct rpki_config *old = (void *) p->p.cf;
732
  struct rpki_cache *cache = p->cache;
733

    
734
  if (!proto_configure_channel(&p->p, &p->roa4_channel, proto_cf_find_channel(CF, NET_ROA4)) ||
735
      !proto_configure_channel(&p->p, &p->roa6_channel, proto_cf_find_channel(CF, NET_ROA6)))
736
    return NEED_RESTART;
737

    
738
  if (rpki_reconfigure_cache(p, cache, new, old) != SUCCESSFUL_RECONF)
739
    return NEED_RESTART;
740

    
741
  return SUCCESSFUL_RECONF;
742
}
743

    
744

    
745
/*
746
 *         RPKI Protocol Glue
747
 */
748

    
749
static struct proto *
750
rpki_init(struct proto_config *CF)
751
{
752
  struct proto *P = proto_new(CF);
753
  struct rpki_proto *p = (void *) P;
754

    
755
  proto_configure_channel(&p->p, &p->roa4_channel, proto_cf_find_channel(CF, NET_ROA4));
756
  proto_configure_channel(&p->p, &p->roa6_channel, proto_cf_find_channel(CF, NET_ROA6));
757

    
758
  return P;
759
}
760

    
761
static int
762
rpki_start(struct proto *P)
763
{
764
  struct rpki_proto *p = (void *) P;
765
  struct rpki_config *cf = (void *) P->cf;
766

    
767
  p->cache = rpki_init_cache(p, cf);
768
  rpki_start_cache(p->cache);
769

    
770
  return PS_START;
771
}
772

    
773
static void
774
rpki_get_status(struct proto *P, byte *buf)
775
{
776
  struct rpki_proto *p = (struct rpki_proto *) P;
777

    
778
  if (P->proto_state == PS_DOWN)
779
  {
780
    *buf = 0;
781
    return;
782
  }
783

    
784
  if (p->cache)
785
    bsprintf(buf, "%s", rpki_cache_state_to_str(p->cache->state));
786
  else
787
    bsprintf(buf, "No cache server configured");
788
}
789

    
790
static void
791
rpki_show_proto_info_timer(const char *name, uint num, timer *t)
792
{
793
  if (t->expires)
794
    cli_msg(-1006, "  %-17s %us (remains %us)", name, num, tm_remains(t));
795
  else
796
    cli_msg(-1006, "  %-17s ---", name);
797
}
798

    
799
static void
800
rpki_show_proto_info(struct proto *P)
801
{
802
  struct rpki_proto *p = (struct rpki_proto *) P;
803
  struct rpki_config *cf = (void *) p->p.cf;
804
  struct rpki_cache *cache = p->cache;
805

    
806
  if (P->proto_state == PS_DOWN)
807
    return;
808

    
809
  if (cache)
810
  {
811
    const char *transport_name = "---";
812

    
813
    switch (cf->tr_config.type)
814
    {
815
    case RPKI_TR_SSH: transport_name = "SSHv2"; break;
816
    case RPKI_TR_TCP: transport_name = "Unprotected over TCP"; break;
817
    };
818

    
819
    cli_msg(-1006, "  Cache server:     %s", rpki_get_cache_ident(cache));
820
    cli_msg(-1006, "  Status:           %s", rpki_cache_state_to_str(cache->state));
821
    cli_msg(-1006, "  Transport:        %s", transport_name);
822
    cli_msg(-1006, "  Protocol version: %u", cache->version);
823

    
824
    if (cache->request_session_id)
825
      cli_msg(-1006, "  Session ID:       ---");
826
    else
827
      cli_msg(-1006, "  Session ID:       %u", cache->session_id);
828

    
829
    if (cache->last_update)
830
    {
831
      cli_msg(-1006, "  Serial number:    %u", cache->serial_num);
832
      cli_msg(-1006, "  Last update:      before %us", now - cache->last_update);
833
    }
834
    else
835
    {
836
      cli_msg(-1006, "  Serial number:    ---");
837
      cli_msg(-1006, "  Last update:      ---");
838
    }
839

    
840
    rpki_show_proto_info_timer("Refresh interval:", cache->refresh_interval, cache->refresh_timer);
841
    rpki_show_proto_info_timer("Retry interval:", cache->retry_interval, cache->retry_timer);
842
    rpki_show_proto_info_timer("Expire interval:", cache->expire_interval, cache->expire_timer);
843

    
844
    if (p->roa4_channel)
845
      channel_show_info(p->roa4_channel);
846
    else
847
      cli_msg(-1006, "  No roa4 channel");
848

    
849
    if (p->roa6_channel)
850
      channel_show_info(p->roa6_channel);
851
    else
852
      cli_msg(-1006, "  No roa6 channel");
853
  }
854
}
855

    
856

    
857
/*
858
 *         RPKI Protocol Configuration
859
 */
860

    
861
/**
862
 * rpki_check_config - check and complete configuration of RPKI protocol
863
 * @cf: RPKI configuration
864
 *
865
 * This function is called at the end of parsing RPKI protocol configuration.
866
 */
867
void
868
rpki_check_config(struct rpki_config *cf)
869
{
870
  /* Do not check templates at all */
871
  if (cf->c.class == SYM_TEMPLATE)
872
    return;
873

    
874
  if (ipa_zero(cf->ip) && cf->hostname == NULL)
875
    cf_error("IP address or hostname of cache server must be set");
876

    
877
  /* Set default transport type */
878
  if (cf->tr_config.spec == NULL)
879
  {
880
    cf->tr_config.spec = cfg_allocz(sizeof(struct rpki_tr_tcp_config));
881
    cf->tr_config.type = RPKI_TR_TCP;
882
  }
883

    
884
  if (cf->port == 0)
885
  {
886
    /* Set default port numbers */
887
    switch (cf->tr_config.type)
888
    {
889
    case RPKI_TR_SSH:
890
      cf->port = RPKI_SSH_PORT;
891
      break;
892
    default:
893
      cf->port = RPKI_TCP_PORT;
894
    }
895
  }
896
}
897

    
898
static void
899
rpki_postconfig(struct proto_config *CF)
900
{
901
  /* Define default channel */
902
  if (EMPTY_LIST(CF->channels))
903
    channel_config_new(NULL, CF->net_type, CF);
904
}
905

    
906
static void
907
rpki_copy_config(struct proto_config *dest, struct proto_config *src)
908
{
909
  /* Just a shallow copy */
910
}
911

    
912
struct protocol proto_rpki = {
913
  .name =                 "RPKI",
914
  .template =                 "rpki%d",
915
  .preference =         DEF_PREF_RPKI,
916
  .proto_size =         sizeof(struct rpki_proto),
917
  .config_size =        sizeof(struct rpki_config),
918
  .init =                 rpki_init,
919
  .start =                 rpki_start,
920
  .postconfig =         rpki_postconfig,
921
  .channel_mask =        (NB_ROA4 | NB_ROA6),
922
  .show_proto_info =        rpki_show_proto_info,
923
  .shutdown =                 rpki_shutdown,
924
  .copy_config =         rpki_copy_config,
925
  .reconfigure =         rpki_reconfigure,
926
  .get_status =         rpki_get_status,
927
};