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 .pref
= channel
->preference
,
126 .scope
= SCOPE_UNIVERSE
,
130 rta
*a
= rta_lookup(&a0
);
131 rte
*e
= rte_get_temp(a
, p
->p
.main_source
);
133 rte_update2(channel
, &pfxr
->n
, e
, e
->src
);
137 rpki_table_remove_roa(struct rpki_cache
*cache
, struct channel
*channel
, const net_addr_union
*pfxr
)
139 struct rpki_proto
*p
= cache
->p
;
140 rte_update2(channel
, &pfxr
->n
, NULL
, p
->p
.main_source
);
145 * RPKI Protocol Logic
148 static const char *str_cache_states
[] = {
149 [RPKI_CS_CONNECTING
] = "Connecting",
150 [RPKI_CS_ESTABLISHED
] = "Established",
151 [RPKI_CS_RESET
] = "Reseting",
152 [RPKI_CS_SYNC_START
] = "Sync-Start",
153 [RPKI_CS_SYNC_RUNNING
] = "Sync-Running",
154 [RPKI_CS_FAST_RECONNECT
] = "Fast-Reconnect",
155 [RPKI_CS_NO_INCR_UPDATE_AVAIL
]= "No-Increment-Update-Available",
156 [RPKI_CS_ERROR_NO_DATA_AVAIL
] = "Cache-Error-No-Data-Available",
157 [RPKI_CS_ERROR_FATAL
] = "Fatal-Protocol-Error",
158 [RPKI_CS_ERROR_TRANSPORT
] = "Transport-Error",
159 [RPKI_CS_SHUTDOWN
] = "Down"
163 * rpki_cache_state_to_str - give a text representation of cache state
164 * @state: A cache state
166 * The function converts logic cache state into string.
169 rpki_cache_state_to_str(enum rpki_cache_state state
)
171 return str_cache_states
[state
];
175 * rpki_start_cache - connect to a cache server
176 * @cache: RPKI connection instance
178 * This function is a high level method to kick up a connection to a cache server.
181 rpki_start_cache(struct rpki_cache
*cache
)
183 rpki_cache_change_state(cache
, RPKI_CS_CONNECTING
);
187 * rpki_force_restart_proto - force shutdown and start protocol again
188 * @p: RPKI protocol instance
190 * This function calls shutdown and frees all protocol resources as well.
191 * After calling this function should be no operations with protocol data,
192 * they could be freed already.
195 rpki_force_restart_proto(struct rpki_proto
*p
)
199 CACHE_DBG(p
->cache
, "Connection object destroying");
205 proto_notify_state(&p
->p
, PS_DOWN
);
209 * rpki_cache_change_state - check and change cache state
210 * @cache: RPKI cache instance
211 * @new_state: suggested new state
213 * This function makes transitions between internal states.
214 * It represents the core of logic management of RPKI protocol.
215 * Cannot transit into the same state as cache is in already.
218 rpki_cache_change_state(struct rpki_cache
*cache
, const enum rpki_cache_state new_state
)
220 const enum rpki_cache_state old_state
= cache
->state
;
222 if (old_state
== new_state
)
225 cache
->state
= new_state
;
226 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
));
230 case RPKI_CS_CONNECTING
:
232 sock
*sk
= cache
->tr_sock
->sk
;
234 if (sk
== NULL
|| sk
->fd
< 0)
235 rpki_open_connection(cache
);
237 rpki_cache_change_state(cache
, RPKI_CS_SYNC_START
);
239 rpki_schedule_next_retry(cache
);
243 case RPKI_CS_ESTABLISHED
:
244 rpki_schedule_next_refresh(cache
);
245 rpki_schedule_next_expire_check(cache
);
246 rpki_stop_retry_timer_event(cache
);
250 /* Resetting cache connection. */
251 cache
->request_session_id
= 1;
252 cache
->serial_num
= 0;
253 rpki_cache_change_state(cache
, RPKI_CS_SYNC_START
);
256 case RPKI_CS_SYNC_START
:
257 /* Requesting for receive ROAs from a cache server. */
258 if (cache
->request_session_id
)
260 /* Send request for Session ID */
261 if (rpki_send_reset_query(cache
) != RPKI_SUCCESS
)
262 rpki_cache_change_state(cache
, RPKI_CS_ERROR_TRANSPORT
);
266 /* We have already a session_id. So send a Serial Query and start an incremental sync */
267 if (rpki_send_serial_query(cache
) != RPKI_SUCCESS
)
268 rpki_cache_change_state(cache
, RPKI_CS_ERROR_TRANSPORT
);
272 case RPKI_CS_SYNC_RUNNING
:
273 /* The state between Cache Response and End of Data. Only waiting for
274 * receiving all IP Prefix PDUs and finally a End of Data PDU. */
277 case RPKI_CS_NO_INCR_UPDATE_AVAIL
:
278 /* Server was unable to answer the last Serial Query and sent Cache Reset. */
279 case RPKI_CS_ERROR_NO_DATA_AVAIL
:
280 /* No validation records are available on the cache server. */
282 if (old_state
== RPKI_CS_ESTABLISHED
)
283 rpki_cache_change_state(cache
, RPKI_CS_RESET
);
285 rpki_schedule_next_retry(cache
);
288 case RPKI_CS_ERROR_FATAL
:
289 /* Fatal protocol error occurred. */
290 rpki_force_restart_proto(cache
->p
);
293 case RPKI_CS_ERROR_TRANSPORT
:
294 /* Error on the transport socket occurred. */
295 rpki_close_connection(cache
);
296 rpki_schedule_next_retry(cache
);
297 rpki_stop_refresh_timer_event(cache
);
298 cache
->request_session_id
= 1;
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_sync_is_stuck(struct rpki_cache
*cache
)
371 return !sk_rx_ready(cache
->tr_sock
->sk
) && (
372 !cache
->last_rx_prefix
|| (current_time() - cache
->last_rx_prefix
> 10 S
)
377 * rpki_refresh_hook - control a scheduling of downloading data from cache server
378 * @tm: refresh timer with cache connection instance in data
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.
385 rpki_refresh_hook(timer
*tm
)
387 struct rpki_cache
*cache
= tm
->data
;
389 CACHE_DBG(cache
, "%s", rpki_cache_state_to_str(cache
->state
));
391 switch (cache
->state
)
393 case RPKI_CS_ESTABLISHED
:
394 rpki_cache_change_state(cache
, RPKI_CS_SYNC_START
);
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_sync_is_stuck(cache
))
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
);
416 if (cache
->state
!= RPKI_CS_SHUTDOWN
&& cache
->state
!= RPKI_CS_ERROR_TRANSPORT
)
417 rpki_schedule_next_refresh(cache
);
419 rpki_stop_refresh_timer_event(cache
);
423 * rpki_retry_hook - control a scheduling of retrying connection to cache server
424 * @tm: retry timer with cache connection instance in data
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.
431 rpki_retry_hook(timer
*tm
)
433 struct rpki_cache
*cache
= tm
->data
;
435 CACHE_DBG(cache
, "%s", rpki_cache_state_to_str(cache
->state
));
437 switch (cache
->state
)
439 case RPKI_CS_ESTABLISHED
:
440 case RPKI_CS_SHUTDOWN
:
443 case RPKI_CS_CONNECTING
:
444 case RPKI_CS_SYNC_START
:
445 case RPKI_CS_SYNC_RUNNING
:
446 if (rpki_sync_is_stuck(cache
))
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
);
455 case RPKI_CS_NO_INCR_UPDATE_AVAIL
:
456 case RPKI_CS_ERROR_NO_DATA_AVAIL
:
457 rpki_cache_change_state(cache
, RPKI_CS_RESET
);
461 rpki_cache_change_state(cache
, RPKI_CS_CONNECTING
);
465 if (cache
->state
!= RPKI_CS_ESTABLISHED
)
466 rpki_schedule_next_retry(cache
);
468 rpki_stop_retry_timer_event(cache
);
472 * rpki_expire_hook - control a expiration of ROA entries
473 * @tm: expire timer with cache connection instance in data
475 * This function is scheduled after received a |End of Data| PDU.
476 * A waiting interval is calculated dynamically by last update.
477 * If we reach an expiration time then we invoke a restarting
481 rpki_expire_hook(timer
*tm
)
483 struct rpki_cache
*cache
= tm
->data
;
485 if (!cache
->last_update
)
488 CACHE_DBG(cache
, "%s", rpki_cache_state_to_str(cache
->state
));
490 btime t
= cache
->last_update
+ cache
->expire_interval S
- current_time();
493 CACHE_TRACE(D_EVENTS
, cache
, "All ROAs expired");
494 rpki_force_restart_proto(cache
->p
);
498 CACHE_DBG(cache
, "Remains %t seconds to become ROAs obsolete", t
);
499 rpki_schedule_next_expire_check(cache
);
504 * rpki_check_refresh_interval - check validity of refresh interval value
505 * @seconds: suggested value
507 * This function validates value and should return |NULL|.
508 * If the check doesn't pass then returns error message.
511 rpki_check_refresh_interval(uint seconds
)
514 return "Minimum allowed refresh interval is 1 second";
516 return "Maximum allowed refresh interval is 86400 seconds";
521 * rpki_check_retry_interval - check validity of retry interval value
522 * @seconds: suggested value
524 * This function validates value and should return |NULL|.
525 * If the check doesn't pass then returns error message.
528 rpki_check_retry_interval(uint seconds
)
531 return "Minimum allowed retry interval is 1 second";
533 return "Maximum allowed retry interval is 7200 seconds";
538 * rpki_check_expire_interval - check validity of expire interval value
539 * @seconds: suggested value
541 * This function validates value and should return |NULL|.
542 * If the check doesn't pass then returns error message.
545 rpki_check_expire_interval(uint seconds
)
548 return "Minimum allowed expire interval is 600 seconds";
549 if (seconds
> 172800)
550 return "Maximum allowed expire interval is 172800 seconds";
559 static struct rpki_cache
*
560 rpki_init_cache(struct rpki_proto
*p
, struct rpki_config
*cf
)
562 pool
*pool
= rp_new(p
->p
.pool
, cf
->hostname
);
564 struct rpki_cache
*cache
= mb_allocz(pool
, sizeof(struct rpki_cache
));
569 cache
->state
= RPKI_CS_SHUTDOWN
;
570 cache
->request_session_id
= 1;
571 cache
->version
= RPKI_MAX_VERSION
;
573 cache
->refresh_interval
= cf
->refresh_interval
;
574 cache
->retry_interval
= cf
->retry_interval
;
575 cache
->expire_interval
= cf
->expire_interval
;
576 cache
->refresh_timer
= tm_new_init(pool
, &rpki_refresh_hook
, cache
, 0, 0);
577 cache
->retry_timer
= tm_new_init(pool
, &rpki_retry_hook
, cache
, 0, 0);
578 cache
->expire_timer
= tm_new_init(pool
, &rpki_expire_hook
, cache
, 0, 0);
580 cache
->tr_sock
= mb_allocz(pool
, sizeof(struct rpki_tr_sock
));
581 cache
->tr_sock
->cache
= cache
;
583 switch (cf
->tr_config
.type
)
585 case RPKI_TR_TCP
: rpki_tr_tcp_init(cache
->tr_sock
); break;
587 case RPKI_TR_SSH
: rpki_tr_ssh_init(cache
->tr_sock
); break;
591 CACHE_DBG(cache
, "Connection object created");
597 * rpki_get_cache_ident - give a text representation of cache server name
598 * @cache: RPKI connection instance
600 * The function converts cache connection into string.
603 rpki_get_cache_ident(struct rpki_cache
*cache
)
605 return rpki_tr_ident(cache
->tr_sock
);
609 rpki_open_connection(struct rpki_cache
*cache
)
611 CACHE_TRACE(D_EVENTS
, cache
, "Opening a connection");
613 if (rpki_tr_open(cache
->tr_sock
) == RPKI_TR_ERROR
)
615 rpki_cache_change_state(cache
, RPKI_CS_ERROR_TRANSPORT
);
616 return RPKI_TR_ERROR
;
619 return RPKI_TR_SUCCESS
;
623 rpki_close_connection(struct rpki_cache
*cache
)
625 CACHE_TRACE(D_EVENTS
, cache
, "Closing a connection");
626 rpki_tr_close(cache
->tr_sock
);
627 proto_notify_state(&cache
->p
->p
, PS_START
);
631 rpki_shutdown(struct proto
*P
)
633 struct rpki_proto
*p
= (void *) P
;
635 rpki_force_restart_proto(p
);
637 /* Protocol memory pool will be automatically freed */
643 * RPKI Reconfiguration
647 * rpki_reconfigure_cache - a cache reconfiguration
648 * @p: RPKI protocol instance
649 * @cache: a cache connection
650 * @new: new RPKI configuration
651 * @old: old RPKI configuration
653 * This function reconfigures existing single cache server connection with new
654 * existing configuration. Generally, a change of time intervals could be
655 * reconfigured without restarting and all others changes requires a restart of
656 * protocol. Returns |NEED_TO_RESTART| or |SUCCESSFUL_RECONF|.
659 rpki_reconfigure_cache(struct rpki_proto
*p UNUSED
, struct rpki_cache
*cache
, struct rpki_config
*new, struct rpki_config
*old
)
662 u8 try_fast_reconnect
= 0;
664 if (strcmp(old
->hostname
, new->hostname
) != 0)
666 CACHE_TRACE(D_EVENTS
, cache
, "Cache server address changed to %s", new->hostname
);
670 if (old
->port
!= new->port
)
672 CACHE_TRACE(D_EVENTS
, cache
, "Cache server port changed to %u", new->port
);
676 if (old
->tr_config
.type
!= new->tr_config
.type
)
678 CACHE_TRACE(D_EVENTS
, cache
, "Transport type changed");
682 if (old
->ignore_max_length
!= new->ignore_max_length
)
684 CACHE_TRACE(D_EVENTS
, cache
, "Ignore max length changed");
689 else if (new->tr_config
.type
== RPKI_TR_SSH
)
691 struct rpki_tr_ssh_config
*ssh_old
= (void *) old
->tr_config
.spec
;
692 struct rpki_tr_ssh_config
*ssh_new
= (void *) new->tr_config
.spec
;
693 if (bstrcmp(ssh_old
->bird_private_key
, ssh_new
->bird_private_key
) ||
694 bstrcmp(ssh_old
->cache_public_key
, ssh_new
->cache_public_key
) ||
695 bstrcmp(ssh_old
->user
, ssh_new
->user
))
697 CACHE_TRACE(D_EVENTS
, cache
, "Settings of SSH transport configuration changed");
698 try_fast_reconnect
= 1;
703 #define TEST_INTERVAL(name, Name) \
704 if (old->name##_interval != new->name##_interval || \
705 old->keep_##name##_interval != new->keep_##name##_interval) \
707 cache->name##_interval = new->name##_interval; \
708 CACHE_TRACE(D_EVENTS, cache, #Name " interval changed to %u seconds %s", cache->name##_interval, (new->keep_##name##_interval ? "and keep it" : "")); \
709 try_fast_reconnect = 1; \
711 TEST_INTERVAL(refresh
, Refresh
);
712 TEST_INTERVAL(retry
, Retry
);
713 TEST_INTERVAL(expire
, Expire
);
716 if (try_reset
|| try_fast_reconnect
)
718 if (cache
->state
!= RPKI_CS_ESTABLISHED
)
721 if (try_reset
&& !try_fast_reconnect
)
722 rpki_cache_change_state(cache
, RPKI_CS_RESET
);
724 if (try_fast_reconnect
)
728 /* Force reset during reconnect */
729 cache
->request_session_id
= 1;
730 cache
->serial_num
= 0;
733 rpki_cache_change_state(cache
, RPKI_CS_FAST_RECONNECT
);
737 return SUCCESSFUL_RECONF
;
741 * rpki_reconfigure - a protocol reconfiguration hook
742 * @P: a protocol instance
743 * @CF: a new protocol configuration
745 * This function reconfigures whole protocol.
746 * It sets new protocol configuration into a protocol structure.
747 * Returns |NEED_TO_RESTART| or |SUCCESSFUL_RECONF|.
750 rpki_reconfigure(struct proto
*P
, struct proto_config
*CF
)
752 struct rpki_proto
*p
= (void *) P
;
753 struct rpki_config
*new = (void *) CF
;
754 struct rpki_config
*old
= (void *) p
->p
.cf
;
755 struct rpki_cache
*cache
= p
->cache
;
757 if (!proto_configure_channel(&p
->p
, &p
->roa4_channel
, proto_cf_find_channel(CF
, NET_ROA4
)) ||
758 !proto_configure_channel(&p
->p
, &p
->roa6_channel
, proto_cf_find_channel(CF
, NET_ROA6
)))
761 if (rpki_reconfigure_cache(p
, cache
, new, old
) != SUCCESSFUL_RECONF
)
764 return SUCCESSFUL_RECONF
;
772 static struct proto
*
773 rpki_init(struct proto_config
*CF
)
775 struct proto
*P
= proto_new(CF
);
776 struct rpki_proto
*p
= (void *) P
;
778 proto_configure_channel(&p
->p
, &p
->roa4_channel
, proto_cf_find_channel(CF
, NET_ROA4
));
779 proto_configure_channel(&p
->p
, &p
->roa6_channel
, proto_cf_find_channel(CF
, NET_ROA6
));
785 rpki_start(struct proto
*P
)
787 struct rpki_proto
*p
= (void *) P
;
788 struct rpki_config
*cf
= (void *) P
->cf
;
790 p
->cache
= rpki_init_cache(p
, cf
);
791 rpki_start_cache(p
->cache
);
797 rpki_get_status(struct proto
*P
, byte
*buf
)
799 struct rpki_proto
*p
= (struct rpki_proto
*) P
;
801 if (P
->proto_state
== PS_DOWN
)
808 bsprintf(buf
, "%s", rpki_cache_state_to_str(p
->cache
->state
));
810 bsprintf(buf
, "No cache server configured");
814 rpki_show_proto_info_timer(const char *name
, uint num
, timer
*t
)
817 cli_msg(-1006, " %-16s: %t/%u", name
, tm_remains(t
), num
);
819 cli_msg(-1006, " %-16s: ---", name
);
823 rpki_show_proto_info(struct proto
*P
)
825 struct rpki_proto
*p
= (struct rpki_proto
*) P
;
826 struct rpki_config
*cf
= (void *) p
->p
.cf
;
827 struct rpki_cache
*cache
= p
->cache
;
829 if (P
->proto_state
== PS_DOWN
)
834 const char *transport_name
= "---";
835 uint default_port
= 0;
837 switch (cf
->tr_config
.type
)
841 transport_name
= "SSHv2";
842 default_port
= RPKI_SSH_PORT
;
846 transport_name
= "Unprotected over TCP";
847 default_port
= RPKI_TCP_PORT
;
851 cli_msg(-1006, " Cache server: %s", cf
->hostname
);
853 if (cf
->port
!= default_port
)
854 cli_msg(-1006, " Cache port: %u", cf
->port
);
856 cli_msg(-1006, " Status: %s", rpki_cache_state_to_str(cache
->state
));
857 cli_msg(-1006, " Transport: %s", transport_name
);
858 cli_msg(-1006, " Protocol version: %u", cache
->version
);
860 if (cache
->request_session_id
)
861 cli_msg(-1006, " Session ID: ---");
863 cli_msg(-1006, " Session ID: %u", cache
->session_id
);
865 if (cache
->last_update
)
867 cli_msg(-1006, " Serial number: %u", cache
->serial_num
);
868 cli_msg(-1006, " Last update: before %t s", current_time() - cache
->last_update
);
872 cli_msg(-1006, " Serial number: ---");
873 cli_msg(-1006, " Last update: ---");
876 rpki_show_proto_info_timer("Refresh timer", cache
->refresh_interval
, cache
->refresh_timer
);
877 rpki_show_proto_info_timer("Retry timer", cache
->retry_interval
, cache
->retry_timer
);
878 rpki_show_proto_info_timer("Expire timer", cache
->expire_interval
, cache
->expire_timer
);
881 channel_show_info(p
->roa4_channel
);
883 cli_msg(-1006, " No roa4 channel");
886 channel_show_info(p
->roa6_channel
);
888 cli_msg(-1006, " No roa6 channel");
894 * RPKI Protocol Configuration
898 * rpki_check_config - check and complete configuration of RPKI protocol
899 * @cf: RPKI configuration
901 * This function is called at the end of parsing RPKI protocol configuration.
904 rpki_check_config(struct rpki_config
*cf
)
906 /* Do not check templates at all */
907 if (cf
->c
.class == SYM_TEMPLATE
)
910 if (ipa_zero(cf
->ip
) && cf
->hostname
== NULL
)
911 cf_error("IP address or hostname of cache server must be set");
913 /* Set default transport type */
914 if (cf
->tr_config
.spec
== NULL
)
916 cf
->tr_config
.spec
= cfg_allocz(sizeof(struct rpki_tr_tcp_config
));
917 cf
->tr_config
.type
= RPKI_TR_TCP
;
922 /* Set default port numbers */
923 switch (cf
->tr_config
.type
)
927 cf
->port
= RPKI_SSH_PORT
;
931 cf
->port
= RPKI_TCP_PORT
;
937 rpki_postconfig(struct proto_config
*CF
)
939 /* Define default channel */
940 if (EMPTY_LIST(CF
->channels
))
941 cf_error("Channel not specified");
945 rpki_copy_config(struct proto_config
*dest UNUSED
, struct proto_config
*src UNUSED
)
947 /* FIXME: Should copy transport */
950 struct protocol proto_rpki
= {
952 .template = "rpki%d",
953 .class = PROTOCOL_RPKI
,
954 .preference
= DEF_PREF_RPKI
,
955 .proto_size
= sizeof(struct rpki_proto
),
956 .config_size
= sizeof(struct rpki_config
),
959 .postconfig
= rpki_postconfig
,
960 .channel_mask
= (NB_ROA4
| NB_ROA6
),
961 .show_proto_info
= rpki_show_proto_info
,
962 .shutdown
= rpki_shutdown
,
963 .copy_config
= rpki_copy_config
,
964 .reconfigure
= rpki_reconfigure
,
965 .get_status
= rpki_get_status
,
971 proto_build(&proto_rpki
);