2 * BIRD -- The Resource Public Key Infrastructure (RPKI) to Router Protocol
5 * (c) 2015 Pavel Tvrdik <pawel.tvrdik@gmail.com>
7 * Using RTRlib: http://rpki.realmv6.org/
9 * Can be freely distributed and used under the terms of the GNU GPL.
13 * DOC: RPKI To Router (RPKI-RTR)
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|.
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.
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.
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.
39 * |Connecting| state establishes the transport connection. The state from a
40 * call |rpki_cache_change_state(CONNECTING)| to a call |rpki_connected_hook()|
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()|
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()|.
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.
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.
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.
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.
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.
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.
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.
83 * A reconfiguration of cache connection works well without restarting when we
84 * change only intervals values.
86 * Supported standards:
87 * - RFC 6810 - main RPKI-RTR standard
88 * - RFC 6810 bis - an explicit timing parameters and protocol version number negotiation
97 #include "lib/string.h"
100 /* Return values for reconfiguration functions */
101 #define NEED_RESTART 0
102 #define SUCCESSFUL_RECONF 1
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
);
119 rpki_table_add_roa(struct rpki_cache
*cache
, struct channel
*channel
, const net_addr_union
*pfxr
)
121 struct rpki_proto
*p
= cache
->p
;
124 .src
= p
->p
.main_source
,
126 .scope
= SCOPE_UNIVERSE
,
130 rta
*a
= rta_lookup(&a0
);
131 rte
*e
= rte_get_temp(a
);
135 rte_update2(channel
, &pfxr
->n
, e
, a0
.src
);
139 rpki_table_remove_roa(struct rpki_cache
*cache
, struct channel
*channel
, const net_addr_union
*pfxr
)
141 struct rpki_proto
*p
= cache
->p
;
142 rte_update2(channel
, &pfxr
->n
, NULL
, p
->p
.main_source
);
147 * RPKI Protocol Logic
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"
165 * rpki_cache_state_to_str - give a text representation of cache state
166 * @state: A cache state
168 * The function converts logic cache state into string.
171 rpki_cache_state_to_str(enum rpki_cache_state state
)
173 return str_cache_states
[state
];
177 * rpki_start_cache - connect to a cache server
178 * @cache: RPKI connection instance
180 * This function is a high level method to kick up a connection to a cache server.
183 rpki_start_cache(struct rpki_cache
*cache
)
185 rpki_cache_change_state(cache
, RPKI_CS_CONNECTING
);
189 * rpki_force_restart_proto - force shutdown and start protocol again
190 * @p: RPKI protocol instance
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.
197 rpki_force_restart_proto(struct rpki_proto
*p
)
201 CACHE_DBG(p
->cache
, "Connection object destroying");
207 proto_notify_state(&p
->p
, PS_DOWN
);
211 * rpki_cache_change_state - check and change cache state
212 * @cache: RPKI cache instance
213 * @new_state: suggested new state
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.
220 rpki_cache_change_state(struct rpki_cache
*cache
, const enum rpki_cache_state new_state
)
222 const enum rpki_cache_state old_state
= cache
->state
;
224 if (old_state
== new_state
)
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
));
232 case RPKI_CS_CONNECTING
:
234 sock
*sk
= cache
->tr_sock
->sk
;
236 if (sk
== NULL
|| sk
->fd
< 0)
237 rpki_open_connection(cache
);
239 rpki_cache_change_state(cache
, RPKI_CS_SYNC_START
);
241 rpki_schedule_next_retry(cache
);
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
);
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
);
258 case RPKI_CS_SYNC_START
:
259 /* Requesting for receive ROAs from a cache server. */
260 if (cache
->request_session_id
)
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
);
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
);
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. */
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
);
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
);
289 case RPKI_CS_ERROR_FATAL
:
290 /* Fatal protocol error occurred. */
291 rpki_force_restart_proto(cache
->p
);
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
);
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
);
307 case RPKI_CS_SHUTDOWN
:
308 bug("This isn't never really called.");
319 rpki_schedule_next_refresh(struct rpki_cache
*cache
)
321 btime t
= cache
->refresh_interval S
;
323 CACHE_DBG(cache
, "after %t s", t
);
324 tm_start(cache
->refresh_timer
, t
);
328 rpki_schedule_next_retry(struct rpki_cache
*cache
)
330 btime t
= cache
->retry_interval S
;
332 CACHE_DBG(cache
, "after %t s", t
);
333 tm_start(cache
->retry_timer
, t
);
337 rpki_schedule_next_expire_check(struct rpki_cache
*cache
)
339 /* A minimum time to wait is 1 second */
340 btime t
= cache
->last_update
+ cache
->expire_interval S
- current_time();
343 CACHE_DBG(cache
, "after %t s", t
);
344 tm_start(cache
->expire_timer
, t
);
348 rpki_stop_refresh_timer_event(struct rpki_cache
*cache
)
350 CACHE_DBG(cache
, "Stop");
351 tm_stop(cache
->refresh_timer
);
355 rpki_stop_retry_timer_event(struct rpki_cache
*cache
)
357 CACHE_DBG(cache
, "Stop");
358 tm_stop(cache
->retry_timer
);
362 rpki_stop_expire_timer_event(struct rpki_cache
*cache
)
364 CACHE_DBG(cache
, "Stop");
365 tm_stop(cache
->expire_timer
);
369 rpki_do_we_recv_prefix_pdu_in_last_seconds(struct rpki_cache
*cache
)
371 if (!cache
->last_rx_prefix
)
374 return ((current_time() - cache
->last_rx_prefix
) <= 2 S
);
378 * rpki_refresh_hook - control a scheduling of downloading data from cache server
379 * @tm: refresh timer with cache connection instance in data
381 * This function is periodically called during &ESTABLISHED or &SYNC* state
382 * cache connection. The first refresh schedule is invoked after receiving a
383 * |End of Data| PDU and has run by some &ERROR is occurred.
386 rpki_refresh_hook(timer
*tm
)
388 struct rpki_cache
*cache
= tm
->data
;
390 CACHE_DBG(cache
, "%s", rpki_cache_state_to_str(cache
->state
));
392 switch (cache
->state
)
394 case RPKI_CS_ESTABLISHED
:
395 rpki_cache_change_state(cache
, RPKI_CS_SYNC_START
);
398 case RPKI_CS_SYNC_START
:
399 /* We sent Serial/Reset Query in last refresh hook call
400 * and didn't receive Cache Response yet. It is probably
401 * troubles with network. */
402 case RPKI_CS_SYNC_RUNNING
:
403 /* We sent Serial/Reset Query in last refresh hook call
404 * and we got Cache Response but didn't get End-Of-Data yet.
405 * It could be a trouble with network or only too long synchronization. */
406 if (!rpki_do_we_recv_prefix_pdu_in_last_seconds(cache
))
408 CACHE_TRACE(D_EVENTS
, cache
, "Sync takes more time than refresh interval %us, resetting connection", cache
->refresh_interval
);
409 rpki_cache_change_state(cache
, RPKI_CS_ERROR_TRANSPORT
);
417 if (cache
->state
!= RPKI_CS_SHUTDOWN
&& cache
->state
!= RPKI_CS_ERROR_TRANSPORT
)
418 rpki_schedule_next_refresh(cache
);
420 rpki_stop_refresh_timer_event(cache
);
424 * rpki_retry_hook - control a scheduling of retrying connection to cache server
425 * @tm: retry timer with cache connection instance in data
427 * This function is periodically called during &ERROR* state cache connection.
428 * The first retry schedule is invoked after any &ERROR* state occurred and
429 * ends by reaching of &ESTABLISHED state again.
432 rpki_retry_hook(timer
*tm
)
434 struct rpki_cache
*cache
= tm
->data
;
436 CACHE_DBG(cache
, "%s", rpki_cache_state_to_str(cache
->state
));
438 switch (cache
->state
)
440 case RPKI_CS_ESTABLISHED
:
441 case RPKI_CS_SHUTDOWN
:
444 case RPKI_CS_CONNECTING
:
445 case RPKI_CS_SYNC_START
:
446 case RPKI_CS_SYNC_RUNNING
:
447 if (!rpki_do_we_recv_prefix_pdu_in_last_seconds(cache
))
449 /* We tried to establish a connection in last retry hook call and haven't done
450 * yet. It looks like troubles with network. We are aggressive here. */
451 CACHE_TRACE(D_EVENTS
, cache
, "Sync takes more time than retry interval %us, resetting connection.", cache
->retry_interval
);
452 rpki_cache_change_state(cache
, RPKI_CS_ERROR_TRANSPORT
);
457 rpki_cache_change_state(cache
, RPKI_CS_CONNECTING
);
461 if (cache
->state
!= RPKI_CS_ESTABLISHED
)
462 rpki_schedule_next_retry(cache
);
464 rpki_stop_retry_timer_event(cache
);
468 * rpki_expire_hook - control a expiration of ROA entries
469 * @tm: expire timer with cache connection instance in data
471 * This function is scheduled after received a |End of Data| PDU.
472 * A waiting interval is calculated dynamically by last update.
473 * If we reach an expiration time then we invoke a restarting
477 rpki_expire_hook(timer
*tm
)
479 struct rpki_cache
*cache
= tm
->data
;
481 if (!cache
->last_update
)
484 CACHE_DBG(cache
, "%s", rpki_cache_state_to_str(cache
->state
));
486 btime t
= cache
->last_update
+ cache
->expire_interval S
- current_time();
489 CACHE_TRACE(D_EVENTS
, cache
, "All ROAs expired");
490 rpki_force_restart_proto(cache
->p
);
494 CACHE_DBG(cache
, "Remains %t seconds to become ROAs obsolete", t
);
495 rpki_schedule_next_expire_check(cache
);
500 * rpki_check_refresh_interval - check validity of refresh interval value
501 * @seconds: suggested value
503 * This function validates value and should return |NULL|.
504 * If the check doesn't pass then returns error message.
507 rpki_check_refresh_interval(uint seconds
)
510 return "Minimum allowed refresh interval is 1 second";
512 return "Maximum allowed refresh interval is 86400 seconds";
517 * rpki_check_retry_interval - check validity of retry interval value
518 * @seconds: suggested value
520 * This function validates value and should return |NULL|.
521 * If the check doesn't pass then returns error message.
524 rpki_check_retry_interval(uint seconds
)
527 return "Minimum allowed retry interval is 1 second";
529 return "Maximum allowed retry interval is 7200 seconds";
534 * rpki_check_expire_interval - check validity of expire interval value
535 * @seconds: suggested value
537 * This function validates value and should return |NULL|.
538 * If the check doesn't pass then returns error message.
541 rpki_check_expire_interval(uint seconds
)
544 return "Minimum allowed expire interval is 600 seconds";
545 if (seconds
> 172800)
546 return "Maximum allowed expire interval is 172800 seconds";
555 static struct rpki_cache
*
556 rpki_init_cache(struct rpki_proto
*p
, struct rpki_config
*cf
)
558 pool
*pool
= rp_new(p
->p
.pool
, cf
->hostname
);
560 struct rpki_cache
*cache
= mb_allocz(pool
, sizeof(struct rpki_cache
));
565 cache
->state
= RPKI_CS_SHUTDOWN
;
566 cache
->request_session_id
= 1;
567 cache
->version
= RPKI_MAX_VERSION
;
569 cache
->refresh_interval
= cf
->refresh_interval
;
570 cache
->retry_interval
= cf
->retry_interval
;
571 cache
->expire_interval
= cf
->expire_interval
;
572 cache
->refresh_timer
= tm_new_init(pool
, &rpki_refresh_hook
, cache
, 0, 0);
573 cache
->retry_timer
= tm_new_init(pool
, &rpki_retry_hook
, cache
, 0, 0);
574 cache
->expire_timer
= tm_new_init(pool
, &rpki_expire_hook
, cache
, 0, 0);
576 cache
->tr_sock
= mb_allocz(pool
, sizeof(struct rpki_tr_sock
));
577 cache
->tr_sock
->cache
= cache
;
579 switch (cf
->tr_config
.type
)
581 case RPKI_TR_TCP
: rpki_tr_tcp_init(cache
->tr_sock
); break;
582 case RPKI_TR_SSH
: rpki_tr_ssh_init(cache
->tr_sock
); break;
585 CACHE_DBG(cache
, "Connection object created");
591 * rpki_get_cache_ident - give a text representation of cache server name
592 * @cache: RPKI connection instance
594 * The function converts cache connection into string.
597 rpki_get_cache_ident(struct rpki_cache
*cache
)
599 return rpki_tr_ident(cache
->tr_sock
);
603 rpki_open_connection(struct rpki_cache
*cache
)
605 CACHE_TRACE(D_EVENTS
, cache
, "Opening a connection");
607 if (rpki_tr_open(cache
->tr_sock
) == RPKI_TR_ERROR
)
609 rpki_cache_change_state(cache
, RPKI_CS_ERROR_TRANSPORT
);
610 return RPKI_TR_ERROR
;
613 return RPKI_TR_SUCCESS
;
617 rpki_close_connection(struct rpki_cache
*cache
)
619 CACHE_TRACE(D_EVENTS
, cache
, "Closing a connection");
620 rpki_tr_close(cache
->tr_sock
);
621 proto_notify_state(&cache
->p
->p
, PS_START
);
625 rpki_shutdown(struct proto
*P
)
627 struct rpki_proto
*p
= (void *) P
;
629 rpki_force_restart_proto(p
);
631 /* Protocol memory pool will be automatically freed */
637 * RPKI Reconfiguration
641 rpki_try_fast_reconnect(struct rpki_cache
*cache
)
643 if (cache
->state
== RPKI_CS_ESTABLISHED
)
645 rpki_cache_change_state(cache
, RPKI_CS_FAST_RECONNECT
);
646 return SUCCESSFUL_RECONF
;
653 * rpki_reconfigure_cache - a cache reconfiguration
654 * @p: RPKI protocol instance
655 * @cache: a cache connection
656 * @new: new RPKI configuration
657 * @old: old RPKI configuration
659 * This function reconfigures existing single cache server connection with new
660 * existing configuration. Generally, a change of time intervals could be
661 * reconfigured without restarting and all others changes requires a restart of
662 * protocol. Returns |NEED_TO_RESTART| or |SUCCESSFUL_RECONF|.
665 rpki_reconfigure_cache(struct rpki_proto
*p UNUSED
, struct rpki_cache
*cache
, struct rpki_config
*new, struct rpki_config
*old
)
667 u8 try_fast_reconnect
= 0;
669 if (strcmp(old
->hostname
, new->hostname
) != 0)
671 CACHE_TRACE(D_EVENTS
, cache
, "Cache server address changed to %s", new->hostname
);
675 if (old
->port
!= new->port
)
677 CACHE_TRACE(D_EVENTS
, cache
, "Cache server port changed to %u", new->port
);
681 if (old
->tr_config
.type
!= new->tr_config
.type
)
683 CACHE_TRACE(D_EVENTS
, cache
, "Transport type changed");
686 else if (new->tr_config
.type
== RPKI_TR_SSH
)
688 struct rpki_tr_ssh_config
*ssh_old
= (void *) old
->tr_config
.spec
;
689 struct rpki_tr_ssh_config
*ssh_new
= (void *) new->tr_config
.spec
;
690 if ((strcmp(ssh_old
->bird_private_key
, ssh_new
->bird_private_key
) != 0) ||
691 (strcmp(ssh_old
->cache_public_key
, ssh_new
->cache_public_key
) != 0) ||
692 (strcmp(ssh_old
->user
, ssh_new
->user
) != 0))
694 CACHE_TRACE(D_EVENTS
, cache
, "Settings of SSH transport configuration changed");
695 try_fast_reconnect
= 1;
699 #define TEST_INTERVAL(name, Name) \
700 if (cache->name##_interval != new->name##_interval || \
701 old->keep_##name##_interval != new->keep_##name##_interval) \
703 cache->name##_interval = new->name##_interval; \
704 CACHE_TRACE(D_EVENTS, cache, #Name " interval changed to %u seconds %s", cache->name##_interval, (new->keep_##name##_interval ? "and keep it" : "")); \
705 try_fast_reconnect = 1; \
707 TEST_INTERVAL(refresh
, Refresh
);
708 TEST_INTERVAL(retry
, Retry
);
709 TEST_INTERVAL(expire
, Expire
);
712 if (try_fast_reconnect
)
713 return rpki_try_fast_reconnect(cache
);
715 return SUCCESSFUL_RECONF
;
719 * rpki_reconfigure - a protocol reconfiguration hook
720 * @P: a protocol instance
721 * @CF: a new protocol configuration
723 * This function reconfigures whole protocol.
724 * It sets new protocol configuration into a protocol structure.
725 * Returns |NEED_TO_RESTART| or |SUCCESSFUL_RECONF|.
728 rpki_reconfigure(struct proto
*P
, struct proto_config
*CF
)
730 struct rpki_proto
*p
= (void *) P
;
731 struct rpki_config
*new = (void *) CF
;
732 struct rpki_config
*old
= (void *) p
->p
.cf
;
733 struct rpki_cache
*cache
= p
->cache
;
735 if (!proto_configure_channel(&p
->p
, &p
->roa4_channel
, proto_cf_find_channel(CF
, NET_ROA4
)) ||
736 !proto_configure_channel(&p
->p
, &p
->roa6_channel
, proto_cf_find_channel(CF
, NET_ROA6
)))
739 if (rpki_reconfigure_cache(p
, cache
, new, old
) != SUCCESSFUL_RECONF
)
742 return SUCCESSFUL_RECONF
;
750 static struct proto
*
751 rpki_init(struct proto_config
*CF
)
753 struct proto
*P
= proto_new(CF
);
754 struct rpki_proto
*p
= (void *) P
;
756 proto_configure_channel(&p
->p
, &p
->roa4_channel
, proto_cf_find_channel(CF
, NET_ROA4
));
757 proto_configure_channel(&p
->p
, &p
->roa6_channel
, proto_cf_find_channel(CF
, NET_ROA6
));
763 rpki_start(struct proto
*P
)
765 struct rpki_proto
*p
= (void *) P
;
766 struct rpki_config
*cf
= (void *) P
->cf
;
768 p
->cache
= rpki_init_cache(p
, cf
);
769 rpki_start_cache(p
->cache
);
775 rpki_get_status(struct proto
*P
, byte
*buf
)
777 struct rpki_proto
*p
= (struct rpki_proto
*) P
;
779 if (P
->proto_state
== PS_DOWN
)
786 bsprintf(buf
, "%s", rpki_cache_state_to_str(p
->cache
->state
));
788 bsprintf(buf
, "No cache server configured");
792 rpki_show_proto_info_timer(const char *name
, uint num
, timer
*t
)
795 cli_msg(-1006, " %-16s: %t/%u", name
, tm_remains(t
), num
);
797 cli_msg(-1006, " %-16s: ---", name
);
801 rpki_show_proto_info(struct proto
*P
)
803 struct rpki_proto
*p
= (struct rpki_proto
*) P
;
804 struct rpki_config
*cf
= (void *) p
->p
.cf
;
805 struct rpki_cache
*cache
= p
->cache
;
807 if (P
->proto_state
== PS_DOWN
)
812 const char *transport_name
= "---";
814 switch (cf
->tr_config
.type
)
816 case RPKI_TR_SSH
: transport_name
= "SSHv2"; break;
817 case RPKI_TR_TCP
: transport_name
= "Unprotected over TCP"; break;
820 cli_msg(-1006, " Cache server: %s", rpki_get_cache_ident(cache
));
821 cli_msg(-1006, " Status: %s", rpki_cache_state_to_str(cache
->state
));
822 cli_msg(-1006, " Transport: %s", transport_name
);
823 cli_msg(-1006, " Protocol version: %u", cache
->version
);
825 if (cache
->request_session_id
)
826 cli_msg(-1006, " Session ID: ---");
828 cli_msg(-1006, " Session ID: %u", cache
->session_id
);
830 if (cache
->last_update
)
832 cli_msg(-1006, " Serial number: %u", cache
->serial_num
);
833 cli_msg(-1006, " Last update: before %t s", current_time() - cache
->last_update
);
837 cli_msg(-1006, " Serial number: ---");
838 cli_msg(-1006, " Last update: ---");
841 rpki_show_proto_info_timer("Refresh timer", cache
->refresh_interval
, cache
->refresh_timer
);
842 rpki_show_proto_info_timer("Retry timer", cache
->retry_interval
, cache
->retry_timer
);
843 rpki_show_proto_info_timer("Expire timer", cache
->expire_interval
, cache
->expire_timer
);
846 channel_show_info(p
->roa4_channel
);
848 cli_msg(-1006, " No roa4 channel");
851 channel_show_info(p
->roa6_channel
);
853 cli_msg(-1006, " No roa6 channel");
859 * RPKI Protocol Configuration
863 * rpki_check_config - check and complete configuration of RPKI protocol
864 * @cf: RPKI configuration
866 * This function is called at the end of parsing RPKI protocol configuration.
869 rpki_check_config(struct rpki_config
*cf
)
871 /* Do not check templates at all */
872 if (cf
->c
.class == SYM_TEMPLATE
)
875 if (ipa_zero(cf
->ip
) && cf
->hostname
== NULL
)
876 cf_error("IP address or hostname of cache server must be set");
878 /* Set default transport type */
879 if (cf
->tr_config
.spec
== NULL
)
881 cf
->tr_config
.spec
= cfg_allocz(sizeof(struct rpki_tr_tcp_config
));
882 cf
->tr_config
.type
= RPKI_TR_TCP
;
887 /* Set default port numbers */
888 switch (cf
->tr_config
.type
)
891 cf
->port
= RPKI_SSH_PORT
;
894 cf
->port
= RPKI_TCP_PORT
;
900 rpki_postconfig(struct proto_config
*CF
)
902 /* Define default channel */
903 if (EMPTY_LIST(CF
->channels
))
904 channel_config_new(NULL
, net_label
[CF
->net_type
], CF
->net_type
, CF
);
908 rpki_copy_config(struct proto_config
*dest UNUSED
, struct proto_config
*src UNUSED
)
910 /* FIXME: Should copy transport */
913 struct protocol proto_rpki
= {
915 .template = "rpki%d",
916 .class = PROTOCOL_RPKI
,
917 .preference
= DEF_PREF_RPKI
,
918 .proto_size
= sizeof(struct rpki_proto
),
919 .config_size
= sizeof(struct rpki_config
),
922 .postconfig
= rpki_postconfig
,
923 .channel_mask
= (NB_ROA4
| NB_ROA6
),
924 .show_proto_info
= rpki_show_proto_info
,
925 .shutdown
= rpki_shutdown
,
926 .copy_config
= rpki_copy_config
,
927 .reconfigure
= rpki_reconfigure
,
928 .get_status
= rpki_get_status
,