Lines Matching defs:wgp
163 * - Each peer (struct wg_peer, wgp) has a mutex wgp_lock, which can be taken
840 #define WG_PEER_READER_FOREACH(wgp, wg) \
841 PSLIST_READER_FOREACH((wgp), &(wg)->wg_peers, struct wg_peer, \
843 #define WG_PEER_WRITER_FOREACH(wgp, wg) \
844 PSLIST_WRITER_FOREACH((wgp), &(wg)->wg_peers, struct wg_peer, \
846 #define WG_PEER_WRITER_INSERT_HEAD(wgp, wg) \
847 PSLIST_WRITER_INSERT_HEAD(&(wg)->wg_peers, (wgp), wgp_peerlist_entry)
848 #define WG_PEER_WRITER_REMOVE(wgp) \
849 PSLIST_WRITER_REMOVE((wgp), wgp_peerlist_entry)
1285 * wg_get_stable_session(wgp, psref)
1296 wg_get_stable_session(struct wg_peer *wgp, struct psref *psref)
1302 wgs = atomic_load_consume(&wgp->wgp_session_stable);
1323 struct wg_peer *wgp = wgs->wgs_peer;
1327 KASSERT(mutex_owned(wgp->wgp_lock));
1337 pserialize_perform(wgp->wgp_psz);
1367 struct wg_peer *wgp __diagused = wgs->wgs_peer;
1371 KASSERT(mutex_owned(wgp->wgp_lock));
1372 KASSERT(wgs == wgp->wgp_session_unstable);
1402 struct wg_peer *wgp __diagused = wgs->wgs_peer;
1404 KASSERT(mutex_owned(wgp->wgp_lock));
1435 wg_fill_msg_init(struct wg_softc *wg, struct wg_peer *wgp,
1444 KASSERT(mutex_owned(wgp->wgp_lock));
1445 KASSERT(wgs == wgp->wgp_session_unstable);
1458 wg_algo_hash(hash, wgp->wgp_pubkey, sizeof(wgp->wgp_pubkey));
1477 wg_algo_dh_kdf(ckey, cipher_key, privkey, wgp->wgp_pubkey);
1491 wg_algo_dh_kdf(ckey, cipher_key, wg->wg_privkey, wgp->wgp_pubkey);
1503 wgp->wgp_pubkey, sizeof(wgp->wgp_pubkey),
1506 memcpy(wgp->wgp_last_sent_mac1, wgmi->wgmi_mac1,
1507 sizeof(wgp->wgp_last_sent_mac1));
1508 wgp->wgp_last_sent_mac1_valid = true;
1510 if (wgp->wgp_latest_cookie_time == 0 ||
1511 (time_uptime - wgp->wgp_latest_cookie_time) >= WG_COOKIE_TIME)
1515 wgp->wgp_latest_cookie, WG_COOKIE_LEN,
1529 * wg_initiator_priority(wg, wgp)
1531 * Return true if we claim priority over peer wgp as initiator at
1571 wg_initiator_priority(struct wg_softc *wg, struct wg_peer *wgp)
1584 wgp->wgp_pubkey, sizeof(wgp->wgp_pubkey));
1600 struct wg_peer *wgp;
1666 wgp = wg_lookup_peer_by_pubkey(wg, peer_pubkey, &psref_peer);
1667 if (wgp == NULL) {
1678 mutex_enter(wgp->wgp_lock);
1680 if (__predict_false(wg_is_underload(wg, wgp, WG_MSG_TYPE_INIT))) {
1693 wg_send_cookie_msg(wg, wgp, wgmi->wgmi_sender,
1697 if (!wgp->wgp_last_sent_cookie_valid) {
1699 wg_send_cookie_msg(wg, wgp, wgmi->wgmi_sender,
1704 wg_algo_mac(mac2, sizeof(mac2), wgp->wgp_last_sent_cookie,
1716 wg_algo_dh_kdf(ckey, cipher_key, wg->wg_privkey, wgp->wgp_pubkey);
1724 WG_LOG_RATECHECK(&wgp->wgp_ppsratecheck, LOG_DEBUG,
1726 if_name(&wg->wg_if), wgp->wgp_name);
1737 ret = memcmp(timestamp, wgp->wgp_timestamp_latest_init,
1740 WG_LOG_RATECHECK(&wgp->wgp_ppsratecheck, LOG_DEBUG,
1742 if_name(&wg->wg_if), wgp->wgp_name);
1745 memcpy(wgp->wgp_timestamp_latest_init, timestamp, sizeof(timestamp));
1751 wgs = wgp->wgp_session_unstable;
1756 if (wg_initiator_priority(wg, wgp)) {
1807 wg_update_endpoint_if_necessary(wgp, src);
1818 wg_schedule_session_dtor_timer(wgp);
1823 wg_send_handshake_msg_resp(wg, wgp, wgs, wgmi);
1851 mutex_exit(wgp->wgp_lock);
1852 wg_put_peer(wgp, &psref_peer);
1874 wg_get_so_by_peer(struct wg_peer *wgp, struct wg_sockaddr *wgsa)
1877 return wg_get_so_by_af(wgp->wgp_sc, wgsa_family(wgsa));
1881 wg_get_endpoint_sa(struct wg_peer *wgp, struct psref *psref)
1887 wgsa = atomic_load_consume(&wgp->wgp_endpoint);
1895 wg_put_sa(struct wg_peer *wgp, struct wg_sockaddr *wgsa, struct psref *psref)
1902 wg_send_hs(struct wg_peer *wgp, struct mbuf *m)
1909 wgsa = wg_get_endpoint_sa(wgp, &psref);
1915 so = wg_get_so_by_peer(wgp, wgsa);
1917 wg_put_sa(wgp, wgsa, &psref);
1923 wg_send_handshake_msg_init(struct wg_softc *wg, struct wg_peer *wgp)
1930 KASSERT(mutex_owned(wgp->wgp_lock));
1932 wgs = wgp->wgp_session_unstable;
1979 wg_fill_msg_init(wg, wgp, wgs, wgmi);
1981 error = wg->wg_ops->send_hs_msg(wgp, m); /* consumes m */
1992 m = atomic_swap_ptr(&wgp->wgp_pending, NULL);
1999 if (wgp->wgp_handshake_start_time == 0)
2000 wgp->wgp_handshake_start_time = time_uptime;
2001 callout_schedule(&wgp->wgp_handshake_timeout_timer,
2006 wg_fill_msg_resp(struct wg_softc *wg, struct wg_peer *wgp,
2016 KASSERT(mutex_owned(wgp->wgp_lock));
2017 KASSERT(wgs == wgp->wgp_session_unstable);
2049 wg_algo_dh_kdf(ckey, NULL, privkey, wgp->wgp_pubkey);
2055 wg_algo_kdf(ckey, kdfout, cipher_key, ckey, wgp->wgp_psk,
2056 sizeof(wgp->wgp_psk));
2072 wgp->wgp_pubkey, sizeof(wgp->wgp_pubkey),
2075 memcpy(wgp->wgp_last_sent_mac1, wgmr->wgmr_mac1,
2076 sizeof(wgp->wgp_last_sent_mac1));
2077 wgp->wgp_last_sent_mac1_valid = true;
2079 if (wgp->wgp_latest_cookie_time == 0 ||
2080 (time_uptime - wgp->wgp_latest_cookie_time) >= WG_COOKIE_TIME)
2086 wgp->wgp_latest_cookie, WG_COOKIE_LEN,
2102 * wg_swap_sessions(wg, wgp)
2105 * wg for peer wgp. Publish it as the stable session, send queued
2111 wg_swap_sessions(struct wg_softc *wg, struct wg_peer *wgp)
2116 KASSERT(mutex_owned(wgp->wgp_lock));
2124 wgs = wgp->wgp_session_unstable;
2134 wgs_prev = wgp->wgp_session_stable;
2145 atomic_store_release(&wgp->wgp_session_stable, wgs);
2146 wgp->wgp_session_unstable = wgs_prev;
2151 getnanotime(&wgp->wgp_last_handshake_time);
2152 wgp->wgp_handshake_start_time = 0;
2153 wgp->wgp_last_sent_mac1_valid = false;
2154 wgp->wgp_last_sent_cookie_valid = false;
2163 if ((m = atomic_swap_ptr(&wgp->wgp_pending, NULL)) != NULL) {
2165 wg_send_data_msg(wgp, wgs, m); /* consumes m */
2168 wg_send_keepalive_msg(wgp, wgs);
2204 struct wg_peer *wgp;
2231 wgp = wgs->wgs_peer;
2233 mutex_enter(wgp->wgp_lock);
2241 if (__predict_false(wg_is_underload(wg, wgp, WG_MSG_TYPE_RESP))) {
2254 wg_send_cookie_msg(wg, wgp, wgmr->wgmr_sender,
2258 if (!wgp->wgp_last_sent_cookie_valid) {
2260 wg_send_cookie_msg(wg, wgp, wgmr->wgmr_sender,
2265 wg_algo_mac(mac2, sizeof(mac2), wgp->wgp_last_sent_cookie,
2311 wg_algo_kdf(ckey, kdfout, cipher_key, ckey, wgp->wgp_psk,
2312 sizeof(wgp->wgp_psk));
2324 WG_LOG_RATECHECK(&wgp->wgp_ppsratecheck, LOG_DEBUG,
2326 if_name(&wg->wg_if), wgp->wgp_name);
2345 wg_update_endpoint_if_necessary(wgp, src);
2350 wg_schedule_session_dtor_timer(wgp);
2371 callout_halt(&wgp->wgp_handshake_timeout_timer, NULL);
2380 wg_swap_sessions(wg, wgp);
2381 KASSERT(wgs == wgp->wgp_session_stable);
2384 mutex_exit(wgp->wgp_lock);
2389 wg_send_handshake_msg_resp(struct wg_softc *wg, struct wg_peer *wgp,
2396 KASSERT(mutex_owned(wgp->wgp_lock));
2397 KASSERT(wgs == wgp->wgp_session_unstable);
2408 wg_fill_msg_resp(wg, wgp, wgs, wgmr, wgmi);
2410 error = wg->wg_ops->send_hs_msg(wgp, m); /* consumes m */
2423 struct wg_peer *wgp;
2426 wgp = thmap_get(wg->wg_peers_bypubkey, pubkey, WG_STATIC_KEY_LEN);
2427 if (wgp != NULL)
2428 wg_get_peer(wgp, psref);
2431 return wgp;
2435 wg_fill_msg_cookie(struct wg_softc *wg, struct wg_peer *wgp,
2445 KASSERT(mutex_owned(wgp->wgp_lock));
2456 if ((time_uptime - wgp->wgp_last_cookiesecret_time) >
2458 cprng_strong(kern_cprng, wgp->wgp_cookiesecret,
2459 sizeof(wgp->wgp_cookiesecret), 0);
2460 wgp->wgp_last_cookiesecret_time = time_uptime;
2487 wgp->wgp_cookiesecret, sizeof(wgp->wgp_cookiesecret),
2495 memcpy(wgp->wgp_last_sent_cookie, cookie, sizeof(cookie));
2496 wgp->wgp_last_sent_cookie_valid = true;
2500 wg_send_cookie_msg(struct wg_softc *wg, struct wg_peer *wgp,
2508 KASSERT(mutex_owned(wgp->wgp_lock));
2517 wg_fill_msg_cookie(wg, wgp, wgmc, sender, mac1, src);
2519 error = wg->wg_ops->send_hs_msg(wgp, m); /* consumes m */
2529 wg_is_underload(struct wg_softc *wg, struct wg_peer *wgp, int msgtype)
2542 time_t last = wgp->wgp_last_msg_received_time[msgtype];
2543 wgp->wgp_last_msg_received_time[msgtype] = time_uptime;
2637 wg_send_keepalive_msg(struct wg_peer *wgp, struct wg_session *wgs)
2648 wg_send_data_msg(wgp, wgs, m);
2671 wg_schedule_peer_task(struct wg_peer *wgp, unsigned int task)
2674 mutex_enter(wgp->wgp_intr_lock);
2675 WG_DLOG("tasks=%d, task=%d\n", wgp->wgp_tasks, task);
2676 if (wgp->wgp_tasks == 0)
2683 workqueue_enqueue(wg_wq, &wgp->wgp_work, NULL);
2684 wgp->wgp_tasks |= task;
2685 mutex_exit(wgp->wgp_intr_lock);
2689 wg_change_endpoint(struct wg_peer *wgp, const struct sockaddr *new)
2695 memcpy(wgp->wgp_endpoint0, new, new->sa_len);
2696 wgsa_prev = wgp->wgp_endpoint;
2697 atomic_store_release(&wgp->wgp_endpoint, wgp->wgp_endpoint0);
2698 wgp->wgp_endpoint0 = wgsa_prev;
2699 atomic_store_release(&wgp->wgp_endpoint_available, true);
2701 wg_schedule_peer_task(wgp, WGP_TASK_ENDPOINT_CHANGED);
2769 struct wg_peer *wgp;
2803 wgp = wg_pick_peer_by_sa(wg, sa, &psref);
2804 ok = (wgp == wgp_expected);
2805 if (wgp != NULL)
2806 wg_put_peer(wgp, &psref);
2814 struct wg_peer *wgp = arg;
2818 wg_schedule_session_dtor_timer(wgp);
2819 wg_schedule_peer_task(wgp, WGP_TASK_DESTROY_PREV_SESSION);
2823 wg_schedule_session_dtor_timer(struct wg_peer *wgp)
2831 if (callout_pending(&wgp->wgp_session_dtor_timer)) {
2837 callout_schedule(&wgp->wgp_session_dtor_timer,
2862 wg_update_endpoint_if_necessary(struct wg_peer *wgp,
2868 wgsa = wg_get_endpoint_sa(wgp, &psref);
2884 if (atomic_swap_uint(&wgp->wgp_endpoint_changing, 1) == 0) {
2885 wg_change_endpoint(wgp, src);
2889 wg_put_sa(wgp, wgsa, &psref);
2900 struct wg_peer *wgp;
2959 wgp = wgs->wgs_peer;
2968 WG_LOG_RATECHECK(&wgp->wgp_ppsratecheck, LOG_DEBUG,
2970 if_name(&wg->wg_if), wgp->wgp_name,
3023 WG_LOG_RATECHECK(&wgp->wgp_ppsratecheck, LOG_DEBUG,
3025 if_name(&wg->wg_if), wgp->wgp_name);
3037 WG_LOG_RATECHECK(&wgp->wgp_ppsratecheck, LOG_DEBUG,
3039 if_name(&wg->wg_if), wgp->wgp_name,
3057 wg_update_endpoint_if_necessary(wgp, src);
3070 ok = wg_validate_route(wg, wgp, af, decrypted_buf);
3095 WG_LOG_RATECHECK(&wgp->wgp_ppsratecheck, LOG_DEBUG,
3097 if_name(&wg->wg_if), wgp->wgp_name, addrstr);
3114 wg_schedule_peer_task(wgp, WGP_TASK_ESTABLISH_SESSION);
3117 wg_schedule_peer_task(wgp, WGP_TASK_SEND_INIT_MESSAGE);
3139 wg_schedule_peer_task(wgp,
3154 struct wg_peer *wgp;
3170 wgp = wgs->wgs_peer;
3171 mutex_enter(wgp->wgp_lock);
3173 if (!wgp->wgp_last_sent_mac1_valid) {
3188 wg_algo_mac_cookie(key, sizeof(key), wgp->wgp_pubkey,
3189 sizeof(wgp->wgp_pubkey));
3192 wgp->wgp_last_sent_mac1, sizeof(wgp->wgp_last_sent_mac1),
3195 WG_LOG_RATECHECK(&wgp->wgp_ppsratecheck, LOG_DEBUG,
3197 "error=%d\n", if_name(&wg->wg_if), wgp->wgp_name, error);
3206 wgp->wgp_latest_cookie_time = time_uptime;
3207 memcpy(wgp->wgp_latest_cookie, cookie, sizeof(wgp->wgp_latest_cookie));
3209 mutex_exit(wgp->wgp_lock);
3340 wg_get_peer(struct wg_peer *wgp, struct psref *psref)
3343 psref_acquire(psref, &wgp->wgp_psref, wg_psref_class);
3347 wg_put_peer(struct wg_peer *wgp, struct psref *psref)
3350 psref_release(psref, &wgp->wgp_psref, wg_psref_class);
3354 wg_task_send_init_message(struct wg_softc *wg, struct wg_peer *wgp)
3360 KASSERT(mutex_owned(wgp->wgp_lock));
3362 if (!atomic_load_acquire(&wgp->wgp_endpoint_available)) {
3374 wgs = wgp->wgp_session_stable;
3384 wg_send_handshake_msg_init(wg, wgp);
3388 wg_task_retry_handshake(struct wg_softc *wg, struct wg_peer *wgp)
3394 KASSERT(mutex_owned(wgp->wgp_lock));
3396 wgs = wgp->wgp_session_unstable;
3400 KASSERT(wgp->wgp_handshake_start_time != 0);
3409 if ((time_uptime - wgp->wgp_handshake_start_time) >
3412 wgp->wgp_handshake_start_time = 0;
3420 wg_purge_pending_packets(wgp);
3424 wg_task_send_init_message(wg, wgp);
3428 wg_task_establish_session(struct wg_softc *wg, struct wg_peer *wgp)
3432 KASSERT(mutex_owned(wgp->wgp_lock));
3434 wgs = wgp->wgp_session_unstable;
3465 wg_swap_sessions(wg, wgp);
3466 KASSERT(wgs == wgp->wgp_session_stable);
3470 wg_task_endpoint_changed(struct wg_softc *wg, struct wg_peer *wgp)
3475 KASSERT(mutex_owned(wgp->wgp_lock));
3477 if (atomic_load_relaxed(&wgp->wgp_endpoint_changing)) {
3478 pserialize_perform(wgp->wgp_psz);
3479 mutex_exit(wgp->wgp_lock);
3480 psref_target_destroy(&wgp->wgp_endpoint0->wgsa_psref,
3482 psref_target_init(&wgp->wgp_endpoint0->wgsa_psref,
3484 mutex_enter(wgp->wgp_lock);
3485 atomic_store_release(&wgp->wgp_endpoint_changing, 0);
3490 wg_task_send_keepalive_message(struct wg_softc *wg, struct wg_peer *wgp)
3496 KASSERT(mutex_owned(wgp->wgp_lock));
3498 wgs = wgp->wgp_session_stable;
3502 wg_send_keepalive_msg(wgp, wgs);
3506 wg_task_destroy_prev_session(struct wg_softc *wg, struct wg_peer *wgp)
3513 KASSERT(mutex_owned(wgp->wgp_lock));
3521 wgs = wgp->wgp_session_unstable;
3537 wgs = wgp->wgp_session_stable;
3559 if (wgp->wgp_session_unstable->wgs_state == WGS_STATE_UNKNOWN &&
3560 wgp->wgp_session_stable->wgs_state == WGS_STATE_UNKNOWN)
3561 callout_halt(&wgp->wgp_session_dtor_timer, NULL);
3567 struct wg_peer *wgp = container_of(wk, struct wg_peer, wgp_work);
3568 struct wg_softc *wg = wgp->wgp_sc;
3571 mutex_enter(wgp->wgp_intr_lock);
3572 while ((tasks = wgp->wgp_tasks) != 0) {
3573 wgp->wgp_tasks = 0;
3574 mutex_exit(wgp->wgp_intr_lock);
3576 mutex_enter(wgp->wgp_lock);
3578 wg_task_send_init_message(wg, wgp);
3580 wg_task_retry_handshake(wg, wgp);
3582 wg_task_establish_session(wg, wgp);
3584 wg_task_endpoint_changed(wg, wgp);
3586 wg_task_send_keepalive_message(wg, wgp);
3588 wg_task_destroy_prev_session(wg, wgp);
3589 mutex_exit(wgp->wgp_lock);
3591 mutex_enter(wgp->wgp_intr_lock);
3593 mutex_exit(wgp->wgp_intr_lock);
3798 struct wg_peer *wgp;
3804 wgp = M_GETCTX(m, struct wg_peer *);
3805 if ((wgs = wg_get_stable_session(wgp, &psref)) == NULL) {
3817 if ((m = atomic_swap_ptr(&wgp->wgp_pending, m)) ==
3821 wg_schedule_peer_task(wgp,
3833 if ((m = atomic_swap_ptr(&wgp->wgp_pending, m)) ==
3839 wg_schedule_peer_task(wgp,
3848 wg_send_data_msg(wgp, wgs, m);
3857 wg_purge_pending_packets(struct wg_peer *wgp)
3861 m = atomic_swap_ptr(&wgp->wgp_pending, NULL);
3865 wg_start(&wgp->wgp_sc->wg_if);
3873 struct wg_peer *wgp = arg;
3877 wg_schedule_peer_task(wgp, WGP_TASK_RETRY_HANDSHAKE);
3883 struct wg_peer *wgp;
3885 wgp = kmem_zalloc(sizeof(*wgp), KM_SLEEP);
3887 wgp->wgp_sc = wg;
3888 callout_init(&wgp->wgp_handshake_timeout_timer, CALLOUT_MPSAFE);
3889 callout_setfunc(&wgp->wgp_handshake_timeout_timer,
3890 wg_handshake_timeout_timer, wgp);
3891 callout_init(&wgp->wgp_session_dtor_timer, CALLOUT_MPSAFE);
3892 callout_setfunc(&wgp->wgp_session_dtor_timer,
3893 wg_session_dtor_timer, wgp);
3894 PSLIST_ENTRY_INIT(wgp, wgp_peerlist_entry);
3895 wgp->wgp_endpoint_changing = false;
3896 wgp->wgp_endpoint_available = false;
3897 wgp->wgp_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
3898 wgp->wgp_intr_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_SOFTNET);
3899 wgp->wgp_psz = pserialize_create();
3900 psref_target_init(&wgp->wgp_psref, wg_psref_class);
3902 wgp->wgp_endpoint = kmem_zalloc(sizeof(*wgp->wgp_endpoint), KM_SLEEP);
3903 wgp->wgp_endpoint0 = kmem_zalloc(sizeof(*wgp->wgp_endpoint0), KM_SLEEP);
3904 psref_target_init(&wgp->wgp_endpoint->wgsa_psref, wg_psref_class);
3905 psref_target_init(&wgp->wgp_endpoint0->wgsa_psref, wg_psref_class);
3908 wgp->wgp_session_stable =
3909 kmem_zalloc(sizeof(*wgp->wgp_session_stable), KM_SLEEP);
3910 wgp->wgp_session_unstable =
3911 kmem_zalloc(sizeof(*wgp->wgp_session_unstable), KM_SLEEP);
3912 wgs = wgp->wgp_session_stable;
3913 wgs->wgs_peer = wgp;
3922 wgs = wgp->wgp_session_unstable;
3923 wgs->wgs_peer = wgp;
3932 return wgp;
3936 wg_destroy_peer(struct wg_peer *wgp)
3939 struct wg_softc *wg = wgp->wgp_sc;
3943 for (int i = 0; i < wgp->wgp_n_allowedips; i++) {
3944 struct wg_allowedip *wga = &wgp->wgp_allowedips[i];
3962 wg_purge_pending_packets(wgp);
3965 callout_halt(&wgp->wgp_handshake_timeout_timer, NULL);
3966 callout_halt(&wgp->wgp_session_dtor_timer, NULL);
3969 workqueue_wait(wg_wq, &wgp->wgp_work);
3971 wgs = wgp->wgp_session_unstable;
3973 mutex_enter(wgp->wgp_lock);
3975 mutex_exit(wgp->wgp_lock);
3984 wgs = wgp->wgp_session_stable;
3986 mutex_enter(wgp->wgp_lock);
3988 mutex_exit(wgp->wgp_lock);
3997 psref_target_destroy(&wgp->wgp_endpoint->wgsa_psref, wg_psref_class);
3998 psref_target_destroy(&wgp->wgp_endpoint0->wgsa_psref, wg_psref_class);
3999 kmem_free(wgp->wgp_endpoint, sizeof(*wgp->wgp_endpoint));
4000 kmem_free(wgp->wgp_endpoint0, sizeof(*wgp->wgp_endpoint0));
4002 pserialize_destroy(wgp->wgp_psz);
4003 mutex_obj_free(wgp->wgp_intr_lock);
4004 mutex_obj_free(wgp->wgp_lock);
4006 kmem_free(wgp, sizeof(*wgp));
4012 struct wg_peer *wgp, *wgp0 __diagused;
4018 WG_PEER_WRITER_FOREACH(wgp, wg) {
4019 if (wgp->wgp_name[0]) {
4020 wgp0 = thmap_del(wg->wg_peers_byname, wgp->wgp_name,
4021 strlen(wgp->wgp_name));
4022 KASSERT(wgp0 == wgp);
4025 wgp0 = thmap_del(wg->wg_peers_bypubkey, wgp->wgp_pubkey,
4026 sizeof(wgp->wgp_pubkey));
4027 KASSERT(wgp0 == wgp);
4029 WG_PEER_WRITER_REMOVE(wgp);
4031 mutex_enter(wgp->wgp_lock);
4032 pserialize_perform(wgp->wgp_psz);
4033 mutex_exit(wgp->wgp_lock);
4034 PSLIST_ENTRY_DESTROY(wgp, wgp_peerlist_entry);
4039 if (wgp == NULL)
4042 psref_target_destroy(&wgp->wgp_psref, wg_psref_class);
4044 wg_destroy_peer(wgp);
4054 struct wg_peer *wgp, *wgp0 __diagused;
4058 wgp = thmap_del(wg->wg_peers_byname, name, strlen(name));
4059 if (wgp != NULL) {
4060 wgp0 = thmap_del(wg->wg_peers_bypubkey, wgp->wgp_pubkey,
4061 sizeof(wgp->wgp_pubkey));
4062 KASSERT(wgp0 == wgp);
4065 WG_PEER_WRITER_REMOVE(wgp);
4069 mutex_enter(wgp->wgp_lock);
4070 pserialize_perform(wgp->wgp_psz);
4071 mutex_exit(wgp->wgp_lock);
4072 PSLIST_ENTRY_DESTROY(wgp, wgp_peerlist_entry);
4076 if (wgp == NULL)
4079 psref_target_destroy(&wgp->wgp_psref, wg_psref_class);
4081 wg_destroy_peer(wgp);
4282 struct wg_peer *wgp = NULL;
4304 wgp = wga->wga_peer;
4305 wg_get_peer(wgp, psref);
4309 return wgp;
4313 wg_fill_msg_data(struct wg_softc *wg, struct wg_peer *wgp,
4331 struct wg_peer *wgp = NULL;
4358 wgp = wg_pick_peer_by_sa(wg, dst, &wgp_psref);
4359 if (wgp == NULL) {
4374 M_SETCTX(m, wgp);
4387 M_SETCTX(m, wgp);
4401 wg_put_peer(wgp, &wgp_psref);
4408 wg_send_data(struct wg_peer *wgp, struct mbuf *m)
4415 wgsa = wg_get_endpoint_sa(wgp, &psref);
4416 so = wg_get_so_by_peer(wgp, wgsa);
4435 wg_put_sa(wgp, wgsa, &psref);
4466 wg_send_data_msg(struct wg_peer *wgp, struct wg_session *wgs, struct mbuf *m)
4468 struct wg_softc *wg = wgp->wgp_sc;
4508 wg_fill_msg_data(wg, wgp, wgs, wgmd);
4516 error = wg->wg_ops->send_data_msg(wgp, n); /* consumes n */
4562 wg_schedule_peer_task(wgp, WGP_TASK_SEND_INIT_MESSAGE);
4578 wg_schedule_peer_task(wgp, WGP_TASK_SEND_INIT_MESSAGE);
4687 struct wg_peer *wgp = wg_alloc_peer(wg);
4688 memcpy(wgp->wgp_pubkey, pubkey, sizeof(wgp->wgp_pubkey));
4690 strncpy(wgp->wgp_name, name, sizeof(wgp->wgp_name));
4693 if (psk_len != sizeof(wgp->wgp_psk)) {
4697 memcpy(wgp->wgp_psk, psk, sizeof(wgp->wgp_psk));
4702 struct wg_sockaddr *wgsa = wgp->wgp_endpoint;
4734 wgp->wgp_endpoint_available = true;
4746 struct wg_allowedip *wga = &wgp->wgp_allowedips[j];
4819 wga->wga_peer = wgp;
4827 wgp->wgp_n_allowedips = j;
4829 *wgpp = wgp;
4927 struct wg_peer *wgp = NULL, *wgp0 __diagused;
4937 error = wg_handle_prop_peer(wg, prop_dict, &wgp);
4942 if (thmap_get(wg->wg_peers_bypubkey, wgp->wgp_pubkey,
4943 sizeof(wgp->wgp_pubkey)) != NULL ||
4944 (wgp->wgp_name[0] &&
4945 thmap_get(wg->wg_peers_byname, wgp->wgp_name,
4946 strlen(wgp->wgp_name)) != NULL)) {
4948 wg_destroy_peer(wgp);
4952 wgp0 = thmap_put(wg->wg_peers_bypubkey, wgp->wgp_pubkey,
4953 sizeof(wgp->wgp_pubkey), wgp);
4954 KASSERT(wgp0 == wgp);
4955 if (wgp->wgp_name[0]) {
4956 wgp0 = thmap_put(wg->wg_peers_byname, wgp->wgp_name,
4957 strlen(wgp->wgp_name), wgp);
4958 KASSERT(wgp0 == wgp);
4960 WG_PEER_WRITER_INSERT_HEAD(wgp, wg);
5016 struct wg_peer *wgp;
5044 WG_PEER_READER_FOREACH(wgp, wg) {
5049 wg_get_peer(wgp, &wgp_psref);
5056 if (strlen(wgp->wgp_name) > 0) {
5058 wgp->wgp_name))
5063 wgp->wgp_pubkey, sizeof(wgp->wgp_pubkey)))
5067 if (!consttime_memequal(wgp->wgp_psk, psk_zero,
5068 sizeof(wgp->wgp_psk))) {
5072 wgp->wgp_psk, sizeof(wgp->wgp_psk)))
5077 wgsa = wg_get_endpoint_sa(wgp, &wgsa_psref);
5083 wg_put_sa(wgp, wgsa, &wgsa_psref);
5086 wg_put_sa(wgp, wgsa, &wgsa_psref);
5088 const struct timespec *t = &wgp->wgp_last_handshake_time;
5097 if (wgp->wgp_n_allowedips == 0)
5103 for (int j = 0; j < wgp->wgp_n_allowedips; j++) {
5104 struct wg_allowedip *wga = &wgp->wgp_allowedips[j];
5154 wg_put_peer(wgp, &wgp_psref);
5461 wg_send_user(struct wg_peer *wgp, struct mbuf *m, bool handshake)
5466 struct wg_softc *wg = wgp->wgp_sc;
5469 wgsa = wg_get_endpoint_sa(wgp, &psref);
5485 wg_put_sa(wgp, wgsa, &psref);
5493 wg_send_hs_user(struct wg_peer *wgp, struct mbuf *m)
5496 return wg_send_user(wgp, m, /*handshake*/true);
5500 wg_send_data_user(struct wg_peer *wgp, struct mbuf *m)
5503 return wg_send_user(wgp, m, /*handshake*/false);