2 * Copyright (c) 2020 Doc.ai and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 #include <vlibmemory/api.h>
17 #include <wireguard/wireguard.h>
18 #include <wireguard/wireguard_send.h>
19 #include <wireguard/wireguard_timer.h>
22 get_random_u32_max (u32 max)
24 vlib_main_t *vm = vlib_get_main ();
25 u32 seed = (u32) (vlib_time_now (vm) * 1e6);
26 return random_u32 (&seed) % max;
30 stop_timer (wg_peer_t * peer, u32 timer_id)
32 if (peer->timers[timer_id] != ~0)
34 tw_timer_stop_16t_2w_512sl (peer->timer_wheel, peer->timers[timer_id]);
35 peer->timers[timer_id] = ~0;
40 start_timer (wg_peer_t * peer, u32 timer_id, u32 interval_ticks)
42 ASSERT (vlib_get_thread_index () == 0);
44 if (peer->timers[timer_id] == ~0)
46 peer->timers[timer_id] =
47 tw_timer_start_16t_2w_512sl (peer->timer_wheel, peer - wg_peer_pool,
48 timer_id, interval_ticks);
61 start_timer_thread_fn (void *arg)
63 wg_timers_args *a = arg;
64 wg_peer_t *peer = wg_peer_get (a->peer_idx);
65 start_timer (peer, a->timer_id, a->interval_ticks);
70 start_timer_from_mt (u32 peer_idx, u32 timer_id, u32 interval_ticks)
75 .interval_ticks = interval_ticks,
77 wg_peer_t *peer = wg_peer_get (peer_idx);
78 if (PREDICT_FALSE (!peer->timers_dispatched[timer_id]))
79 if (!clib_atomic_cmp_and_swap (&peer->timers_dispatched[timer_id], 0, 1))
80 vl_api_rpc_call_main_thread (start_timer_thread_fn, (u8 *) &a,
85 timer_ticks_left (vlib_main_t * vm, f64 init_time_sec, u32 interval_ticks)
87 static const int32_t rounding = (int32_t) (WHZ / 2);
90 ticks_remain = (init_time_sec - vlib_time_now (vm)) * WHZ + interval_ticks;
91 return (ticks_remain > rounding) ? (u32) ticks_remain : 0;
95 wg_expired_retransmit_handshake (vlib_main_t * vm, wg_peer_t * peer)
97 if (peer->rehandshake_started == ~0)
100 u32 ticks = timer_ticks_left (vm, peer->rehandshake_started,
101 peer->rehandshake_interval_tick);
104 start_timer (peer, WG_TIMER_RETRANSMIT_HANDSHAKE, ticks);
108 if (peer->timer_handshake_attempts > MAX_TIMER_HANDSHAKES)
110 stop_timer (peer, WG_TIMER_SEND_KEEPALIVE);
112 /* We set a timer for destroying any residue that might be left
113 * of a partial exchange.
115 start_timer (peer, WG_TIMER_KEY_ZEROING, REJECT_AFTER_TIME * 3 * WHZ);
120 ++peer->timer_handshake_attempts;
121 wg_send_handshake (vm, peer, true);
126 wg_expired_send_keepalive (vlib_main_t * vm, wg_peer_t * peer)
128 if (peer->last_sent_packet < peer->last_received_packet)
130 u32 ticks = timer_ticks_left (vm, peer->last_received_packet,
131 KEEPALIVE_TIMEOUT * WHZ);
134 start_timer (peer, WG_TIMER_SEND_KEEPALIVE, ticks);
138 wg_send_keepalive (vm, peer);
139 if (peer->timer_need_another_keepalive)
141 peer->timer_need_another_keepalive = false;
142 start_timer (peer, WG_TIMER_SEND_KEEPALIVE,
143 KEEPALIVE_TIMEOUT * WHZ);
149 wg_expired_send_persistent_keepalive (vlib_main_t * vm, wg_peer_t * peer)
151 if (peer->persistent_keepalive_interval)
153 f64 latest_time = peer->last_sent_packet > peer->last_received_packet
154 ? peer->last_sent_packet : peer->last_received_packet;
156 u32 ticks = timer_ticks_left (vm, latest_time,
157 peer->persistent_keepalive_interval *
161 start_timer (peer, WG_TIMER_PERSISTENT_KEEPALIVE, ticks);
165 wg_send_keepalive (vm, peer);
170 wg_expired_new_handshake (vlib_main_t * vm, wg_peer_t * peer)
172 u32 ticks = timer_ticks_left (vm, peer->last_sent_packet,
173 peer->new_handshake_interval_tick);
176 start_timer (peer, WG_TIMER_NEW_HANDSHAKE, ticks);
180 wg_send_handshake (vm, peer, false);
184 wg_expired_zero_key_material (vlib_main_t * vm, wg_peer_t * peer)
187 timer_ticks_left (vm, peer->session_derived, REJECT_AFTER_TIME * 3 * WHZ);
190 start_timer (peer, WG_TIMER_KEY_ZEROING, ticks);
196 noise_remote_clear (vm, &peer->remote);
201 wg_timers_any_authenticated_packet_traversal (wg_peer_t * peer)
203 if (peer->persistent_keepalive_interval)
205 start_timer_from_mt (peer - wg_peer_pool,
206 WG_TIMER_PERSISTENT_KEEPALIVE,
207 peer->persistent_keepalive_interval * WHZ);
212 wg_timers_any_authenticated_packet_sent (wg_peer_t * peer)
214 peer->last_sent_packet = vlib_time_now (vlib_get_main ());
218 wg_timers_handshake_initiated (wg_peer_t * peer)
220 peer->rehandshake_started = vlib_time_now (vlib_get_main ());
221 peer->rehandshake_interval_tick =
222 REKEY_TIMEOUT * WHZ + get_random_u32_max (REKEY_TIMEOUT_JITTER);
224 start_timer_from_mt (peer - wg_peer_pool, WG_TIMER_RETRANSMIT_HANDSHAKE,
225 peer->rehandshake_interval_tick);
229 wg_timers_session_derived (wg_peer_t * peer)
231 peer->session_derived = vlib_time_now (vlib_get_main ());
233 start_timer_from_mt (peer - wg_peer_pool, WG_TIMER_KEY_ZEROING,
234 REJECT_AFTER_TIME * 3 * WHZ);
237 /* Should be called after an authenticated data packet is sent. */
239 wg_timers_data_sent (wg_peer_t * peer)
241 peer->new_handshake_interval_tick =
242 (KEEPALIVE_TIMEOUT + REKEY_TIMEOUT) * WHZ +
243 get_random_u32_max (REKEY_TIMEOUT_JITTER);
245 start_timer_from_mt (peer - wg_peer_pool, WG_TIMER_NEW_HANDSHAKE,
246 peer->new_handshake_interval_tick);
249 /* Should be called after an authenticated data packet is received. */
251 wg_timers_data_received (wg_peer_t * peer)
253 if (peer->timers[WG_TIMER_SEND_KEEPALIVE] == ~0)
255 start_timer_from_mt (peer - wg_peer_pool, WG_TIMER_SEND_KEEPALIVE,
256 KEEPALIVE_TIMEOUT * WHZ);
259 peer->timer_need_another_keepalive = true;
262 /* Should be called after a handshake response message is received and processed
263 * or when getting key confirmation via the first data message.
266 wg_timers_handshake_complete (wg_peer_t * peer)
268 peer->rehandshake_started = ~0;
269 peer->timer_handshake_attempts = 0;
273 wg_timers_any_authenticated_packet_received (wg_peer_t * peer)
275 peer->last_received_packet = vlib_time_now (vlib_get_main ());
278 static vlib_node_registration_t wg_timer_mngr_node;
281 expired_timer_callback (u32 * expired_timers)
287 wg_main_t *wmp = &wg_main;
288 vlib_main_t *vm = wmp->vlib_main;
292 /* Need to invalidate all of them because one can restart other */
293 for (i = 0; i < vec_len (expired_timers); i++)
295 pool_index = expired_timers[i] & 0x0FFFFFFF;
296 timer_id = expired_timers[i] >> 28;
298 peer = wg_peer_get (pool_index);
299 peer->timers[timer_id] = ~0;
301 /* Under barrier, no sync needed */
302 peer->timers_dispatched[timer_id] = 0;
305 for (i = 0; i < vec_len (expired_timers); i++)
307 pool_index = expired_timers[i] & 0x0FFFFFFF;
308 timer_id = expired_timers[i] >> 28;
310 peer = wg_peer_get (pool_index);
313 case WG_TIMER_RETRANSMIT_HANDSHAKE:
314 wg_expired_retransmit_handshake (vm, peer);
316 case WG_TIMER_PERSISTENT_KEEPALIVE:
317 wg_expired_send_persistent_keepalive (vm, peer);
319 case WG_TIMER_SEND_KEEPALIVE:
320 wg_expired_send_keepalive (vm, peer);
322 case WG_TIMER_NEW_HANDSHAKE:
323 wg_expired_new_handshake (vm, peer);
325 case WG_TIMER_KEY_ZEROING:
326 wg_expired_zero_key_material (vm, peer);
335 wg_timer_wheel_init ()
337 wg_main_t *wmp = &wg_main;
338 tw_timer_wheel_16t_2w_512sl_t *tw = &wmp->timer_wheel;
339 tw_timer_wheel_init_16t_2w_512sl (tw,
340 expired_timer_callback,
341 WG_TICK /* timer period in s */ , ~0);
345 wg_timer_mngr_fn (vlib_main_t * vm, vlib_node_runtime_t * rt,
348 wg_main_t *wmp = &wg_main;
349 uword event_type = 0;
351 /* Park the process until the feature is configured */
354 vlib_process_wait_for_event (vm);
355 event_type = vlib_process_get_events (vm, 0);
356 if (event_type == WG_START_EVENT)
362 clib_warning ("Unknown event type %d", event_type);
366 * Reset the timer wheel time so it won't try to
367 * expire Avogadro's number of time slots.
369 wmp->timer_wheel.last_run_time = vlib_time_now (vm);
373 vlib_process_wait_for_event_or_clock (vm, WG_TICK);
374 vlib_process_get_events (vm, NULL);
376 tw_timer_expire_timers_16t_2w_512sl (&wmp->timer_wheel,
384 wg_timers_stop (wg_peer_t * peer)
386 ASSERT (vlib_get_thread_index () == 0);
387 if (peer->timer_wheel)
389 stop_timer (peer, WG_TIMER_RETRANSMIT_HANDSHAKE);
390 stop_timer (peer, WG_TIMER_PERSISTENT_KEEPALIVE);
391 stop_timer (peer, WG_TIMER_SEND_KEEPALIVE);
392 stop_timer (peer, WG_TIMER_NEW_HANDSHAKE);
393 stop_timer (peer, WG_TIMER_KEY_ZEROING);
398 VLIB_REGISTER_NODE (wg_timer_mngr_node, static) = {
399 .function = wg_timer_mngr_fn,
400 .type = VLIB_NODE_TYPE_PROCESS,
407 wg_feature_init (wg_main_t * wmp)
409 if (wmp->feature_init)
411 vlib_process_signal_event (wmp->vlib_main, wg_timer_mngr_node.index,
413 wmp->feature_init = 1;
419 * fd.io coding-style-patch-verification: ON
422 * eval: (c-set-style "gnu")