1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef __NET_GENERIC_NETLINK_H 3 #define __NET_GENERIC_NETLINK_H 4 5 #include <linux/net.h> 6 #include <net/netlink.h> 7 #include <net/net_namespace.h> 8 #include <uapi/linux/genetlink.h> 9 10 #define GENLMSG_DEFAULT_SIZE (NLMSG_DEFAULT_SIZE - GENL_HDRLEN) 11 12 /* Non-parallel generic netlink requests are serialized by a global lock. */ 13 void genl_lock(void); 14 void genl_unlock(void); 15 16 #define MODULE_ALIAS_GENL_FAMILY(family) \ 17 MODULE_ALIAS_NET_PF_PROTO_NAME(PF_NETLINK, NETLINK_GENERIC, "-family-" family) 18 19 /* Binding to multicast group requires %CAP_NET_ADMIN */ 20 #define GENL_MCAST_CAP_NET_ADMIN BIT(0) 21 /* Binding to multicast group requires %CAP_SYS_ADMIN */ 22 #define GENL_MCAST_CAP_SYS_ADMIN BIT(1) 23 24 /** 25 * struct genl_multicast_group - generic netlink multicast group 26 * @name: name of the multicast group, names are per-family 27 * @flags: GENL_MCAST_* flags 28 */ 29 struct genl_multicast_group { 30 char name[GENL_NAMSIZ]; 31 u8 flags; 32 }; 33 34 struct genl_split_ops; 35 struct genl_info; 36 37 /** 38 * struct genl_family - generic netlink family 39 * @hdrsize: length of user specific header in bytes 40 * @name: name of family 41 * @version: protocol version 42 * @maxattr: maximum number of attributes supported 43 * @policy: netlink policy 44 * @netnsok: set to true if the family can handle network 45 * namespaces and should be presented in all of them 46 * @parallel_ops: operations can be called in parallel and aren't 47 * synchronized by the core genetlink code 48 * @pre_doit: called before an operation's doit callback, it may 49 * do additional, common, filtering and return an error 50 * @post_doit: called after an operation's doit callback, it may 51 * undo operations done by pre_doit, for example release locks 52 * @bind: called when family multicast group is added to a netlink socket 53 * @unbind: called when family multicast group is removed from a netlink socket 54 * @module: pointer to the owning module (set to THIS_MODULE) 55 * @mcgrps: multicast groups used by this family 56 * @n_mcgrps: number of multicast groups 57 * @resv_start_op: first operation for which reserved fields of the header 58 * can be validated and policies are required (see below); 59 * new families should leave this field at zero 60 * @ops: the operations supported by this family 61 * @n_ops: number of operations supported by this family 62 * @small_ops: the small-struct operations supported by this family 63 * @n_small_ops: number of small-struct operations supported by this family 64 * @split_ops: the split do/dump form of operation definition 65 * @n_split_ops: number of entries in @split_ops, not that with split do/dump 66 * ops the number of entries is not the same as number of commands 67 * @sock_priv_size: the size of per-socket private memory 68 * @sock_priv_init: the per-socket private memory initializer 69 * @sock_priv_destroy: the per-socket private memory destructor 70 * 71 * Attribute policies (the combination of @policy and @maxattr fields) 72 * can be attached at the family level or at the operation level. 73 * If both are present the per-operation policy takes precedence. 74 * For operations before @resv_start_op lack of policy means that the core 75 * will perform no attribute parsing or validation. For newer operations 76 * if policy is not provided core will reject all TLV attributes. 77 */ 78 struct genl_family { 79 unsigned int hdrsize; 80 char name[GENL_NAMSIZ]; 81 unsigned int version; 82 unsigned int maxattr; 83 u8 netnsok:1; 84 u8 parallel_ops:1; 85 u8 n_ops; 86 u8 n_small_ops; 87 u8 n_split_ops; 88 u8 n_mcgrps; 89 u8 resv_start_op; 90 const struct nla_policy *policy; 91 int (*pre_doit)(const struct genl_split_ops *ops, 92 struct sk_buff *skb, 93 struct genl_info *info); 94 void (*post_doit)(const struct genl_split_ops *ops, 95 struct sk_buff *skb, 96 struct genl_info *info); 97 int (*bind)(int mcgrp); 98 void (*unbind)(int mcgrp); 99 const struct genl_ops * ops; 100 const struct genl_small_ops *small_ops; 101 const struct genl_split_ops *split_ops; 102 const struct genl_multicast_group *mcgrps; 103 struct module *module; 104 105 size_t sock_priv_size; 106 void (*sock_priv_init)(void *priv); 107 void (*sock_priv_destroy)(void *priv); 108 109 /* private: internal use only */ 110 /* protocol family identifier */ 111 int id; 112 /* starting number of multicast group IDs in this family */ 113 unsigned int mcgrp_offset; 114 /* list of per-socket privs */ 115 struct xarray *sock_privs; 116 }; 117 118 /** 119 * struct genl_info - receiving information 120 * @snd_seq: sending sequence number 121 * @snd_portid: netlink portid of sender 122 * @family: generic netlink family 123 * @nlhdr: netlink message header 124 * @genlhdr: generic netlink message header 125 * @attrs: netlink attributes 126 * @_net: network namespace 127 * @ctx: storage space for the use by the family 128 * @user_ptr: user pointers (deprecated, use ctx instead) 129 * @extack: extended ACK report struct 130 */ 131 struct genl_info { 132 u32 snd_seq; 133 u32 snd_portid; 134 const struct genl_family *family; 135 const struct nlmsghdr * nlhdr; 136 struct genlmsghdr * genlhdr; 137 struct nlattr ** attrs; 138 possible_net_t _net; 139 union { 140 u8 ctx[NETLINK_CTX_SIZE]; 141 void * user_ptr[2]; 142 }; 143 struct netlink_ext_ack *extack; 144 }; 145 146 static inline struct net *genl_info_net(const struct genl_info *info) 147 { 148 return read_pnet(&info->_net); 149 } 150 151 static inline void genl_info_net_set(struct genl_info *info, struct net *net) 152 { 153 write_pnet(&info->_net, net); 154 } 155 156 static inline void *genl_info_userhdr(const struct genl_info *info) 157 { 158 return (u8 *)info->genlhdr + GENL_HDRLEN; 159 } 160 161 #define GENL_SET_ERR_MSG(info, msg) NL_SET_ERR_MSG((info)->extack, msg) 162 163 #define GENL_SET_ERR_MSG_FMT(info, msg, args...) \ 164 NL_SET_ERR_MSG_FMT((info)->extack, msg, ##args) 165 166 /* Report that a root attribute is missing */ 167 #define GENL_REQ_ATTR_CHECK(info, attr) ({ \ 168 const struct genl_info *__info = (info); \ 169 \ 170 NL_REQ_ATTR_CHECK(__info->extack, NULL, __info->attrs, (attr)); \ 171 }) 172 173 enum genl_validate_flags { 174 GENL_DONT_VALIDATE_STRICT = BIT(0), 175 GENL_DONT_VALIDATE_DUMP = BIT(1), 176 GENL_DONT_VALIDATE_DUMP_STRICT = BIT(2), 177 }; 178 179 /** 180 * struct genl_small_ops - generic netlink operations (small version) 181 * @cmd: command identifier 182 * @internal_flags: flags used by the family 183 * @flags: GENL_* flags (%GENL_ADMIN_PERM or %GENL_UNS_ADMIN_PERM) 184 * @validate: validation flags from enum genl_validate_flags 185 * @doit: standard command callback 186 * @dumpit: callback for dumpers 187 * 188 * This is a cut-down version of struct genl_ops for users who don't need 189 * most of the ancillary infra and want to save space. 190 */ 191 struct genl_small_ops { 192 int (*doit)(struct sk_buff *skb, struct genl_info *info); 193 int (*dumpit)(struct sk_buff *skb, struct netlink_callback *cb); 194 u8 cmd; 195 u8 internal_flags; 196 u8 flags; 197 u8 validate; 198 }; 199 200 /** 201 * struct genl_ops - generic netlink operations 202 * @cmd: command identifier 203 * @internal_flags: flags used by the family 204 * @flags: GENL_* flags (%GENL_ADMIN_PERM or %GENL_UNS_ADMIN_PERM) 205 * @maxattr: maximum number of attributes supported 206 * @policy: netlink policy (takes precedence over family policy) 207 * @validate: validation flags from enum genl_validate_flags 208 * @doit: standard command callback 209 * @start: start callback for dumps 210 * @dumpit: callback for dumpers 211 * @done: completion callback for dumps 212 */ 213 struct genl_ops { 214 int (*doit)(struct sk_buff *skb, 215 struct genl_info *info); 216 int (*start)(struct netlink_callback *cb); 217 int (*dumpit)(struct sk_buff *skb, 218 struct netlink_callback *cb); 219 int (*done)(struct netlink_callback *cb); 220 const struct nla_policy *policy; 221 unsigned int maxattr; 222 u8 cmd; 223 u8 internal_flags; 224 u8 flags; 225 u8 validate; 226 }; 227 228 /** 229 * struct genl_split_ops - generic netlink operations (do/dump split version) 230 * @cmd: command identifier 231 * @internal_flags: flags used by the family 232 * @flags: GENL_* flags (%GENL_ADMIN_PERM or %GENL_UNS_ADMIN_PERM) 233 * @validate: validation flags from enum genl_validate_flags 234 * @policy: netlink policy (takes precedence over family policy) 235 * @maxattr: maximum number of attributes supported 236 * 237 * Do callbacks: 238 * @pre_doit: called before an operation's @doit callback, it may 239 * do additional, common, filtering and return an error 240 * @doit: standard command callback 241 * @post_doit: called after an operation's @doit callback, it may 242 * undo operations done by pre_doit, for example release locks 243 * 244 * Dump callbacks: 245 * @start: start callback for dumps 246 * @dumpit: callback for dumpers 247 * @done: completion callback for dumps 248 * 249 * Do callbacks can be used if %GENL_CMD_CAP_DO is set in @flags. 250 * Dump callbacks can be used if %GENL_CMD_CAP_DUMP is set in @flags. 251 * Exactly one of those flags must be set. 252 */ 253 struct genl_split_ops { 254 union { 255 struct { 256 int (*pre_doit)(const struct genl_split_ops *ops, 257 struct sk_buff *skb, 258 struct genl_info *info); 259 int (*doit)(struct sk_buff *skb, 260 struct genl_info *info); 261 void (*post_doit)(const struct genl_split_ops *ops, 262 struct sk_buff *skb, 263 struct genl_info *info); 264 }; 265 struct { 266 int (*start)(struct netlink_callback *cb); 267 int (*dumpit)(struct sk_buff *skb, 268 struct netlink_callback *cb); 269 int (*done)(struct netlink_callback *cb); 270 }; 271 }; 272 const struct nla_policy *policy; 273 unsigned int maxattr; 274 u8 cmd; 275 u8 internal_flags; 276 u8 flags; 277 u8 validate; 278 }; 279 280 /** 281 * struct genl_dumpit_info - info that is available during dumpit op call 282 * @op: generic netlink ops - for internal genl code usage 283 * @attrs: netlink attributes 284 * @info: struct genl_info describing the request 285 */ 286 struct genl_dumpit_info { 287 struct genl_split_ops op; 288 struct genl_info info; 289 }; 290 291 static inline const struct genl_dumpit_info * 292 genl_dumpit_info(struct netlink_callback *cb) 293 { 294 return cb->data; 295 } 296 297 static inline const struct genl_info * 298 genl_info_dump(struct netlink_callback *cb) 299 { 300 return &genl_dumpit_info(cb)->info; 301 } 302 303 /** 304 * genl_info_init_ntf() - initialize genl_info for notifications 305 * @info: genl_info struct to set up 306 * @family: pointer to the genetlink family 307 * @cmd: command to be used in the notification 308 * 309 * Initialize a locally declared struct genl_info to pass to various APIs. 310 * Intended to be used when creating notifications. 311 */ 312 static inline void 313 genl_info_init_ntf(struct genl_info *info, const struct genl_family *family, 314 u8 cmd) 315 { 316 struct genlmsghdr *hdr = (void *) &info->user_ptr[0]; 317 318 memset(info, 0, sizeof(*info)); 319 info->family = family; 320 info->genlhdr = hdr; 321 hdr->cmd = cmd; 322 } 323 324 static inline bool genl_info_is_ntf(const struct genl_info *info) 325 { 326 return !info->nlhdr; 327 } 328 329 void *__genl_sk_priv_get(struct genl_family *family, struct sock *sk); 330 void *genl_sk_priv_get(struct genl_family *family, struct sock *sk); 331 int genl_register_family(struct genl_family *family); 332 int genl_unregister_family(const struct genl_family *family); 333 void genl_notify(const struct genl_family *family, struct sk_buff *skb, 334 struct genl_info *info, u32 group, gfp_t flags); 335 336 void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, 337 const struct genl_family *family, int flags, u8 cmd); 338 339 static inline void * 340 __genlmsg_iput(struct sk_buff *skb, const struct genl_info *info, int flags) 341 { 342 return genlmsg_put(skb, info->snd_portid, info->snd_seq, info->family, 343 flags, info->genlhdr->cmd); 344 } 345 346 /** 347 * genlmsg_iput - start genetlink message based on genl_info 348 * @skb: skb in which message header will be placed 349 * @info: genl_info as provided to do/dump handlers 350 * 351 * Convenience wrapper which starts a genetlink message based on 352 * information in user request. @info should be either the struct passed 353 * by genetlink core to do/dump handlers (when constructing replies to 354 * such requests) or a struct initialized by genl_info_init_ntf() 355 * when constructing notifications. 356 * 357 * Returns pointer to new genetlink header. 358 */ 359 static inline void * 360 genlmsg_iput(struct sk_buff *skb, const struct genl_info *info) 361 { 362 return __genlmsg_iput(skb, info, 0); 363 } 364 365 /** 366 * genlmsg_nlhdr - Obtain netlink header from user specified header 367 * @user_hdr: user header as returned from genlmsg_put() 368 * 369 * Returns pointer to netlink header. 370 */ 371 static inline struct nlmsghdr *genlmsg_nlhdr(void *user_hdr) 372 { 373 return (struct nlmsghdr *)((char *)user_hdr - 374 GENL_HDRLEN - 375 NLMSG_HDRLEN); 376 } 377 378 /** 379 * genlmsg_parse_deprecated - parse attributes of a genetlink message 380 * @nlh: netlink message header 381 * @family: genetlink message family 382 * @tb: destination array with maxtype+1 elements 383 * @maxtype: maximum attribute type to be expected 384 * @policy: validation policy 385 * @extack: extended ACK report struct 386 */ 387 static inline int genlmsg_parse_deprecated(const struct nlmsghdr *nlh, 388 const struct genl_family *family, 389 struct nlattr *tb[], int maxtype, 390 const struct nla_policy *policy, 391 struct netlink_ext_ack *extack) 392 { 393 return __nlmsg_parse(nlh, family->hdrsize + GENL_HDRLEN, tb, maxtype, 394 policy, NL_VALIDATE_LIBERAL, extack); 395 } 396 397 /** 398 * genlmsg_parse - parse attributes of a genetlink message 399 * @nlh: netlink message header 400 * @family: genetlink message family 401 * @tb: destination array with maxtype+1 elements 402 * @maxtype: maximum attribute type to be expected 403 * @policy: validation policy 404 * @extack: extended ACK report struct 405 */ 406 static inline int genlmsg_parse(const struct nlmsghdr *nlh, 407 const struct genl_family *family, 408 struct nlattr *tb[], int maxtype, 409 const struct nla_policy *policy, 410 struct netlink_ext_ack *extack) 411 { 412 return __nlmsg_parse(nlh, family->hdrsize + GENL_HDRLEN, tb, maxtype, 413 policy, NL_VALIDATE_STRICT, extack); 414 } 415 416 /** 417 * genl_dump_check_consistent - check if sequence is consistent and advertise if not 418 * @cb: netlink callback structure that stores the sequence number 419 * @user_hdr: user header as returned from genlmsg_put() 420 * 421 * Cf. nl_dump_check_consistent(), this just provides a wrapper to make it 422 * simpler to use with generic netlink. 423 */ 424 static inline void genl_dump_check_consistent(struct netlink_callback *cb, 425 void *user_hdr) 426 { 427 nl_dump_check_consistent(cb, genlmsg_nlhdr(user_hdr)); 428 } 429 430 /** 431 * genlmsg_put_reply - Add generic netlink header to a reply message 432 * @skb: socket buffer holding the message 433 * @info: receiver info 434 * @family: generic netlink family 435 * @flags: netlink message flags 436 * @cmd: generic netlink command 437 * 438 * Returns pointer to user specific header 439 */ 440 static inline void *genlmsg_put_reply(struct sk_buff *skb, 441 struct genl_info *info, 442 const struct genl_family *family, 443 int flags, u8 cmd) 444 { 445 return genlmsg_put(skb, info->snd_portid, info->snd_seq, family, 446 flags, cmd); 447 } 448 449 /** 450 * genlmsg_end - Finalize a generic netlink message 451 * @skb: socket buffer the message is stored in 452 * @hdr: user specific header 453 */ 454 static inline void genlmsg_end(struct sk_buff *skb, void *hdr) 455 { 456 nlmsg_end(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN); 457 } 458 459 /** 460 * genlmsg_cancel - Cancel construction of a generic netlink message 461 * @skb: socket buffer the message is stored in 462 * @hdr: generic netlink message header 463 */ 464 static inline void genlmsg_cancel(struct sk_buff *skb, void *hdr) 465 { 466 if (hdr) 467 nlmsg_cancel(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN); 468 } 469 470 /** 471 * genlmsg_multicast_netns_filtered - multicast a netlink message 472 * to a specific netns with filter 473 * function 474 * @family: the generic netlink family 475 * @net: the net namespace 476 * @skb: netlink message as socket buffer 477 * @portid: own netlink portid to avoid sending to yourself 478 * @group: offset of multicast group in groups array 479 * @flags: allocation flags 480 * @filter: filter function 481 * @filter_data: filter function private data 482 * 483 * Return: 0 on success, negative error code for failure. 484 */ 485 static inline int 486 genlmsg_multicast_netns_filtered(const struct genl_family *family, 487 struct net *net, struct sk_buff *skb, 488 u32 portid, unsigned int group, gfp_t flags, 489 netlink_filter_fn filter, 490 void *filter_data) 491 { 492 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 493 return -EINVAL; 494 group = family->mcgrp_offset + group; 495 return nlmsg_multicast_filtered(net->genl_sock, skb, portid, group, 496 flags, filter, filter_data); 497 } 498 499 /** 500 * genlmsg_multicast_netns - multicast a netlink message to a specific netns 501 * @family: the generic netlink family 502 * @net: the net namespace 503 * @skb: netlink message as socket buffer 504 * @portid: own netlink portid to avoid sending to yourself 505 * @group: offset of multicast group in groups array 506 * @flags: allocation flags 507 */ 508 static inline int genlmsg_multicast_netns(const struct genl_family *family, 509 struct net *net, struct sk_buff *skb, 510 u32 portid, unsigned int group, gfp_t flags) 511 { 512 return genlmsg_multicast_netns_filtered(family, net, skb, portid, 513 group, flags, NULL, NULL); 514 } 515 516 /** 517 * genlmsg_multicast - multicast a netlink message to the default netns 518 * @family: the generic netlink family 519 * @skb: netlink message as socket buffer 520 * @portid: own netlink portid to avoid sending to yourself 521 * @group: offset of multicast group in groups array 522 * @flags: allocation flags 523 */ 524 static inline int genlmsg_multicast(const struct genl_family *family, 525 struct sk_buff *skb, u32 portid, 526 unsigned int group, gfp_t flags) 527 { 528 return genlmsg_multicast_netns(family, &init_net, skb, 529 portid, group, flags); 530 } 531 532 /** 533 * genlmsg_multicast_allns - multicast a netlink message to all net namespaces 534 * @family: the generic netlink family 535 * @skb: netlink message as socket buffer 536 * @portid: own netlink portid to avoid sending to yourself 537 * @group: offset of multicast group in groups array 538 * 539 * This function must hold the RTNL or rcu_read_lock(). 540 */ 541 int genlmsg_multicast_allns(const struct genl_family *family, 542 struct sk_buff *skb, u32 portid, 543 unsigned int group); 544 545 /** 546 * genlmsg_unicast - unicast a netlink message 547 * @net: network namespace to look up @portid in 548 * @skb: netlink message as socket buffer 549 * @portid: netlink portid of the destination socket 550 */ 551 static inline int genlmsg_unicast(struct net *net, struct sk_buff *skb, u32 portid) 552 { 553 return nlmsg_unicast(net->genl_sock, skb, portid); 554 } 555 556 /** 557 * genlmsg_reply - reply to a request 558 * @skb: netlink message to be sent back 559 * @info: receiver information 560 */ 561 static inline int genlmsg_reply(struct sk_buff *skb, struct genl_info *info) 562 { 563 return genlmsg_unicast(genl_info_net(info), skb, info->snd_portid); 564 } 565 566 /** 567 * genlmsg_data - head of message payload 568 * @gnlh: genetlink message header 569 */ 570 static inline void *genlmsg_data(const struct genlmsghdr *gnlh) 571 { 572 return ((unsigned char *) gnlh + GENL_HDRLEN); 573 } 574 575 /** 576 * genlmsg_len - length of message payload 577 * @gnlh: genetlink message header 578 */ 579 static inline int genlmsg_len(const struct genlmsghdr *gnlh) 580 { 581 struct nlmsghdr *nlh = (struct nlmsghdr *)((unsigned char *)gnlh - 582 NLMSG_HDRLEN); 583 return (nlh->nlmsg_len - GENL_HDRLEN - NLMSG_HDRLEN); 584 } 585 586 /** 587 * genlmsg_msg_size - length of genetlink message not including padding 588 * @payload: length of message payload 589 */ 590 static inline int genlmsg_msg_size(int payload) 591 { 592 return GENL_HDRLEN + payload; 593 } 594 595 /** 596 * genlmsg_total_size - length of genetlink message including padding 597 * @payload: length of message payload 598 */ 599 static inline int genlmsg_total_size(int payload) 600 { 601 return NLMSG_ALIGN(genlmsg_msg_size(payload)); 602 } 603 604 /** 605 * genlmsg_new - Allocate a new generic netlink message 606 * @payload: size of the message payload 607 * @flags: the type of memory to allocate. 608 */ 609 static inline struct sk_buff *genlmsg_new(size_t payload, gfp_t flags) 610 { 611 return nlmsg_new(genlmsg_total_size(payload), flags); 612 } 613 614 /** 615 * genl_set_err - report error to genetlink broadcast listeners 616 * @family: the generic netlink family 617 * @net: the network namespace to report the error to 618 * @portid: the PORTID of a process that we want to skip (if any) 619 * @group: the broadcast group that will notice the error 620 * (this is the offset of the multicast group in the groups array) 621 * @code: error code, must be negative (as usual in kernelspace) 622 * 623 * This function returns the number of broadcast listeners that have set the 624 * NETLINK_RECV_NO_ENOBUFS socket option. 625 */ 626 static inline int genl_set_err(const struct genl_family *family, 627 struct net *net, u32 portid, 628 u32 group, int code) 629 { 630 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 631 return -EINVAL; 632 group = family->mcgrp_offset + group; 633 return netlink_set_err(net->genl_sock, portid, group, code); 634 } 635 636 static inline int genl_has_listeners(const struct genl_family *family, 637 struct net *net, unsigned int group) 638 { 639 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 640 return -EINVAL; 641 group = family->mcgrp_offset + group; 642 return netlink_has_listeners(net->genl_sock, group); 643 } 644 #endif /* __NET_GENERIC_NETLINK_H */ 645