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