diff options
Diffstat (limited to 'sys/net/if_wg.c')
-rw-r--r-- | sys/net/if_wg.c | 335 |
1 files changed, 155 insertions, 180 deletions
diff --git a/sys/net/if_wg.c b/sys/net/if_wg.c index ae29bf4d49c..b1dd3dd7c19 100644 --- a/sys/net/if_wg.c +++ b/sys/net/if_wg.c @@ -67,10 +67,6 @@ #define DPRINTF(sc, str, ...) do { if (ISSET((sc)->sc_if.if_flags, IFF_DEBUG))\ printf("%s: " str, (sc)->sc_if.if_xname, ##__VA_ARGS__); } while (0) -#define CONTAINER_OF(ptr, type, member) ({ \ - const __typeof( ((type *)0)->member ) *__mptr = (ptr); \ - (type *)( (char *)__mptr - offsetof(type,member) );}) - /* First byte indicating packet type on the wire */ #define WG_PKT_INITIATION htole32(1) #define WG_PKT_RESPONSE htole32(2) @@ -129,21 +125,6 @@ struct wg_endpoint { } e_local; }; -struct wg_timers { - int t_disabled; - int t_need_another_keepalive; - uint16_t t_persistent_keepalive_interval; - struct timeout t_new_handshake; - struct timeout t_send_keepalive; - struct timeout t_retry_handshake; - struct timeout t_zero_key_material; - struct timeout t_persistent_keepalive; - - struct mutex t_handshake_mtx; - struct timespec t_handshake_complete; /* nanotime */ - int t_handshake_retries; -}; - struct wg_aip { struct art_node a_node; LIST_ENTRY(wg_aip) a_entry; @@ -184,7 +165,6 @@ struct wg_peer { struct noise_remote *p_remote; struct cookie_maker p_cookie; - struct wg_timers p_timers; struct mutex p_counters_mtx; uint64_t p_counters_tx; @@ -200,6 +180,19 @@ struct wg_peer { struct wg_queue p_encap_serial; struct wg_queue p_decap_serial; + int p_enabled; + int p_need_another_keepalive; + uint16_t p_persistent_keepalive_interval; + struct timeout p_new_handshake; + struct timeout p_send_keepalive; + struct timeout p_retry_handshake; + struct timeout p_zero_key_material; + struct timeout p_persistent_keepalive; + + struct mutex p_handshake_mtx; + struct timespec p_handshake_complete; /* nanotime */ + int p_handshake_retries; + LIST_HEAD(,wg_aip) p_aip; SLIST_ENTRY(wg_peer) p_start_list; @@ -266,27 +259,24 @@ void wg_send_buf(struct wg_softc *, struct wg_endpoint *, uint8_t *, struct wg_tag * wg_tag_get(struct mbuf *); -void wg_timers_init(struct wg_timers *); -void wg_timers_enable(struct wg_timers *); -void wg_timers_disable(struct wg_timers *); -void wg_timers_set_persistent_keepalive(struct wg_timers *, uint16_t); -int wg_timers_get_persistent_keepalive(struct wg_timers *, uint16_t *); -void wg_timers_get_last_handshake(struct wg_timers *, struct timespec *); -int wg_timers_expired_handshake_last_sent(struct wg_timers *); -int wg_timers_check_handshake_last_sent(struct wg_timers *); - -void wg_timers_event_data_sent(struct wg_timers *); -void wg_timers_event_data_received(struct wg_timers *); -void wg_timers_event_any_authenticated_packet_sent(struct wg_timers *); -void wg_timers_event_any_authenticated_packet_received(struct wg_timers *); -void wg_timers_event_any_authenticated_packet_traversal(struct wg_timers *); -void wg_timers_event_handshake_initiated(struct wg_timers *); -void wg_timers_event_handshake_responded(struct wg_timers *); -void wg_timers_event_handshake_complete(struct wg_timers *); -void wg_timers_event_session_derived(struct wg_timers *); -void wg_timers_event_want_initiation(struct wg_timers *); - -void wg_timers_run_send_initiation(void *, int); +void wg_timers_enable(struct wg_peer *); +void wg_timers_disable(struct wg_peer *); +void wg_timers_set_persistent_keepalive(struct wg_peer *, uint16_t); +int wg_timers_get_persistent_keepalive(struct wg_peer *, uint16_t *); +void wg_timers_get_last_handshake(struct wg_peer *, struct timespec *); + +void wg_timers_event_data_sent(struct wg_peer *); +void wg_timers_event_data_received(struct wg_peer *); +void wg_timers_event_any_authenticated_packet_sent(struct wg_peer *); +void wg_timers_event_any_authenticated_packet_received(struct wg_peer *); +void wg_timers_event_any_authenticated_packet_traversal(struct wg_peer *); +void wg_timers_event_handshake_initiated(struct wg_peer *); +void wg_timers_event_handshake_responded(struct wg_peer *); +void wg_timers_event_handshake_complete(struct wg_peer *); +void wg_timers_event_session_derived(struct wg_peer *); +void wg_timers_event_want_initiation(struct wg_peer *); + +void wg_timers_run_send_initiation(struct wg_peer *, int); void wg_timers_run_retry_handshake(void *); void wg_timers_run_send_keepalive(void *); void wg_timers_run_new_handshake(void *); @@ -361,7 +351,6 @@ wg_peer_create(struct wg_softc *sc, uint8_t public[WG_KEY_SIZE], peer->p_sc = sc; cookie_maker_init(&peer->p_cookie, public); - wg_timers_init(&peer->p_timers); mtx_init(&peer->p_counters_mtx, IPL_NET); peer->p_counters_tx = 0; @@ -377,6 +366,24 @@ wg_peer_create(struct wg_softc *sc, uint8_t public[WG_KEY_SIZE], wg_queue_init(&peer->p_encap_serial); wg_queue_init(&peer->p_decap_serial); + peer->p_enabled = ISSET(sc->sc_if.if_flags, IFF_RUNNING); + peer->p_need_another_keepalive = 0; + peer->p_persistent_keepalive_interval = 0; + timeout_set_flags(&peer->p_new_handshake, + wg_timers_run_new_handshake, peer, TIMEOUT_PROC); + timeout_set_flags(&peer->p_send_keepalive, + wg_timers_run_send_keepalive, peer, TIMEOUT_PROC); + timeout_set_flags(&peer->p_retry_handshake, + wg_timers_run_retry_handshake, peer, TIMEOUT_PROC); + timeout_set_flags(&peer->p_persistent_keepalive, + wg_timers_run_persistent_keepalive, peer, TIMEOUT_PROC); + timeout_set_flags(&peer->p_zero_key_material, + wg_timers_run_zero_key_material, peer, TIMEOUT_PROC); + + mtx_init(&peer->p_handshake_mtx, IPL_NET); + bzero(&peer->p_handshake_complete, sizeof(peer->p_handshake_complete)); + peer->p_handshake_retries = 0; + LIST_INIT(&peer->p_aip); peer->p_start_onlist = 0; @@ -415,7 +422,7 @@ wg_peer_destroy(struct wg_peer *peer) LIST_FOREACH_SAFE(aip, &peer->p_aip, a_entry, taip) wg_aip_remove(sc, peer, &aip->a_data); - wg_timers_disable(&peer->p_timers); + wg_timers_disable(peer); noise_remote_free(peer->p_remote, wg_peer_free); DPRINTF(sc, "Peer %llu destroyed\n", peer->p_id); @@ -810,239 +817,215 @@ wg_tag_get(struct mbuf *m) * tx: data failed, old keys expiring */ void -wg_timers_init(struct wg_timers *t) -{ - bzero(t, sizeof(*t)); - mtx_init(&t->t_handshake_mtx, IPL_NET); - - timeout_set_flags(&t->t_new_handshake, - wg_timers_run_new_handshake, t, TIMEOUT_PROC); - timeout_set_flags(&t->t_send_keepalive, - wg_timers_run_send_keepalive, t, TIMEOUT_PROC); - timeout_set_flags(&t->t_retry_handshake, - wg_timers_run_retry_handshake, t, TIMEOUT_PROC); - timeout_set_flags(&t->t_persistent_keepalive, - wg_timers_run_persistent_keepalive, t, TIMEOUT_PROC); - timeout_set_flags(&t->t_zero_key_material, - wg_timers_run_zero_key_material, t, TIMEOUT_PROC); -} - -void -wg_timers_enable(struct wg_timers *t) +wg_timers_enable(struct wg_peer *peer) { - WRITE_ONCE(t->t_disabled, 0); - wg_timers_run_persistent_keepalive(t); + WRITE_ONCE(peer->p_enabled, 1); + wg_timers_run_persistent_keepalive(peer); } void -wg_timers_disable(struct wg_timers *t) +wg_timers_disable(struct wg_peer *peer) { - WRITE_ONCE(t->t_disabled, 1); + WRITE_ONCE(peer->p_enabled, 0); smr_barrier(); - WRITE_ONCE(t->t_need_another_keepalive, 0); + WRITE_ONCE(peer->p_need_another_keepalive, 0); - timeout_del_barrier(&t->t_new_handshake); - timeout_del_barrier(&t->t_send_keepalive); - timeout_del_barrier(&t->t_retry_handshake); - timeout_del_barrier(&t->t_persistent_keepalive); - timeout_del_barrier(&t->t_zero_key_material); + timeout_del_barrier(&peer->p_new_handshake); + timeout_del_barrier(&peer->p_send_keepalive); + timeout_del_barrier(&peer->p_retry_handshake); + timeout_del_barrier(&peer->p_persistent_keepalive); + timeout_del_barrier(&peer->p_zero_key_material); } void -wg_timers_set_persistent_keepalive(struct wg_timers *t, uint16_t interval) +wg_timers_set_persistent_keepalive(struct wg_peer *peer, uint16_t interval) { - if (interval != t->t_persistent_keepalive_interval) { - WRITE_ONCE(t->t_persistent_keepalive_interval, interval); + if (interval != peer->p_persistent_keepalive_interval) { + WRITE_ONCE(peer->p_persistent_keepalive_interval, interval); smr_read_enter(); - if (!t->t_disabled) - wg_timers_run_persistent_keepalive(t); + if (peer->p_enabled) + wg_timers_run_persistent_keepalive(peer); smr_read_leave(); } } int -wg_timers_get_persistent_keepalive(struct wg_timers *t, uint16_t *interval) +wg_timers_get_persistent_keepalive(struct wg_peer *peer, uint16_t *interval) { - *interval = t->t_persistent_keepalive_interval; + *interval = peer->p_persistent_keepalive_interval; return *interval > 0 ? 0 : ENOENT; } void -wg_timers_get_last_handshake(struct wg_timers *t, struct timespec *time) +wg_timers_get_last_handshake(struct wg_peer *peer, struct timespec *time) { - mtx_enter(&t->t_handshake_mtx); - *time = t->t_handshake_complete; - mtx_leave(&t->t_handshake_mtx); + mtx_enter(&peer->p_handshake_mtx); + *time = peer->p_handshake_complete; + mtx_leave(&peer->p_handshake_mtx); } void -wg_timers_event_data_sent(struct wg_timers *t) +wg_timers_event_data_sent(struct wg_peer *peer) { int msecs = NEW_HANDSHAKE_TIMEOUT * 1000; msecs += arc4random_uniform(REKEY_TIMEOUT_JITTER); smr_read_enter(); - if (!t->t_disabled && !timeout_pending(&t->t_new_handshake)) - timeout_add_msec(&t->t_new_handshake, msecs); + if (peer->p_enabled && !timeout_pending(&peer->p_new_handshake)) + timeout_add_msec(&peer->p_new_handshake, msecs); smr_read_leave(); } void -wg_timers_event_data_received(struct wg_timers *t) +wg_timers_event_data_received(struct wg_peer *peer) { smr_read_enter(); - if (!t->t_disabled) { - if (!timeout_pending(&t->t_send_keepalive)) - timeout_add_sec(&t->t_send_keepalive, + if (peer->p_enabled) { + if (!timeout_pending(&peer->p_send_keepalive)) + timeout_add_sec(&peer->p_send_keepalive, KEEPALIVE_TIMEOUT); else - WRITE_ONCE(t->t_need_another_keepalive, 1); + WRITE_ONCE(peer->p_need_another_keepalive, 1); } smr_read_leave(); } void -wg_timers_event_any_authenticated_packet_sent(struct wg_timers *t) +wg_timers_event_any_authenticated_packet_sent(struct wg_peer *peer) { - timeout_del(&t->t_send_keepalive); + timeout_del(&peer->p_send_keepalive); } void -wg_timers_event_any_authenticated_packet_received(struct wg_timers *t) +wg_timers_event_any_authenticated_packet_received(struct wg_peer *peer) { - timeout_del(&t->t_new_handshake); + timeout_del(&peer->p_new_handshake); } void -wg_timers_event_any_authenticated_packet_traversal(struct wg_timers *t) +wg_timers_event_any_authenticated_packet_traversal(struct wg_peer *peer) { uint16_t interval; smr_read_enter(); - interval = READ_ONCE(t->t_persistent_keepalive_interval); - if (!t->t_disabled && interval > 0) - timeout_add_sec(&t->t_persistent_keepalive, interval); + interval = READ_ONCE(peer->p_persistent_keepalive_interval); + if (peer->p_enabled && interval > 0) + timeout_add_sec(&peer->p_persistent_keepalive, interval); smr_read_leave(); } void -wg_timers_event_handshake_initiated(struct wg_timers *t) +wg_timers_event_handshake_initiated(struct wg_peer *peer) { int msecs = REKEY_TIMEOUT * 1000; msecs += arc4random_uniform(REKEY_TIMEOUT_JITTER); smr_read_enter(); - if (!t->t_disabled) - timeout_add_msec(&t->t_retry_handshake, msecs); + if (peer->p_enabled) + timeout_add_msec(&peer->p_retry_handshake, msecs); smr_read_leave(); } void -wg_timers_event_handshake_complete(struct wg_timers *t) +wg_timers_event_handshake_complete(struct wg_peer *peer) { smr_read_enter(); - if (!t->t_disabled) { - mtx_enter(&t->t_handshake_mtx); - timeout_del(&t->t_retry_handshake); - t->t_handshake_retries = 0; - getnanotime(&t->t_handshake_complete); - mtx_leave(&t->t_handshake_mtx); - wg_timers_run_send_keepalive(t); + if (peer->p_enabled) { + mtx_enter(&peer->p_handshake_mtx); + timeout_del(&peer->p_retry_handshake); + peer->p_handshake_retries = 0; + getnanotime(&peer->p_handshake_complete); + mtx_leave(&peer->p_handshake_mtx); + wg_timers_run_send_keepalive(peer); } smr_read_leave(); } void -wg_timers_event_session_derived(struct wg_timers *t) +wg_timers_event_session_derived(struct wg_peer *peer) { smr_read_enter(); - if (!t->t_disabled) - timeout_add_sec(&t->t_zero_key_material, REJECT_AFTER_TIME * 3); + if (peer->p_enabled) + timeout_add_sec(&peer->p_zero_key_material, REJECT_AFTER_TIME * 3); smr_read_leave(); } void -wg_timers_event_want_initiation(struct wg_timers *t) +wg_timers_event_want_initiation(struct wg_peer *peer) { smr_read_enter(); - if (!t->t_disabled) - wg_timers_run_send_initiation(t, 0); + if (peer->p_enabled) + wg_timers_run_send_initiation(peer, 0); smr_read_leave(); } void -wg_timers_run_send_initiation(void *_t, int is_retry) +wg_timers_run_send_initiation(struct wg_peer *peer, int is_retry) { - struct wg_timers *t = _t; - struct wg_peer *peer = CONTAINER_OF(t, struct wg_peer, p_timers); if (!is_retry) - t->t_handshake_retries = 0; + peer->p_handshake_retries = 0; if (noise_remote_initiation_expired(peer->p_remote) == ETIMEDOUT) wg_send_initiation(peer); } void -wg_timers_run_retry_handshake(void *_t) +wg_timers_run_retry_handshake(void *_peer) { - struct wg_timers *t = _t; - struct wg_peer *peer = CONTAINER_OF(t, struct wg_peer, p_timers); + struct wg_peer *peer = _peer; - mtx_enter(&t->t_handshake_mtx); - if (t->t_handshake_retries <= MAX_TIMER_HANDSHAKES) { - t->t_handshake_retries++; - mtx_leave(&t->t_handshake_mtx); + mtx_enter(&peer->p_handshake_mtx); + if (peer->p_handshake_retries <= MAX_TIMER_HANDSHAKES) { + peer->p_handshake_retries++; + mtx_leave(&peer->p_handshake_mtx); DPRINTF(peer->p_sc, "Handshake for peer %llu did not complete " "after %d seconds, retrying (try %d)\n", peer->p_id, - REKEY_TIMEOUT, t->t_handshake_retries + 1); + REKEY_TIMEOUT, peer->p_handshake_retries + 1); wg_peer_clear_src(peer); - wg_timers_run_send_initiation(t, 1); + wg_timers_run_send_initiation(peer, 1); } else { - mtx_leave(&t->t_handshake_mtx); + mtx_leave(&peer->p_handshake_mtx); DPRINTF(peer->p_sc, "Handshake for peer %llu did not complete " "after %d retries, giving up\n", peer->p_id, MAX_TIMER_HANDSHAKES + 2); - timeout_del(&t->t_send_keepalive); + timeout_del(&peer->p_send_keepalive); mq_purge(&peer->p_stage_queue); - if (!timeout_pending(&t->t_zero_key_material)) - timeout_add_sec(&t->t_zero_key_material, + if (!timeout_pending(&peer->p_zero_key_material)) + timeout_add_sec(&peer->p_zero_key_material, REJECT_AFTER_TIME * 3); } } void -wg_timers_run_send_keepalive(void *_t) +wg_timers_run_send_keepalive(void *_peer) { - struct wg_timers *t = _t; - struct wg_peer *peer = CONTAINER_OF(t, struct wg_peer, p_timers); + struct wg_peer *peer = _peer; wg_send_keepalive(peer); - if (READ_ONCE(t->t_need_another_keepalive)) { - WRITE_ONCE(t->t_need_another_keepalive, 0); - timeout_add_sec(&t->t_send_keepalive, KEEPALIVE_TIMEOUT); + if (READ_ONCE(peer->p_need_another_keepalive)) { + WRITE_ONCE(peer->p_need_another_keepalive, 0); + timeout_add_sec(&peer->p_send_keepalive, KEEPALIVE_TIMEOUT); } } void -wg_timers_run_new_handshake(void *_t) +wg_timers_run_new_handshake(void *_peer) { - struct wg_timers *t = _t; - struct wg_peer *peer = CONTAINER_OF(t, struct wg_peer, p_timers); + struct wg_peer *peer = _peer; DPRINTF(peer->p_sc, "Retrying handshake with peer %llu because we " "stopped hearing back after %d seconds\n", peer->p_id, NEW_HANDSHAKE_TIMEOUT); wg_peer_clear_src(peer); - wg_timers_run_send_initiation(t, 0); + wg_timers_run_send_initiation(peer, 0); } void -wg_timers_run_zero_key_material(void *_t) +wg_timers_run_zero_key_material(void *_peer) { - struct wg_timers *t = _t; - struct wg_peer *peer = CONTAINER_OF(t, struct wg_peer, p_timers); + struct wg_peer *peer = _peer; DPRINTF(peer->p_sc, "Zeroing out keys for peer %llu, since we " "haven't received a new one in %d seconds\n", @@ -1051,12 +1034,11 @@ wg_timers_run_zero_key_material(void *_t) } void -wg_timers_run_persistent_keepalive(void *_t) +wg_timers_run_persistent_keepalive(void *_peer) { - struct wg_timers *t = _t; - struct wg_peer *peer = CONTAINER_OF(t, struct wg_peer, p_timers); + struct wg_peer *peer = _peer; - if (READ_ONCE(t->t_persistent_keepalive_interval) > 0) + if (READ_ONCE(peer->p_persistent_keepalive_interval) > 0) wg_send_keepalive(peer); } @@ -1067,8 +1049,8 @@ wg_peer_send_buf(struct wg_peer *peer, uint8_t *buf, size_t len) struct wg_endpoint endpoint; wg_peer_counters_add(peer, len, 0); - wg_timers_event_any_authenticated_packet_traversal(&peer->p_timers); - wg_timers_event_any_authenticated_packet_sent(&peer->p_timers); + wg_timers_event_any_authenticated_packet_traversal(peer); + wg_timers_event_any_authenticated_packet_sent(peer); wg_peer_get_endpoint(peer, &endpoint); wg_send_buf(peer->p_sc, &endpoint, buf, len); } @@ -1089,7 +1071,7 @@ wg_send_initiation(struct wg_peer *peer) cookie_maker_mac(&peer->p_cookie, &pkt.m, &pkt, sizeof(pkt)-sizeof(pkt.m)); wg_peer_send_buf(peer, (uint8_t *)&pkt, sizeof(pkt)); - wg_timers_event_handshake_initiated(&peer->p_timers); + wg_timers_event_handshake_initiated(peer); } void @@ -1103,7 +1085,7 @@ wg_send_response(struct wg_peer *peer) if (noise_create_response(peer->p_remote, &pkt.s_idx, &pkt.r_idx, pkt.ue, pkt.en) != 0) return; - wg_timers_event_session_derived(&peer->p_timers); + wg_timers_event_session_derived(peer); pkt.t = WG_PKT_RESPONSE; cookie_maker_mac(&peer->p_cookie, &pkt.m, &pkt, sizeof(pkt)-sizeof(pkt.m)); @@ -1254,8 +1236,8 @@ wg_handshake(struct wg_softc *sc, struct wg_packet *pkt) DPRINTF(sc, "Receiving handshake response from peer %llu\n", peer->p_id); wg_peer_set_endpoint(peer, e); - wg_timers_event_session_derived(&peer->p_timers); - wg_timers_event_handshake_complete(&peer->p_timers); + wg_timers_event_session_derived(peer); + wg_timers_event_handshake_complete(peer); break; case WG_PKT_COOKIE: cook = mtod(m, struct wg_pkt_cookie *); @@ -1282,8 +1264,8 @@ wg_handshake(struct wg_softc *sc, struct wg_packet *pkt) panic("invalid packet in handshake queue"); } - wg_timers_event_any_authenticated_packet_received(&peer->p_timers); - wg_timers_event_any_authenticated_packet_traversal(&peer->p_timers); + wg_timers_event_any_authenticated_packet_received(peer); + wg_timers_event_any_authenticated_packet_traversal(peer); wg_peer_counters_add(peer, 0, m->m_pkthdr.len); error: if (remote != NULL) @@ -1423,7 +1405,7 @@ wg_decap(struct wg_softc *sc, struct wg_packet *pkt) if (__predict_false(res == EINVAL)) { goto error_free; } else if (__predict_false(res == ECONNRESET)) { - wg_timers_event_handshake_complete(&peer->p_timers); + wg_timers_event_handshake_complete(peer); } else if (__predict_false(res != 0)) { panic("unexpected response: %d\n", res); } @@ -1548,13 +1530,11 @@ wg_deliver_out(void *_peer) ret = wg_send(sc, &endpoint, m); if (ret == 0) { - wg_timers_event_any_authenticated_packet_traversal( - &peer->p_timers); - wg_timers_event_any_authenticated_packet_sent( - &peer->p_timers); + wg_timers_event_any_authenticated_packet_traversal(peer); + wg_timers_event_any_authenticated_packet_sent(peer); if (data) - wg_timers_event_data_sent(&peer->p_timers); + wg_timers_event_data_sent(peer); } else if (ret == EADDRNOTAVAIL) { wg_peer_clear_src(peer); wg_peer_get_endpoint(peer, &endpoint); @@ -1568,7 +1548,7 @@ wg_deliver_out(void *_peer) pool_put(&wg_packet_pool, pkt); } if (noise_keep_key_fresh_send(peer->p_remote)) - wg_timers_event_want_initiation(&peer->p_timers); + wg_timers_event_want_initiation(peer); } void @@ -1587,10 +1567,8 @@ wg_deliver_in(void *_peer) goto put; } - wg_timers_event_any_authenticated_packet_received( - &peer->p_timers); - wg_timers_event_any_authenticated_packet_traversal( - &peer->p_timers); + wg_timers_event_any_authenticated_packet_received(peer); + wg_timers_event_any_authenticated_packet_traversal(peer); wg_peer_set_endpoint(peer, &pkt->p_endpoint); if (m->m_pkthdr.len == 0) { @@ -1615,7 +1593,7 @@ wg_deliver_in(void *_peer) panic("invalid ph_family"); NET_UNLOCK(); - wg_timers_event_data_received(&peer->p_timers); + wg_timers_event_data_received(peer); } else { m_freem(m); } @@ -1624,7 +1602,7 @@ put: pool_put(&wg_packet_pool, pkt); } if (noise_keep_key_fresh_recv(peer->p_remote)) - wg_timers_event_want_initiation(&peer->p_timers); + wg_timers_event_want_initiation(peer); } void @@ -1684,7 +1662,7 @@ wg_queue_out(struct wg_softc *sc, struct wg_peer *peer) struct mbuf *m; if ((keypair = noise_keypair_current(peer->p_remote)) == NULL) { - wg_timers_event_want_initiation(&peer->p_timers); + wg_timers_event_want_initiation(peer); return; } @@ -2088,8 +2066,7 @@ wg_ioctl_set(struct wg_softc *sc, struct wg_data_io *data) noise_remote_set_psk(peer->p_remote, peer_o.p_psk); if (peer_o.p_flags & WG_PEER_HAS_PKA) - wg_timers_set_persistent_keepalive(&peer->p_timers, - peer_o.p_pka); + wg_timers_set_persistent_keepalive(peer, peer_o.p_pka); if (peer_o.p_flags & WG_PEER_REPLACE_AIPS) { LIST_FOREACH_SAFE(aip, &peer->p_aip, a_entry, taip) { @@ -2182,8 +2159,7 @@ wg_ioctl_get(struct wg_softc *sc, struct wg_data_io *data) peer_o.p_psk) == 0) peer_o.p_flags |= WG_PEER_HAS_PSK; - if (wg_timers_get_persistent_keepalive(&peer->p_timers, - &peer_o.p_pka) == 0) + if (wg_timers_get_persistent_keepalive(peer, &peer_o.p_pka) == 0) peer_o.p_flags |= WG_PEER_HAS_PKA; if (wg_peer_get_sockaddr(peer, &peer_o.p_sa) == 0) @@ -2194,8 +2170,7 @@ wg_ioctl_get(struct wg_softc *sc, struct wg_data_io *data) peer_o.p_rxbytes = peer->p_counters_rx; mtx_leave(&peer->p_counters_mtx); - wg_timers_get_last_handshake(&peer->p_timers, - &peer_o.p_last_handshake); + wg_timers_get_last_handshake(peer, &peer_o.p_last_handshake); aip_count = 0; aip_p = &peer_p->p_aips[0]; @@ -2297,7 +2272,7 @@ wg_up(struct wg_softc *sc) ret = wg_bind(sc, &sc->sc_udp_port, &sc->sc_udp_rtable); if (ret == 0) { TAILQ_FOREACH(peer, &sc->sc_peers, p_entry) - wg_timers_enable(&peer->p_timers); + wg_timers_enable(peer); } rw_exit_write(&sc->sc_lock); @@ -2326,7 +2301,7 @@ wg_down(struct wg_softc *sc) rw_enter_read(&sc->sc_lock); TAILQ_FOREACH(peer, &sc->sc_peers, p_entry) { mq_purge(&peer->p_stage_queue); - wg_timers_disable(&peer->p_timers); + wg_timers_disable(peer); } taskq_barrier(wg_handshake_taskq); |