sys/netlink/netlink_domain.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2021 Ng Peng Nam Sean
   5  * Copyright (c) 2022 Alexander V. Chernikov <melifaro@FreeBSD.org>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * This file contains socket and protocol bindings for netlink.
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/kernel.h>
  35 #include <sys/malloc.h>
  36 #include <sys/lock.h>
  37 #include <sys/rmlock.h>
  38 #include <sys/domain.h>
  39 #include <sys/mbuf.h>
  40 #include <sys/protosw.h>
  41 #include <sys/proc.h>
  42 #include <sys/ck.h>
  43 #include <sys/socket.h>
  44 #include <sys/socketvar.h>
  45 #include <sys/sysent.h>
  46 #include <sys/syslog.h>
  47 #include <sys/priv.h> /* priv_check */
  48
  49 #include <netlink/netlink.h>
  50 #include <netlink/netlink_ctl.h>
  51 #include <netlink/netlink_var.h>
  52
  53 #define DEBUG_MOD_NAME  nl_domain
  54 #define DEBUG_MAX_LEVEL LOG_DEBUG3
  55 #include <netlink/netlink_debug.h>
  56 _DECLARE_DEBUG(LOG_DEBUG);
  57
  58 _Static_assert((NLP_MAX_GROUPS % 64) == 0,
  59     "NLP_MAX_GROUPS has to be multiple of 64");
  60 _Static_assert(NLP_MAX_GROUPS >= 64,
  61     "NLP_MAX_GROUPS has to be at least 64");
  62
  63 #define NLCTL_TRACKER           struct rm_priotracker nl_tracker
  64 #define NLCTL_RLOCK(_ctl)       rm_rlock(&((_ctl)->ctl_lock), &nl_tracker)
  65 #define NLCTL_RUNLOCK(_ctl)     rm_runlock(&((_ctl)->ctl_lock), &nl_tracker)
  66
  67 #define NLCTL_WLOCK(_ctl)       rm_wlock(&((_ctl)->ctl_lock))
  68 #define NLCTL_WUNLOCK(_ctl)     rm_wunlock(&((_ctl)->ctl_lock))
  69
  70 static u_long nl_sendspace = NLSNDQ;
  71 SYSCTL_ULONG(_net_netlink, OID_AUTO, sendspace, CTLFLAG_RW, &nl_sendspace, 0,
  72     "Default netlink socket send space");
  73
  74 static u_long nl_recvspace = NLSNDQ;
  75 SYSCTL_ULONG(_net_netlink, OID_AUTO, recvspace, CTLFLAG_RW, &nl_recvspace, 0,
  76     "Default netlink socket receive space");
  77
  78 extern u_long sb_max_adj;
  79 static u_long nl_maxsockbuf = 512 * 1024 * 1024; /* 512M, XXX: init based on physmem */
  80 static int sysctl_handle_nl_maxsockbuf(SYSCTL_HANDLER_ARGS);
  81 SYSCTL_OID(_net_netlink, OID_AUTO, nl_maxsockbuf,
  82     CTLTYPE_ULONG | CTLFLAG_RW | CTLFLAG_MPSAFE, &nl_maxsockbuf, 0,
  83     sysctl_handle_nl_maxsockbuf, "LU",
  84     "Maximum Netlink socket buffer size");
  85
  86 uint32_t
  87 nlp_get_pid(const struct nlpcb *nlp)
  88 {
  89         return (nlp->nl_process_id);
  90 }
  91
  92 /*
  93  * Looks up a nlpcb struct based on the @portid. Need to claim nlsock_mtx.
  94  * Returns nlpcb pointer if present else NULL
  95  */
  96 static struct nlpcb *
  97 nl_port_lookup(uint32_t port_id)
  98 {
  99         struct nlpcb *nlp;
 100
 101         CK_LIST_FOREACH(nlp, &V_nl_ctl->ctl_port_head, nl_port_next) {
 102                 if (nlp->nl_port == port_id)
 103                         return (nlp);
 104         }
 105         return (NULL);
 106 }
 107
 108 static void
 109 nl_add_group_locked(struct nlpcb *nlp, unsigned int group_id)
 110 {
 111         MPASS(group_id <= NLP_MAX_GROUPS);
 112         --group_id;
 113
 114         nlp->nl_groups[group_id / 64] |= (uint64_t)1 << (group_id % 64);
 115 }
 116
 117 static void
 118 nl_del_group_locked(struct nlpcb *nlp, unsigned int group_id)
 119 {
 120         MPASS(group_id <= NLP_MAX_GROUPS);
 121         --group_id;
 122
 123         nlp->nl_groups[group_id / 64] &= ~((uint64_t)1 << (group_id % 64));
 124 }
 125
 126 static bool
 127 nl_isset_group_locked(struct nlpcb *nlp, unsigned int group_id)
 128 {
 129         MPASS(group_id <= NLP_MAX_GROUPS);
 130         --group_id;
 131
 132         return (nlp->nl_groups[group_id / 64] & ((uint64_t)1 << (group_id % 64)));
 133 }
 134
 135 static uint32_t
 136 nl_get_groups_compat(struct nlpcb *nlp)
 137 {
 138         uint32_t groups_mask = 0;
 139
 140         for (int i = 0; i < 32; i++) {
 141                 if (nl_isset_group_locked(nlp, i + 1))
 142                         groups_mask |= (1 << i);
 143         }
 144
 145         return (groups_mask);
 146 }
 147
 148 /*
 149  * Broadcasts message @m to the protocol @proto group specified by @group_id
 150  */
 151 void
 152 nl_send_group(struct mbuf *m, int num_messages, int proto, int group_id)
 153 {
 154         struct nlpcb *nlp_last = NULL;
 155         struct nlpcb *nlp;
 156         NLCTL_TRACKER;
 157
 158         IF_DEBUG_LEVEL(LOG_DEBUG2) {
 159                 struct nlmsghdr *hdr = mtod(m, struct nlmsghdr *);
 160                 NL_LOG(LOG_DEBUG2, "MCAST mbuf len %u msg type %d len %u to group %d/%d",
 161                     m->m_len, hdr->nlmsg_type, hdr->nlmsg_len, proto, group_id);
 162         }
 163
 164         struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl);
 165         if (__predict_false(ctl == NULL)) {
 166                 /*
 167                  * Can be the case when notification is sent within VNET
 168                  * which doesn't have any netlink sockets.
 169                  */
 170                 m_freem(m);
 171                 return;
 172         }
 173
 174         NLCTL_RLOCK(ctl);
 175
 176         int io_flags = NL_IOF_UNTRANSLATED;
 177
 178         CK_LIST_FOREACH(nlp, &ctl->ctl_pcb_head, nl_next) {
 179                 if (nl_isset_group_locked(nlp, group_id) && nlp->nl_proto == proto) {
 180                         if (nlp_last != NULL) {
 181                                 struct mbuf *m_copy;
 182                                 m_copy = m_copym(m, 0, M_COPYALL, M_NOWAIT);
 183                                 if (m_copy != NULL)
 184                                         nl_send_one(m_copy, nlp_last, num_messages, io_flags);
 185                                 else {
 186                                         NLP_LOCK(nlp_last);
 187                                         if (nlp_last->nl_socket != NULL)
 188                                                 sorwakeup(nlp_last->nl_socket);
 189                                         NLP_UNLOCK(nlp_last);
 190                                 }
 191                         }
 192                         nlp_last = nlp;
 193                 }
 194         }
 195         if (nlp_last != NULL)
 196                 nl_send_one(m, nlp_last, num_messages, io_flags);
 197         else
 198                 m_freem(m);
 199
 200         NLCTL_RUNLOCK(ctl);
 201 }
 202
 203 bool
 204 nl_has_listeners(int netlink_family, uint32_t groups_mask)
 205 {
 206         return (V_nl_ctl != NULL);
 207 }
 208
 209 bool
 210 nlp_has_priv(struct nlpcb *nlp, int priv)
 211 {
 212         return (priv_check_cred(nlp->nl_cred, priv) == 0);
 213 }
 214
 215 struct ucred *
 216 nlp_get_cred(struct nlpcb *nlp)
 217 {
 218         return (nlp->nl_cred);
 219 }
 220
 221 static uint32_t
 222 nl_find_port(void)
 223 {
 224         /*
 225          * app can open multiple netlink sockets.
 226          * Start with current pid, if already taken,
 227          * try random numbers in 65k..256k+65k space,
 228          * avoiding clash with pids.
 229          */
 230         if (nl_port_lookup(curproc->p_pid) == NULL)
 231                 return (curproc->p_pid);
 232         for (int i = 0; i < 16; i++) {
 233                 uint32_t nl_port = (arc4random() % 65536) + 65536 * 4;
 234                 if (nl_port_lookup(nl_port) == 0)
 235                         return (nl_port);
 236                 NL_LOG(LOG_DEBUG3, "tried %u\n", nl_port);
 237         }
 238         return (curproc->p_pid);
 239 }
 240
 241 static int
 242 nl_bind_locked(struct nlpcb *nlp, struct sockaddr_nl *snl)
 243 {
 244         if (nlp->nl_bound) {
 245                 if (nlp->nl_port != snl->nl_pid) {
 246                         NL_LOG(LOG_DEBUG,
 247                             "bind() failed: program pid %d "
 248                             "is different from provided pid %d",
 249                             nlp->nl_port, snl->nl_pid);
 250                         return (EINVAL); // XXX: better error
 251                 }
 252         } else {
 253                 if (snl->nl_pid == 0)
 254                         snl->nl_pid = nl_find_port();
 255                 if (nl_port_lookup(snl->nl_pid) != NULL)
 256                         return (EADDRINUSE);
 257                 nlp->nl_port = snl->nl_pid;
 258                 nlp->nl_bound = true;
 259                 CK_LIST_INSERT_HEAD(&V_nl_ctl->ctl_port_head, nlp, nl_port_next);
 260         }
 261         for (int i = 0; i < 32; i++) {
 262                 if (snl->nl_groups & ((uint32_t)1 << i))
 263                         nl_add_group_locked(nlp, i + 1);
 264                 else
 265                         nl_del_group_locked(nlp, i + 1);
 266         }
 267
 268         return (0);
 269 }
 270
 271 static int
 272 nl_pru_attach(struct socket *so, int proto, struct thread *td)
 273 {
 274         struct nlpcb *nlp;
 275         int error;
 276
 277         if (__predict_false(netlink_unloading != 0))
 278                 return (EAFNOSUPPORT);
 279
 280         error = nl_verify_proto(proto);
 281         if (error != 0)
 282                 return (error);
 283
 284         bool is_linux = SV_PROC_ABI(td->td_proc) == SV_ABI_LINUX;
 285         NL_LOG(LOG_DEBUG2, "socket %p, %sPID %d: attaching socket to %s",
 286             so, is_linux ? "(linux) " : "", curproc->p_pid,
 287             nl_get_proto_name(proto));
 288
 289         /* Create per-VNET state on first socket init */
 290         struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl);
 291         if (ctl == NULL)
 292                 ctl = vnet_nl_ctl_init();
 293         KASSERT(V_nl_ctl != NULL, ("nl_attach: vnet_sock_init() failed"));
 294
 295         MPASS(sotonlpcb(so) == NULL);
 296
 297         nlp = malloc(sizeof(struct nlpcb), M_PCB, M_WAITOK | M_ZERO);
 298         error = soreserve(so, nl_sendspace, nl_recvspace);
 299         if (error != 0) {
 300                 free(nlp, M_PCB);
 301                 return (error);
 302         }
 303         so->so_pcb = nlp;
 304         nlp->nl_socket = so;
 305         /* Copy so_cred to avoid having socket_var.h in every header */
 306         nlp->nl_cred = so->so_cred;
 307         nlp->nl_proto = proto;
 308         nlp->nl_process_id = curproc->p_pid;
 309         nlp->nl_linux = is_linux;
 310         nlp->nl_active = true;
 311         NLP_LOCK_INIT(nlp);
 312         refcount_init(&nlp->nl_refcount, 1);
 313         nl_init_io(nlp);
 314
 315         nlp->nl_taskqueue = taskqueue_create("netlink_socket", M_WAITOK,
 316             taskqueue_thread_enqueue, &nlp->nl_taskqueue);
 317         TASK_INIT(&nlp->nl_task, 0, nl_taskqueue_handler, nlp);
 318         taskqueue_start_threads(&nlp->nl_taskqueue, 1, PWAIT,
 319             "netlink_socket (PID %u)", nlp->nl_process_id);
 320
 321         NLCTL_WLOCK(ctl);
 322         /* XXX: check ctl is still alive */
 323         CK_LIST_INSERT_HEAD(&ctl->ctl_pcb_head, nlp, nl_next);
 324         NLCTL_WUNLOCK(ctl);
 325
 326         soisconnected(so);
 327
 328         return (0);
 329 }
 330
 331 static void
 332 nl_pru_abort(struct socket *so)
 333 {
 334         NL_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid);
 335         MPASS(sotonlpcb(so) != NULL);
 336         soisdisconnected(so);
 337 }
 338
 339 static int
 340 nl_pru_bind(struct socket *so, struct sockaddr *sa, struct thread *td)
 341 {
 342         struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl);
 343         struct nlpcb *nlp = sotonlpcb(so);
 344         struct sockaddr_nl *snl = (struct sockaddr_nl *)sa;
 345         int error;
 346
 347         NL_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid);
 348         if (snl->nl_len != sizeof(*snl)) {
 349                 NL_LOG(LOG_DEBUG, "socket %p, wrong sizeof(), ignoring bind()", so);
 350                 return (EINVAL);
 351         }
 352
 353
 354         NLCTL_WLOCK(ctl);
 355         NLP_LOCK(nlp);
 356         error = nl_bind_locked(nlp, snl);
 357         NLP_UNLOCK(nlp);
 358         NLCTL_WUNLOCK(ctl);
 359         NL_LOG(LOG_DEBUG2, "socket %p, bind() to %u, groups %u, error %d", so,
 360             snl->nl_pid, snl->nl_groups, error);
 361
 362         return (error);
 363 }
 364
 365
 366 static int
 367 nl_assign_port(struct nlpcb *nlp, uint32_t port_id)
 368 {
 369         struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl);
 370         struct sockaddr_nl snl = {
 371                 .nl_pid = port_id,
 372         };
 373         int error;
 374
 375         NLCTL_WLOCK(ctl);
 376         NLP_LOCK(nlp);
 377         snl.nl_groups = nl_get_groups_compat(nlp);
 378         error = nl_bind_locked(nlp, &snl);
 379         NLP_UNLOCK(nlp);
 380         NLCTL_WUNLOCK(ctl);
 381
 382         NL_LOG(LOG_DEBUG3, "socket %p, port assign: %d, error: %d", nlp->nl_socket, port_id, error);
 383         return (error);
 384 }
 385
 386 /*
 387  * nl_autobind_port binds a unused portid to @nlp
 388  * @nlp: pcb data for the netlink socket
 389  * @candidate_id: first id to consider
 390  */
 391 static int
 392 nl_autobind_port(struct nlpcb *nlp, uint32_t candidate_id)
 393 {
 394         struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl);
 395         uint32_t port_id = candidate_id;
 396         NLCTL_TRACKER;
 397         bool exist;
 398         int error = EADDRINUSE;
 399
 400         for (int i = 0; i < 10; i++) {
 401                 NL_LOG(LOG_DEBUG3, "socket %p, trying to assign port %d", nlp->nl_socket, port_id);
 402                 NLCTL_RLOCK(ctl);
 403                 exist = nl_port_lookup(port_id) != 0;
 404                 NLCTL_RUNLOCK(ctl);
 405                 if (!exist) {
 406                         error = nl_assign_port(nlp, port_id);
 407                         if (error != EADDRINUSE)
 408                                 break;
 409                 }
 410                 port_id++;
 411         }
 412         NL_LOG(LOG_DEBUG3, "socket %p, autobind to %d, error: %d", nlp->nl_socket, port_id, error);
 413         return (error);
 414 }
 415
 416 static int
 417 nl_pru_connect(struct socket *so, struct sockaddr *sa, struct thread *td)
 418 {
 419         struct sockaddr_nl *snl = (struct sockaddr_nl *)sa;
 420         struct nlpcb *nlp;
 421
 422         NL_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid);
 423         if (snl->nl_len != sizeof(*snl)) {
 424                 NL_LOG(LOG_DEBUG, "socket %p, wrong sizeof(), ignoring bind()", so);
 425                 return (EINVAL);
 426         }
 427
 428         nlp = sotonlpcb(so);
 429         if (!nlp->nl_bound) {
 430                 int error = nl_autobind_port(nlp, td->td_proc->p_pid);
 431                 if (error != 0) {
 432                         NL_LOG(LOG_DEBUG, "socket %p, nl_autobind() failed: %d", so, error);
 433                         return (error);
 434                 }
 435         }
 436         /* XXX: Handle socket flags & multicast */
 437         soisconnected(so);
 438
 439         NL_LOG(LOG_DEBUG2, "socket %p, connect to %u", so, snl->nl_pid);
 440
 441         return (0);
 442 }
 443
 444 static void
 445 destroy_nlpcb(struct nlpcb *nlp)
 446 {
 447         NLP_LOCK(nlp);
 448         nl_free_io(nlp);
 449         NLP_LOCK_DESTROY(nlp);
 450         free(nlp, M_PCB);
 451 }
 452
 453 static void
 454 destroy_nlpcb_epoch(epoch_context_t ctx)
 455 {
 456         struct nlpcb *nlp;
 457
 458         nlp = __containerof(ctx, struct nlpcb, nl_epoch_ctx);
 459
 460         destroy_nlpcb(nlp);
 461 }
 462
 463
 464 static void
 465 nl_pru_detach(struct socket *so)
 466 {
 467         struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl);
 468         MPASS(sotonlpcb(so) != NULL);
 469         struct nlpcb *nlp;
 470
 471         NL_LOG(LOG_DEBUG2, "detaching socket %p, PID %d", so, curproc->p_pid);
 472         nlp = sotonlpcb(so);
 473
 474         /* Mark as inactive so no new work can be enqueued */
 475         NLP_LOCK(nlp);
 476         bool was_bound = nlp->nl_bound;
 477         nlp->nl_active = false;
 478         NLP_UNLOCK(nlp);
 479
 480         /* Wait till all scheduled work has been completed  */
 481         taskqueue_drain_all(nlp->nl_taskqueue);
 482         taskqueue_free(nlp->nl_taskqueue);
 483
 484         NLCTL_WLOCK(ctl);
 485         NLP_LOCK(nlp);
 486         if (was_bound) {
 487                 CK_LIST_REMOVE(nlp, nl_port_next);
 488                 NL_LOG(LOG_DEBUG3, "socket %p, unlinking bound pid %u", so, nlp->nl_port);
 489         }
 490         CK_LIST_REMOVE(nlp, nl_next);
 491         nlp->nl_socket = NULL;
 492         NLP_UNLOCK(nlp);
 493         NLCTL_WUNLOCK(ctl);
 494
 495         so->so_pcb = NULL;
 496
 497         NL_LOG(LOG_DEBUG3, "socket %p, detached", so);
 498
 499         /* XXX: is delayed free needed? */
 500         NET_EPOCH_CALL(destroy_nlpcb_epoch, &nlp->nl_epoch_ctx);
 501 }
 502
 503 static int
 504 nl_pru_disconnect(struct socket *so)
 505 {
 506         NL_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid);
 507         MPASS(sotonlpcb(so) != NULL);
 508         return (ENOTCONN);
 509 }
 510
 511 static int
 512 nl_pru_peeraddr(struct socket *so, struct sockaddr **sa)
 513 {
 514         NL_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid);
 515         MPASS(sotonlpcb(so) != NULL);
 516         return (ENOTCONN);
 517 }
 518
 519 static int
 520 nl_pru_shutdown(struct socket *so)
 521 {
 522         NL_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid);
 523         MPASS(sotonlpcb(so) != NULL);
 524         socantsendmore(so);
 525         return (0);
 526 }
 527
 528 static int
 529 nl_pru_sockaddr(struct socket *so, struct sockaddr **sa)
 530 {
 531         struct sockaddr_nl *snl;
 532
 533         snl = malloc(sizeof(struct sockaddr_nl), M_SONAME, M_WAITOK | M_ZERO);
 534         /* TODO: set other fields */
 535         snl->nl_len = sizeof(struct sockaddr_nl);
 536         snl->nl_family = AF_NETLINK;
 537         snl->nl_pid = sotonlpcb(so)->nl_port;
 538         *sa = (struct sockaddr *)snl;
 539         return (0);
 540 }
 541
 542 static void
 543 nl_pru_close(struct socket *so)
 544 {
 545         NL_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid);
 546         MPASS(sotonlpcb(so) != NULL);
 547         soisdisconnected(so);
 548 }
 549
 550 static int
 551 nl_pru_output(struct mbuf *m, struct socket *so, ...)
 552 {
 553
 554         if (__predict_false(m == NULL ||
 555             ((m->m_len < sizeof(struct nlmsghdr)) &&
 556                 (m = m_pullup(m, sizeof(struct nlmsghdr))) == NULL)))
 557                 return (ENOBUFS);
 558         MPASS((m->m_flags & M_PKTHDR) != 0);
 559
 560         NL_LOG(LOG_DEBUG3, "sending message to kernel async processing");
 561         nl_receive_async(m, so);
 562         return (0);
 563 }
 564
 565
 566 static int
 567 nl_pru_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *sa,
 568     struct mbuf *control, struct thread *td)
 569 {
 570         NL_LOG(LOG_DEBUG2, "sending message to kernel");
 571
 572         if (__predict_false(control != NULL)) {
 573                 if (control->m_len) {
 574                         m_freem(control);
 575                         return (EINVAL);
 576                 }
 577                 m_freem(control);
 578         }
 579
 580         return (nl_pru_output(m, so));
 581 }
 582
 583 static int
 584 nl_pru_rcvd(struct socket *so, int flags)
 585 {
 586         NL_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid);
 587         MPASS(sotonlpcb(so) != NULL);
 588
 589         nl_on_transmit(sotonlpcb(so));
 590
 591         return (0);
 592 }
 593
 594 static int
 595 nl_getoptflag(int sopt_name)
 596 {
 597         switch (sopt_name) {
 598         case NETLINK_CAP_ACK:
 599                 return (NLF_CAP_ACK);
 600         case NETLINK_EXT_ACK:
 601                 return (NLF_EXT_ACK);
 602         case NETLINK_GET_STRICT_CHK:
 603                 return (NLF_STRICT);
 604         }
 605
 606         return (0);
 607 }
 608
 609 static int
 610 nl_ctloutput(struct socket *so, struct sockopt *sopt)
 611 {
 612         struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl);
 613         struct nlpcb *nlp = sotonlpcb(so);
 614         uint32_t flag;
 615         int optval, error = 0;
 616         NLCTL_TRACKER;
 617
 618         NL_LOG(LOG_DEBUG2, "%ssockopt(%p, %d)", (sopt->sopt_dir) ? "set" : "get",
 619             so, sopt->sopt_name);
 620
 621         switch (sopt->sopt_dir) {
 622         case SOPT_SET:
 623                 switch (sopt->sopt_name) {
 624                 case NETLINK_ADD_MEMBERSHIP:
 625                 case NETLINK_DROP_MEMBERSHIP:
 626                         error = sooptcopyin(sopt, &optval, sizeof(optval), sizeof(optval));
 627                         if (error != 0)
 628                                 break;
 629                         if (optval <= 0 || optval >= NLP_MAX_GROUPS) {
 630                                 error = ERANGE;
 631                                 break;
 632                         }
 633                         NL_LOG(LOG_DEBUG2, "ADD/DEL group %d", (uint32_t)optval);
 634
 635                         NLCTL_WLOCK(ctl);
 636                         if (sopt->sopt_name == NETLINK_ADD_MEMBERSHIP)
 637                                 nl_add_group_locked(nlp, optval);
 638                         else
 639                                 nl_del_group_locked(nlp, optval);
 640                         NLCTL_WUNLOCK(ctl);
 641                         break;
 642                 case NETLINK_CAP_ACK:
 643                 case NETLINK_EXT_ACK:
 644                 case NETLINK_GET_STRICT_CHK:
 645                         error = sooptcopyin(sopt, &optval, sizeof(optval), sizeof(optval));
 646                         if (error != 0)
 647                                 break;
 648
 649                         flag = nl_getoptflag(sopt->sopt_name);
 650
 651                         NLCTL_WLOCK(ctl);
 652                         if (optval != 0)
 653                                 nlp->nl_flags |= flag;
 654                         else
 655                                 nlp->nl_flags &= ~flag;
 656                         NLCTL_WUNLOCK(ctl);
 657                         break;
 658                 default:
 659                         error = ENOPROTOOPT;
 660                 }
 661                 break;
 662         case SOPT_GET:
 663                 switch (sopt->sopt_name) {
 664                 case NETLINK_LIST_MEMBERSHIPS:
 665                         NLCTL_RLOCK(ctl);
 666                         optval = nl_get_groups_compat(nlp);
 667                         NLCTL_RUNLOCK(ctl);
 668                         error = sooptcopyout(sopt, &optval, sizeof(optval));
 669                         break;
 670                 case NETLINK_CAP_ACK:
 671                 case NETLINK_EXT_ACK:
 672                 case NETLINK_GET_STRICT_CHK:
 673                         NLCTL_RLOCK(ctl);
 674                         optval = (nlp->nl_flags & nl_getoptflag(sopt->sopt_name)) != 0;
 675                         NLCTL_RUNLOCK(ctl);
 676                         error = sooptcopyout(sopt, &optval, sizeof(optval));
 677                         break;
 678                 default:
 679                         error = ENOPROTOOPT;
 680                 }
 681                 break;
 682         default:
 683                 error = ENOPROTOOPT;
 684         }
 685
 686         return (error);
 687 }
 688
 689 static int
 690 sysctl_handle_nl_maxsockbuf(SYSCTL_HANDLER_ARGS)
 691 {
 692         int error = 0;
 693         u_long tmp_maxsockbuf = nl_maxsockbuf;
 694
 695         error = sysctl_handle_long(oidp, &tmp_maxsockbuf, arg2, req);
 696         if (error || !req->newptr)
 697                 return (error);
 698         if (tmp_maxsockbuf < MSIZE + MCLBYTES)
 699                 return (EINVAL);
 700         nl_maxsockbuf = tmp_maxsockbuf;
 701
 702         return (0);
 703 }
 704
 705 static int
 706 nl_setsbopt(struct socket *so, struct sockopt *sopt)
 707 {
 708         int error, optval;
 709         bool result;
 710
 711         if (sopt->sopt_name != SO_RCVBUF)
 712                 return (sbsetopt(so, sopt));
 713
 714         /* Allow to override max buffer size in certain conditions */
 715
 716         error = sooptcopyin(sopt, &optval, sizeof optval, sizeof optval);
 717         if (error != 0)
 718                 return (error);
 719         NL_LOG(LOG_DEBUG2, "socket %p, PID %d, SO_RCVBUF=%d", so, curproc->p_pid, optval);
 720         if (optval > sb_max_adj) {
 721                 if (priv_check(curthread, PRIV_NET_ROUTE) != 0)
 722                         return (EPERM);
 723         }
 724
 725         SOCK_RECVBUF_LOCK(so);
 726         result = sbreserve_locked_limit(so, SO_RCV, optval, nl_maxsockbuf, curthread);
 727         SOCK_RECVBUF_UNLOCK(so);
 728
 729         return (result ? 0 : ENOBUFS);
 730 }
 731
 732 #define NETLINK_PROTOSW                                         \
 733         .pr_flags = PR_ATOMIC | PR_ADDR | PR_WANTRCVD,          \
 734         .pr_ctloutput = nl_ctloutput,                           \
 735         .pr_setsbopt = nl_setsbopt,                             \
 736         .pr_abort = nl_pru_abort,                               \
 737         .pr_attach = nl_pru_attach,                             \
 738         .pr_bind = nl_pru_bind,                                 \
 739         .pr_connect = nl_pru_connect,                           \
 740         .pr_detach = nl_pru_detach,                             \
 741         .pr_disconnect = nl_pru_disconnect,                     \
 742         .pr_peeraddr = nl_pru_peeraddr,                         \
 743         .pr_send = nl_pru_send,                                 \
 744         .pr_rcvd = nl_pru_rcvd,                                 \
 745         .pr_shutdown = nl_pru_shutdown,                         \
 746         .pr_sockaddr = nl_pru_sockaddr,                         \
 747         .pr_close = nl_pru_close
 748
 749 static struct protosw netlink_raw_sw = {
 750         .pr_type = SOCK_RAW,
 751         NETLINK_PROTOSW
 752 };
 753
 754 static struct protosw netlink_dgram_sw = {
 755         .pr_type = SOCK_DGRAM,
 756         NETLINK_PROTOSW
 757 };
 758
 759 static struct domain netlinkdomain = {
 760         .dom_family = PF_NETLINK,
 761         .dom_name = "netlink",
 762         .dom_flags = DOMF_UNLOADABLE,
 763         .dom_nprotosw =         2,
 764         .dom_protosw =          { &netlink_raw_sw, &netlink_dgram_sw },
 765 };
 766
 767 DOMAIN_SET(netlink);