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 "opt_netlink.h"
  29
  30 #include <sys/param.h>
  31 #include <sys/kernel.h>
  32 #include <sys/malloc.h>
  33 #include <sys/lock.h>
  34 #include <sys/rmlock.h>
  35 #include <sys/domain.h>
  36 #include <sys/mbuf.h>
  37 #include <sys/protosw.h>
  38 #include <sys/proc.h>
  39 #include <sys/ck.h>
  40 #include <sys/socket.h>
  41 #include <sys/socketvar.h>
  42 #include <sys/sysent.h>
  43 #include <sys/syslog.h>
  44 #include <sys/priv.h> /* priv_check */
  45
  46 #include <net/route.h>
  47 #include <net/route/route_ctl.h>
  48
  49 #include <netlink/netlink.h>
  50 #include <netlink/netlink_ctl.h>
  51 #include <netlink/netlink_var.h>
  52 #include <netlink/route/route_var.h>
  53
  54 /* Standard bits: built-in the kernel */
  55 SYSCTL_NODE(_net, OID_AUTO, netlink, CTLFLAG_RD, 0, "");
  56 SYSCTL_NODE(_net_netlink, OID_AUTO, debug, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
  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->writer_type = NS_WRITER_TYPE_STUB;
 117         nw->enomem = true;
 118
 119         return (false);
 120 }
 121
 122 static bool
 123 nlmsg_get_unicast_writer_stub(struct nl_writer *nw, int size, struct nlpcb *nlp)
 124 {
 125         return (get_stub_writer(nw));
 126 }
 127
 128 static bool
 129 nlmsg_get_group_writer_stub(struct nl_writer *nw, int size, int protocol, int group_id)
 130 {
 131         return (get_stub_writer(nw));
 132 }
 133
 134 static bool
 135 nlmsg_get_chain_writer_stub(struct nl_writer *nw, int size, struct mbuf **pm)
 136 {
 137         return (get_stub_writer(nw));
 138 }
 139
 140 static bool
 141 nlmsg_flush_stub(struct nl_writer *nw __unused)
 142 {
 143         return (false);
 144 }
 145
 146 static void
 147 nlmsg_ignore_limit_stub(struct nl_writer *nw __unused)
 148 {
 149 }
 150
 151 static bool
 152 nlmsg_refill_buffer_stub(struct nl_writer *nw __unused, int required_len __unused)
 153 {
 154         return (false);
 155 }
 156
 157 static bool
 158 nlmsg_add_stub(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
 159     uint16_t flags, uint32_t len)
 160 {
 161         return (false);
 162 }
 163
 164 static bool
 165 nlmsg_end_stub(struct nl_writer *nw __unused)
 166 {
 167         return (false);
 168 }
 169
 170 static void
 171 nlmsg_abort_stub(struct nl_writer *nw __unused)
 172 {
 173 }
 174
 175 static bool
 176 nlmsg_end_dump_stub(struct nl_writer *nw, int error, struct nlmsghdr *hdr)
 177 {
 178         return (false);
 179 }
 180
 181 static int
 182 nl_modify_ifp_generic_stub(struct ifnet *ifp __unused,
 183     struct nl_parsed_link *lattrs __unused, const struct nlattr_bmask *bm __unused,
 184     struct nl_pstate *npt __unused)
 185 {
 186         return (ENOTSUP);
 187 }
 188
 189 static void
 190 nl_store_ifp_cookie_stub(struct nl_pstate *npt __unused, struct ifnet *ifp __unused)
 191 {
 192 }
 193
 194 static struct nlpcb *
 195 nl_get_thread_nlp_stub(struct thread *td __unused)
 196 {
 197         return (NULL);
 198 }
 199
 200 const static struct nl_function_wrapper nl_stub = {
 201         .nlmsg_add = nlmsg_add_stub,
 202         .nlmsg_refill_buffer = nlmsg_refill_buffer_stub,
 203         .nlmsg_flush = nlmsg_flush_stub,
 204         .nlmsg_end = nlmsg_end_stub,
 205         .nlmsg_abort = nlmsg_abort_stub,
 206         .nlmsg_ignore_limit = nlmsg_ignore_limit_stub,
 207         .nlmsg_get_unicast_writer = nlmsg_get_unicast_writer_stub,
 208         .nlmsg_get_group_writer = nlmsg_get_group_writer_stub,
 209         .nlmsg_get_chain_writer = nlmsg_get_chain_writer_stub,
 210         .nlmsg_end_dump = nlmsg_end_dump_stub,
 211         .nl_modify_ifp_generic = nl_modify_ifp_generic_stub,
 212         .nl_store_ifp_cookie = nl_store_ifp_cookie_stub,
 213         .nl_get_thread_nlp = nl_get_thread_nlp_stub,
 214 };
 215
 216 /*
 217  * If the kernel is compiled with netlink as a module,
 218  *  provide a way to introduce non-stub functioms
 219  */
 220 static const struct nl_function_wrapper *_nl = &nl_stub;
 221
 222 void
 223 nl_set_functions(const struct nl_function_wrapper *nl)
 224 {
 225         _nl = (nl != NULL) ? nl : &nl_stub;
 226 }
 227
 228 /* Function wrappers */
 229 bool
 230 nlmsg_get_unicast_writer(struct nl_writer *nw, int size, struct nlpcb *nlp)
 231 {
 232         return (_nl->nlmsg_get_unicast_writer(nw, size, nlp));
 233 }
 234
 235 bool
 236 nlmsg_get_group_writer(struct nl_writer *nw, int size, int protocol, int group_id)
 237 {
 238         return (_nl->nlmsg_get_group_writer(nw, size, protocol, group_id));
 239 }
 240
 241 bool
 242 nlmsg_get_chain_writer(struct nl_writer *nw, int size, struct mbuf **pm)
 243 {
 244         return (_nl->nlmsg_get_chain_writer(nw, size, pm));
 245 }
 246
 247 bool
 248 nlmsg_flush(struct nl_writer *nw)
 249 {
 250         return (_nl->nlmsg_flush(nw));
 251 }
 252
 253 void nlmsg_ignore_limit(struct nl_writer *nw)
 254 {
 255         _nl->nlmsg_ignore_limit(nw);
 256 }
 257
 258 bool
 259 nlmsg_refill_buffer(struct nl_writer *nw, int required_len)
 260 {
 261         return (_nl->nlmsg_refill_buffer(nw, required_len));
 262 }
 263
 264 bool
 265 nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
 266     uint16_t flags, uint32_t len)
 267 {
 268         return (_nl->nlmsg_add(nw, portid, seq, type, flags, len));
 269 }
 270
 271 bool
 272 nlmsg_end(struct nl_writer *nw)
 273 {
 274         return (_nl->nlmsg_end(nw));
 275 }
 276
 277 void
 278 nlmsg_abort(struct nl_writer *nw)
 279 {
 280         _nl->nlmsg_abort(nw);
 281 }
 282
 283 bool
 284 nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr)
 285 {
 286         return (_nl->nlmsg_end_dump(nw, error, hdr));
 287 }
 288
 289 int
 290 nl_modify_ifp_generic(struct ifnet *ifp, struct nl_parsed_link *lattrs,
 291     const struct nlattr_bmask *bm , struct nl_pstate *npt)
 292 {
 293         return (_nl->nl_modify_ifp_generic(ifp, lattrs, bm, npt));
 294 }
 295
 296 void
 297 nl_store_ifp_cookie(struct nl_pstate *npt, struct ifnet *ifp)
 298 {
 299         return (_nl->nl_store_ifp_cookie(npt, ifp));
 300 }
 301
 302 struct nlpcb *
 303 nl_get_thread_nlp(struct thread *td)
 304 {
 305         return (_nl->nl_get_thread_nlp(td));
 306 }
 307
 308 #endif /* !NETLINK */
 309