sys/netlink/netlink_message_writer.h

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   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 #ifndef _NETLINK_NETLINK_MESSAGE_WRITER_H_
  30 #define _NETLINK_NETLINK_MESSAGE_WRITER_H_
  31
  32 #ifdef _KERNEL
  33
  34 #include <netinet/in.h>
  35
  36 /*
  37  * It is not meant to be included directly
  38  */
  39
  40 struct mbuf;
  41 struct nl_writer;
  42 typedef bool nl_writer_cb(struct nl_writer *nw, void *buf, int buflen, int cnt);
  43
  44 struct nl_writer {
  45         int                     alloc_len;      /* allocated buffer length */
  46         int                     offset;         /* offset from the start of the buffer */
  47         struct nlmsghdr         *hdr;           /* Pointer to the currently-filled msg */
  48         char                    *data;          /* pointer to the contiguous storage */
  49         void                    *_storage;      /* Underlying storage pointer */
  50         nl_writer_cb            *cb;            /* Callback to flush data */
  51         union {
  52                 void            *ptr;
  53                 struct {
  54                         uint16_t        proto;
  55                         uint16_t        id;
  56                 } group;
  57         } arg;
  58         int                     num_messages;   /* Number of messages in the buffer */
  59         int                     malloc_flag;    /* M_WAITOK or M_NOWAIT */
  60         uint8_t                 writer_type;    /* NS_WRITER_TYPE_* */
  61         uint8_t                 writer_target;  /* NS_WRITER_TARGET_*  */
  62         bool                    ignore_limit;   /* If true, ignores RCVBUF limit */
  63         bool                    enomem;         /* True if ENOMEM occured */
  64         bool                    suppress_ack;   /* If true, don't send NLMSG_ERR */
  65 };
  66 #define NS_WRITER_TARGET_SOCKET 0
  67 #define NS_WRITER_TARGET_GROUP  1
  68 #define NS_WRITER_TARGET_CHAIN  2
  69
  70 #define NS_WRITER_TYPE_MBUF     0
  71 #define NS_WRITER_TYPE_BUF      1
  72 #define NS_WRITER_TYPE_LBUF     2
  73 #define NS_WRITER_TYPE_MBUFC    3
  74 #define NS_WRITER_TYPE_STUB     4
  75
  76
  77 #define NLMSG_SMALL     128
  78 #define NLMSG_LARGE     2048
  79
  80 /* Message and attribute writing */
  81
  82 struct nlpcb;
  83
  84 #if defined(NETLINK) || defined(NETLINK_MODULE)
  85 /* Provide optimized calls to the functions inside the same linking unit */
  86
  87 bool _nlmsg_get_unicast_writer(struct nl_writer *nw, int expected_size, struct nlpcb *nlp);
  88 bool _nlmsg_get_group_writer(struct nl_writer *nw, int expected_size, int proto, int group_id);
  89 bool _nlmsg_get_chain_writer(struct nl_writer *nw, int expected_size, struct mbuf **pm);
  90 bool _nlmsg_flush(struct nl_writer *nw);
  91 void _nlmsg_ignore_limit(struct nl_writer *nw);
  92
  93 bool _nlmsg_refill_buffer(struct nl_writer *nw, int required_size);
  94 bool _nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
  95     uint16_t flags, uint32_t len);
  96 bool _nlmsg_end(struct nl_writer *nw);
  97 void _nlmsg_abort(struct nl_writer *nw);
  98
  99 bool _nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr);
 100
 101
 102 static inline bool
 103 nlmsg_get_unicast_writer(struct nl_writer *nw, int expected_size, struct nlpcb *nlp)
 104 {
 105         return (_nlmsg_get_unicast_writer(nw, expected_size, nlp));
 106 }
 107
 108 static inline bool
 109 nlmsg_get_group_writer(struct nl_writer *nw, int expected_size, int proto, int group_id)
 110 {
 111         return (_nlmsg_get_group_writer(nw, expected_size, proto, group_id));
 112 }
 113
 114 static inline bool
 115 nlmsg_get_chain_writer(struct nl_writer *nw, int expected_size, struct mbuf **pm)
 116 {
 117         return (_nlmsg_get_chain_writer(nw, expected_size, pm));
 118 }
 119
 120 static inline bool
 121 nlmsg_flush(struct nl_writer *nw)
 122 {
 123         return (_nlmsg_flush(nw));
 124 }
 125
 126 static inline void
 127 nlmsg_ignore_limit(struct nl_writer *nw)
 128 {
 129         _nlmsg_ignore_limit(nw);
 130 }
 131
 132 static inline bool
 133 nlmsg_refill_buffer(struct nl_writer *nw, int required_size)
 134 {
 135         return (_nlmsg_refill_buffer(nw, required_size));
 136 }
 137
 138 static inline bool
 139 nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
 140     uint16_t flags, uint32_t len)
 141 {
 142         return (_nlmsg_add(nw, portid, seq, type, flags, len));
 143 }
 144
 145 static inline bool
 146 nlmsg_end(struct nl_writer *nw)
 147 {
 148         return (_nlmsg_end(nw));
 149 }
 150
 151 static inline void
 152 nlmsg_abort(struct nl_writer *nw)
 153 {
 154         return (_nlmsg_abort(nw));
 155 }
 156
 157 static inline bool
 158 nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr)
 159 {
 160         return (_nlmsg_end_dump(nw, error, hdr));
 161 }
 162
 163 #else
 164 /* Provide access to the functions via netlink_glue.c */
 165
 166 bool nlmsg_get_unicast_writer(struct nl_writer *nw, int expected_size, struct nlpcb *nlp);
 167 bool nlmsg_get_group_writer(struct nl_writer *nw, int expected_size, int proto, int group_id);
 168 bool nlmsg_get_chain_writer(struct nl_writer *nw, int expected_size, struct mbuf **pm);
 169 bool nlmsg_flush(struct nl_writer *nw);
 170 void nlmsg_ignore_limit(struct nl_writer *nw);
 171
 172 bool nlmsg_refill_buffer(struct nl_writer *nw, int required_size);
 173 bool nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
 174     uint16_t flags, uint32_t len);
 175 bool nlmsg_end(struct nl_writer *nw);
 176 void nlmsg_abort(struct nl_writer *nw);
 177
 178 bool nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr);
 179
 180 #endif /* defined(NETLINK) || defined(NETLINK_MODULE) */
 181
 182 static inline bool
 183 nlmsg_reply(struct nl_writer *nw, const struct nlmsghdr *hdr, int payload_len)
 184 {
 185         return (nlmsg_add(nw, hdr->nlmsg_pid, hdr->nlmsg_seq, hdr->nlmsg_type,
 186             hdr->nlmsg_flags, payload_len));
 187 }
 188
 189 #define nlmsg_data(_hdr)        ((void *)((_hdr) + 1))
 190
 191 /*
 192  * KPI similar to mtodo():
 193  * current (uncompleted) header is guaranteed to be contiguous,
 194  *  but can be reallocated, thus pointers may need to be readjusted.
 195  */
 196 static inline int
 197 nlattr_save_offset(const struct nl_writer *nw)
 198 {
 199         return (nw->offset - ((char *)nw->hdr - nw->data));
 200 }
 201
 202 static inline void *
 203 _nlattr_restore_offset(const struct nl_writer *nw, int off)
 204 {
 205         return ((void *)((char *)nw->hdr + off));
 206 }
 207 #define nlattr_restore_offset(_ns, _off, _t)    ((_t *)_nlattr_restore_offset(_ns, _off))
 208
 209 static inline void
 210 nlattr_set_len(const struct nl_writer *nw, int off)
 211 {
 212         struct nlattr *nla = nlattr_restore_offset(nw, off, struct nlattr);
 213         nla->nla_len = nlattr_save_offset(nw) - off;
 214 }
 215
 216 static inline void *
 217 nlmsg_reserve_data_raw(struct nl_writer *nw, size_t sz)
 218 {
 219         sz = NETLINK_ALIGN(sz);
 220
 221         if (__predict_false(nw->offset + sz > nw->alloc_len)) {
 222                 if (!nlmsg_refill_buffer(nw, sz))
 223                         return (NULL);
 224         }
 225
 226         void *data_ptr = &nw->data[nw->offset];
 227         nw->offset += sz;
 228         bzero(data_ptr, sz);
 229
 230         return (data_ptr);
 231 }
 232 #define nlmsg_reserve_object(_ns, _t)   ((_t *)nlmsg_reserve_data_raw(_ns, sizeof(_t)))
 233 #define nlmsg_reserve_data(_ns, _sz, _t)        ((_t *)nlmsg_reserve_data_raw(_ns, _sz))
 234
 235 static inline int
 236 nlattr_add_nested(struct nl_writer *nw, uint16_t nla_type)
 237 {
 238         int off = nlattr_save_offset(nw);
 239         struct nlattr *nla = nlmsg_reserve_data(nw, sizeof(struct nlattr), struct nlattr);
 240         if (__predict_false(nla == NULL))
 241                 return (0);
 242         nla->nla_type = nla_type;
 243         return (off);
 244 }
 245
 246 static inline void *
 247 _nlmsg_reserve_attr(struct nl_writer *nw, uint16_t nla_type, uint16_t sz)
 248 {
 249         sz += sizeof(struct nlattr);
 250
 251         struct nlattr *nla = nlmsg_reserve_data(nw, sz, struct nlattr);
 252         if (__predict_false(nla == NULL))
 253                 return (NULL);
 254         nla->nla_type = nla_type;
 255         nla->nla_len = sz;
 256
 257         return ((void *)(nla + 1));
 258 }
 259 #define nlmsg_reserve_attr(_ns, _at, _t)        ((_t *)_nlmsg_reserve_attr(_ns, _at, NLA_ALIGN(sizeof(_t))))
 260
 261 static inline bool
 262 nlattr_add(struct nl_writer *nw, int attr_type, int attr_len, const void *data)
 263 {
 264         int required_len = NLA_ALIGN(attr_len + sizeof(struct nlattr));
 265
 266         if (__predict_false(nw->offset + required_len > nw->alloc_len)) {
 267                 if (!nlmsg_refill_buffer(nw, required_len))
 268                         return (false);
 269         }
 270
 271         struct nlattr *nla = (struct nlattr *)(&nw->data[nw->offset]);
 272
 273         nla->nla_len = attr_len + sizeof(struct nlattr);
 274         nla->nla_type = attr_type;
 275         if (attr_len > 0) {
 276                 if ((attr_len % 4) != 0) {
 277                         /* clear padding bytes */
 278                         bzero((char *)nla + required_len - 4, 4);
 279                 }
 280                 memcpy((nla + 1), data, attr_len);
 281         }
 282         nw->offset += required_len;
 283         return (true);
 284 }
 285
 286 static inline bool
 287 nlattr_add_raw(struct nl_writer *nw, const struct nlattr *nla_src)
 288 {
 289         int attr_len = nla_src->nla_len - sizeof(struct nlattr);
 290
 291         MPASS(attr_len >= 0);
 292
 293         return (nlattr_add(nw, nla_src->nla_type, attr_len, (const void *)(nla_src + 1)));
 294 }
 295
 296 static inline bool
 297 nlattr_add_u8(struct nl_writer *nw, int attrtype, uint8_t value)
 298 {
 299         return (nlattr_add(nw, attrtype, sizeof(uint8_t), &value));
 300 }
 301
 302 static inline bool
 303 nlattr_add_u16(struct nl_writer *nw, int attrtype, uint16_t value)
 304 {
 305         return (nlattr_add(nw, attrtype, sizeof(uint16_t), &value));
 306 }
 307
 308 static inline bool
 309 nlattr_add_u32(struct nl_writer *nw, int attrtype, uint32_t value)
 310 {
 311         return (nlattr_add(nw, attrtype, sizeof(uint32_t), &value));
 312 }
 313
 314 static inline bool
 315 nlattr_add_u64(struct nl_writer *nw, int attrtype, uint64_t value)
 316 {
 317         return (nlattr_add(nw, attrtype, sizeof(uint64_t), &value));
 318 }
 319
 320 static inline bool
 321 nlattr_add_s8(struct nl_writer *nw, int attrtype, int8_t value)
 322 {
 323         return (nlattr_add(nw, attrtype, sizeof(int8_t), &value));
 324 }
 325
 326 static inline bool
 327 nlattr_add_s16(struct nl_writer *nw, int attrtype, int16_t value)
 328 {
 329         return (nlattr_add(nw, attrtype, sizeof(int16_t), &value));
 330 }
 331
 332 static inline bool
 333 nlattr_add_s32(struct nl_writer *nw, int attrtype, int32_t value)
 334 {
 335         return (nlattr_add(nw, attrtype, sizeof(int32_t), &value));
 336 }
 337
 338 static inline bool
 339 nlattr_add_s64(struct nl_writer *nw, int attrtype, int64_t value)
 340 {
 341         return (nlattr_add(nw, attrtype, sizeof(int64_t), &value));
 342 }
 343
 344 static inline bool
 345 nlattr_add_flag(struct nl_writer *nw, int attrtype)
 346 {
 347         return (nlattr_add(nw, attrtype, 0, NULL));
 348 }
 349
 350 static inline bool
 351 nlattr_add_string(struct nl_writer *nw, int attrtype, const char *str)
 352 {
 353         return (nlattr_add(nw, attrtype, strlen(str) + 1, str));
 354 }
 355
 356 static inline bool
 357 nlattr_add_in_addr(struct nl_writer *nw, int attrtype, const struct in_addr *in)
 358 {
 359         return (nlattr_add(nw, attrtype, sizeof(*in), in));
 360 }
 361
 362 static inline bool
 363 nlattr_add_in6_addr(struct nl_writer *nw, int attrtype, const struct in6_addr *in6)
 364 {
 365         return (nlattr_add(nw, attrtype, sizeof(*in6), in6));
 366 }
 367 #endif
 368 #endif