sys/netlink/netlink_glue.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2023 Alexander V. Chernikov <melifaro@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/param.h>
  29 #include <sys/kernel.h>
  30 #include <sys/malloc.h>
  31 #include <sys/lock.h>
  32 #include <sys/rmlock.h>
  33 #include <sys/domain.h>
  34 #include <sys/mbuf.h>
  35 #include <sys/protosw.h>
  36 #include <sys/proc.h>
  37 #include <sys/ck.h>
  38 #include <sys/socket.h>
  39 #include <sys/socketvar.h>
  40 #include <sys/sysent.h>
  41 #include <sys/syslog.h>
  42 #include <sys/priv.h> /* priv_check */
  43
  44 #include <net/route.h>
  45 #include <net/route/route_ctl.h>
  46
  47 #include <netlink/netlink.h>
  48 #include <netlink/netlink_ctl.h>
  49 #include <netlink/netlink_var.h>
  50 #include <netlink/route/route_var.h>
  51
  52 /* Standard bits: built-in the kernel */
  53 SYSCTL_NODE(_net, OID_AUTO, netlink, CTLFLAG_RD, 0,
  54     "RFC3549 Netlink network state socket family");
  55 SYSCTL_NODE(_net_netlink, OID_AUTO, debug, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
  56     "Netlink per-subsystem debug levels");
  57
  58 MALLOC_DEFINE(M_NETLINK, "netlink", "Memory used for netlink packets");
  59
  60 /* Netlink-related callbacks needed to glue rtsock, netlink and linuxolator */
  61 static void
  62 ignore_route_event(uint32_t fibnum, const struct rib_cmd_info *rc)
  63 {
  64 }
  65
  66 static void
  67 ignore_ifmsg_event(struct ifnet *ifp, int if_flags_mask)
  68 {
  69 }
  70
  71 static struct rtbridge ignore_cb = {
  72         .route_f = ignore_route_event,
  73         .ifmsg_f = ignore_ifmsg_event,
  74 };
  75
  76 void *linux_netlink_p = NULL; /* Callback pointer for Linux translator functions */
  77 struct rtbridge *rtsock_callback_p = &ignore_cb;
  78 struct rtbridge *netlink_callback_p = &ignore_cb;
  79
  80
  81 /*
  82  * nlp accessors.
  83  * TODO: move to a separate file once the number grows.
  84  */
  85 bool
  86 nlp_has_priv(struct nlpcb *nlp, int priv)
  87 {
  88         return (priv_check_cred(nlp->nl_cred, priv) == 0);
  89 }
  90
  91 struct ucred *
  92 nlp_get_cred(struct nlpcb *nlp)
  93 {
  94         return (nlp->nl_cred);
  95 }
  96
  97 uint32_t
  98 nlp_get_pid(const struct nlpcb *nlp)
  99 {
 100         return (nlp->nl_process_id);
 101 }
 102
 103 bool
 104 nlp_unconstrained_vnet(const struct nlpcb *nlp)
 105 {
 106         return (nlp->nl_unconstrained_vnet);
 107 }
 108
 109 #ifndef NETLINK
 110 /* Stub implementations for the loadable functions */
 111
 112 static bool
 113 get_stub_writer(struct nl_writer *nw)
 114 {
 115         bzero(nw, sizeof(*nw));
 116         nw->enomem = true;
 117
 118         return (false);
 119 }
 120
 121 static bool
 122 nlmsg_get_unicast_writer_stub(struct nl_writer *nw, int size, struct nlpcb *nlp)
 123 {
 124         return (get_stub_writer(nw));
 125 }
 126
 127 static bool
 128 nlmsg_get_group_writer_stub(struct nl_writer *nw, int size, int protocol, int group_id)
 129 {
 130         return (get_stub_writer(nw));
 131 }
 132
 133 static bool
 134 nlmsg_get_chain_writer_stub(struct nl_writer *nw, int size, struct mbuf **pm)
 135 {
 136         return (get_stub_writer(nw));
 137 }
 138
 139 static bool
 140 nlmsg_flush_stub(struct nl_writer *nw __unused)
 141 {
 142         return (false);
 143 }
 144
 145 static void
 146 nlmsg_ignore_limit_stub(struct nl_writer *nw __unused)
 147 {
 148 }
 149
 150 static bool
 151 nlmsg_refill_buffer_stub(struct nl_writer *nw __unused, int required_len __unused)
 152 {
 153         return (false);
 154 }
 155
 156 static bool
 157 nlmsg_add_stub(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
 158     uint16_t flags, uint32_t len)
 159 {
 160         return (false);
 161 }
 162
 163 static bool
 164 nlmsg_end_stub(struct nl_writer *nw __unused)
 165 {
 166         return (false);
 167 }
 168
 169 static void
 170 nlmsg_abort_stub(struct nl_writer *nw __unused)
 171 {
 172 }
 173
 174 static bool
 175 nlmsg_end_dump_stub(struct nl_writer *nw, int error, struct nlmsghdr *hdr)
 176 {
 177         return (false);
 178 }
 179
 180 static int
 181 nl_modify_ifp_generic_stub(struct ifnet *ifp __unused,
 182     struct nl_parsed_link *lattrs __unused, const struct nlattr_bmask *bm __unused,
 183     struct nl_pstate *npt __unused)
 184 {
 185         return (ENOTSUP);
 186 }
 187
 188 static void
 189 nl_store_ifp_cookie_stub(struct nl_pstate *npt __unused, struct ifnet *ifp __unused)
 190 {
 191 }
 192
 193 static struct nlpcb *
 194 nl_get_thread_nlp_stub(struct thread *td __unused)
 195 {
 196         return (NULL);
 197 }
 198
 199 const static struct nl_function_wrapper nl_stub = {
 200         .nlmsg_add = nlmsg_add_stub,
 201         .nlmsg_refill_buffer = nlmsg_refill_buffer_stub,
 202         .nlmsg_flush = nlmsg_flush_stub,
 203         .nlmsg_end = nlmsg_end_stub,
 204         .nlmsg_abort = nlmsg_abort_stub,
 205         .nlmsg_ignore_limit = nlmsg_ignore_limit_stub,
 206         .nlmsg_get_unicast_writer = nlmsg_get_unicast_writer_stub,
 207         .nlmsg_get_group_writer = nlmsg_get_group_writer_stub,
 208         .nlmsg_get_chain_writer = nlmsg_get_chain_writer_stub,
 209         .nlmsg_end_dump = nlmsg_end_dump_stub,
 210         .nl_modify_ifp_generic = nl_modify_ifp_generic_stub,
 211         .nl_store_ifp_cookie = nl_store_ifp_cookie_stub,
 212         .nl_get_thread_nlp = nl_get_thread_nlp_stub,
 213 };
 214
 215 /*
 216  * If the kernel is compiled with netlink as a module,
 217  *  provide a way to introduce non-stub functioms
 218  */
 219 static const struct nl_function_wrapper *_nl = &nl_stub;
 220
 221 void
 222 nl_set_functions(const struct nl_function_wrapper *nl)
 223 {
 224         _nl = (nl != NULL) ? nl : &nl_stub;
 225 }
 226
 227 /* Function wrappers */
 228 bool
 229 nlmsg_get_unicast_writer(struct nl_writer *nw, int size, struct nlpcb *nlp)
 230 {
 231         return (_nl->nlmsg_get_unicast_writer(nw, size, nlp));
 232 }
 233
 234 bool
 235 nlmsg_get_group_writer(struct nl_writer *nw, int size, int protocol, int group_id)
 236 {
 237         return (_nl->nlmsg_get_group_writer(nw, size, protocol, group_id));
 238 }
 239
 240 bool
 241 nlmsg_get_chain_writer(struct nl_writer *nw, int size, struct mbuf **pm)
 242 {
 243         return (_nl->nlmsg_get_chain_writer(nw, size, pm));
 244 }
 245
 246 bool
 247 nlmsg_flush(struct nl_writer *nw)
 248 {
 249         return (_nl->nlmsg_flush(nw));
 250 }
 251
 252 void nlmsg_ignore_limit(struct nl_writer *nw)
 253 {
 254         _nl->nlmsg_ignore_limit(nw);
 255 }
 256
 257 bool
 258 nlmsg_refill_buffer(struct nl_writer *nw, int required_len)
 259 {
 260         return (_nl->nlmsg_refill_buffer(nw, required_len));
 261 }
 262
 263 bool
 264 nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
 265     uint16_t flags, uint32_t len)
 266 {
 267         return (_nl->nlmsg_add(nw, portid, seq, type, flags, len));
 268 }
 269
 270 bool
 271 nlmsg_end(struct nl_writer *nw)
 272 {
 273         return (_nl->nlmsg_end(nw));
 274 }
 275
 276 void
 277 nlmsg_abort(struct nl_writer *nw)
 278 {
 279         _nl->nlmsg_abort(nw);
 280 }
 281
 282 bool
 283 nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr)
 284 {
 285         return (_nl->nlmsg_end_dump(nw, error, hdr));
 286 }
 287
 288 int
 289 nl_modify_ifp_generic(struct ifnet *ifp, struct nl_parsed_link *lattrs,
 290     const struct nlattr_bmask *bm , struct nl_pstate *npt)
 291 {
 292         return (_nl->nl_modify_ifp_generic(ifp, lattrs, bm, npt));
 293 }
 294
 295 void
 296 nl_store_ifp_cookie(struct nl_pstate *npt, struct ifnet *ifp)
 297 {
 298         return (_nl->nl_store_ifp_cookie(npt, ifp));
 299 }
 300
 301 struct nlpcb *
 302 nl_get_thread_nlp(struct thread *td)
 303 {
 304         return (_nl->nl_get_thread_nlp(td));
 305 }
 306
 307 #endif /* !NETLINK */
 308