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