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 */ 15 struct genl_multicast_group { 16 char name[GENL_NAMSIZ]; 17 u8 flags; 18 }; 19 20 struct genl_ops; 21 struct genl_info; 22 23 /** 24 * struct genl_family - generic netlink family 25 * @id: protocol family identifier (private) 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 * @mcgrps: multicast groups used by this family 40 * @n_mcgrps: number of multicast groups 41 * @mcgrp_offset: starting number of multicast group IDs in this family 42 * (private) 43 * @ops: the operations supported by this family 44 * @n_ops: number of operations supported by this family 45 * @small_ops: the small-struct operations supported by this family 46 * @n_small_ops: number of small-struct operations supported by this family 47 */ 48 struct genl_family { 49 int id; /* private */ 50 unsigned int hdrsize; 51 char name[GENL_NAMSIZ]; 52 unsigned int version; 53 unsigned int maxattr; 54 unsigned int mcgrp_offset; /* private */ 55 u8 netnsok:1; 56 u8 parallel_ops:1; 57 u8 n_ops; 58 u8 n_small_ops; 59 u8 n_mcgrps; 60 const struct nla_policy *policy; 61 int (*pre_doit)(const struct genl_ops *ops, 62 struct sk_buff *skb, 63 struct genl_info *info); 64 void (*post_doit)(const struct genl_ops *ops, 65 struct sk_buff *skb, 66 struct genl_info *info); 67 const struct genl_ops * ops; 68 const struct genl_small_ops *small_ops; 69 const struct genl_multicast_group *mcgrps; 70 struct module *module; 71 }; 72 73 /** 74 * struct genl_info - receiving information 75 * @snd_seq: sending sequence number 76 * @snd_portid: netlink portid of sender 77 * @nlhdr: netlink message header 78 * @genlhdr: generic netlink message header 79 * @userhdr: user specific header 80 * @attrs: netlink attributes 81 * @_net: network namespace 82 * @user_ptr: user pointers 83 * @extack: extended ACK report struct 84 */ 85 struct genl_info { 86 u32 snd_seq; 87 u32 snd_portid; 88 struct nlmsghdr * nlhdr; 89 struct genlmsghdr * genlhdr; 90 void * userhdr; 91 struct nlattr ** attrs; 92 possible_net_t _net; 93 void * user_ptr[2]; 94 struct netlink_ext_ack *extack; 95 }; 96 97 static inline struct net *genl_info_net(struct genl_info *info) 98 { 99 return read_pnet(&info->_net); 100 } 101 102 static inline void genl_info_net_set(struct genl_info *info, struct net *net) 103 { 104 write_pnet(&info->_net, net); 105 } 106 107 #define GENL_SET_ERR_MSG(info, msg) NL_SET_ERR_MSG((info)->extack, msg) 108 109 enum genl_validate_flags { 110 GENL_DONT_VALIDATE_STRICT = BIT(0), 111 GENL_DONT_VALIDATE_DUMP = BIT(1), 112 GENL_DONT_VALIDATE_DUMP_STRICT = BIT(2), 113 }; 114 115 /** 116 * struct genl_small_ops - generic netlink operations (small version) 117 * @cmd: command identifier 118 * @internal_flags: flags used by the family 119 * @flags: flags 120 * @validate: validation flags from enum genl_validate_flags 121 * @doit: standard command callback 122 * @dumpit: callback for dumpers 123 * 124 * This is a cut-down version of struct genl_ops for users who don't need 125 * most of the ancillary infra and want to save space. 126 */ 127 struct genl_small_ops { 128 int (*doit)(struct sk_buff *skb, struct genl_info *info); 129 int (*dumpit)(struct sk_buff *skb, struct netlink_callback *cb); 130 u8 cmd; 131 u8 internal_flags; 132 u8 flags; 133 u8 validate; 134 }; 135 136 /** 137 * struct genl_ops - generic netlink operations 138 * @cmd: command identifier 139 * @internal_flags: flags used by the family 140 * @flags: flags 141 * @maxattr: maximum number of attributes supported 142 * @policy: netlink policy (takes precedence over family policy) 143 * @validate: validation flags from enum genl_validate_flags 144 * @doit: standard command callback 145 * @start: start callback for dumps 146 * @dumpit: callback for dumpers 147 * @done: completion callback for dumps 148 */ 149 struct genl_ops { 150 int (*doit)(struct sk_buff *skb, 151 struct genl_info *info); 152 int (*start)(struct netlink_callback *cb); 153 int (*dumpit)(struct sk_buff *skb, 154 struct netlink_callback *cb); 155 int (*done)(struct netlink_callback *cb); 156 const struct nla_policy *policy; 157 unsigned int maxattr; 158 u8 cmd; 159 u8 internal_flags; 160 u8 flags; 161 u8 validate; 162 }; 163 164 /** 165 * struct genl_info - info that is available during dumpit op call 166 * @family: generic netlink family - for internal genl code usage 167 * @ops: generic netlink ops - for internal genl code usage 168 * @attrs: netlink attributes 169 */ 170 struct genl_dumpit_info { 171 const struct genl_family *family; 172 struct genl_ops op; 173 struct nlattr **attrs; 174 }; 175 176 static inline const struct genl_dumpit_info * 177 genl_dumpit_info(struct netlink_callback *cb) 178 { 179 return cb->data; 180 } 181 182 int genl_register_family(struct genl_family *family); 183 int genl_unregister_family(const struct genl_family *family); 184 void genl_notify(const struct genl_family *family, struct sk_buff *skb, 185 struct genl_info *info, u32 group, gfp_t flags); 186 187 void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, 188 const struct genl_family *family, int flags, u8 cmd); 189 190 /** 191 * genlmsg_nlhdr - Obtain netlink header from user specified header 192 * @user_hdr: user header as returned from genlmsg_put() 193 * 194 * Returns pointer to netlink header. 195 */ 196 static inline struct nlmsghdr *genlmsg_nlhdr(void *user_hdr) 197 { 198 return (struct nlmsghdr *)((char *)user_hdr - 199 GENL_HDRLEN - 200 NLMSG_HDRLEN); 201 } 202 203 /** 204 * genlmsg_parse_deprecated - parse attributes of a genetlink message 205 * @nlh: netlink message header 206 * @family: genetlink message family 207 * @tb: destination array with maxtype+1 elements 208 * @maxtype: maximum attribute type to be expected 209 * @policy: validation policy 210 * @extack: extended ACK report struct 211 */ 212 static inline int genlmsg_parse_deprecated(const struct nlmsghdr *nlh, 213 const struct genl_family *family, 214 struct nlattr *tb[], int maxtype, 215 const struct nla_policy *policy, 216 struct netlink_ext_ack *extack) 217 { 218 return __nlmsg_parse(nlh, family->hdrsize + GENL_HDRLEN, tb, maxtype, 219 policy, NL_VALIDATE_LIBERAL, extack); 220 } 221 222 /** 223 * genlmsg_parse - parse attributes of a genetlink message 224 * @nlh: netlink message header 225 * @family: genetlink message family 226 * @tb: destination array with maxtype+1 elements 227 * @maxtype: maximum attribute type to be expected 228 * @policy: validation policy 229 * @extack: extended ACK report struct 230 */ 231 static inline int genlmsg_parse(const struct nlmsghdr *nlh, 232 const struct genl_family *family, 233 struct nlattr *tb[], int maxtype, 234 const struct nla_policy *policy, 235 struct netlink_ext_ack *extack) 236 { 237 return __nlmsg_parse(nlh, family->hdrsize + GENL_HDRLEN, tb, maxtype, 238 policy, NL_VALIDATE_STRICT, extack); 239 } 240 241 /** 242 * genl_dump_check_consistent - check if sequence is consistent and advertise if not 243 * @cb: netlink callback structure that stores the sequence number 244 * @user_hdr: user header as returned from genlmsg_put() 245 * 246 * Cf. nl_dump_check_consistent(), this just provides a wrapper to make it 247 * simpler to use with generic netlink. 248 */ 249 static inline void genl_dump_check_consistent(struct netlink_callback *cb, 250 void *user_hdr) 251 { 252 nl_dump_check_consistent(cb, genlmsg_nlhdr(user_hdr)); 253 } 254 255 /** 256 * genlmsg_put_reply - Add generic netlink header to a reply message 257 * @skb: socket buffer holding the message 258 * @info: receiver info 259 * @family: generic netlink family 260 * @flags: netlink message flags 261 * @cmd: generic netlink command 262 * 263 * Returns pointer to user specific header 264 */ 265 static inline void *genlmsg_put_reply(struct sk_buff *skb, 266 struct genl_info *info, 267 const struct genl_family *family, 268 int flags, u8 cmd) 269 { 270 return genlmsg_put(skb, info->snd_portid, info->snd_seq, family, 271 flags, cmd); 272 } 273 274 /** 275 * genlmsg_end - Finalize a generic netlink message 276 * @skb: socket buffer the message is stored in 277 * @hdr: user specific header 278 */ 279 static inline void genlmsg_end(struct sk_buff *skb, void *hdr) 280 { 281 nlmsg_end(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN); 282 } 283 284 /** 285 * genlmsg_cancel - Cancel construction of a generic netlink message 286 * @skb: socket buffer the message is stored in 287 * @hdr: generic netlink message header 288 */ 289 static inline void genlmsg_cancel(struct sk_buff *skb, void *hdr) 290 { 291 if (hdr) 292 nlmsg_cancel(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN); 293 } 294 295 /** 296 * genlmsg_multicast_netns - multicast a netlink message to a specific netns 297 * @family: the generic netlink family 298 * @net: the net namespace 299 * @skb: netlink message as socket buffer 300 * @portid: own netlink portid to avoid sending to yourself 301 * @group: offset of multicast group in groups array 302 * @flags: allocation flags 303 */ 304 static inline int genlmsg_multicast_netns(const struct genl_family *family, 305 struct net *net, struct sk_buff *skb, 306 u32 portid, unsigned int group, gfp_t flags) 307 { 308 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 309 return -EINVAL; 310 group = family->mcgrp_offset + group; 311 return nlmsg_multicast(net->genl_sock, skb, portid, group, flags); 312 } 313 314 /** 315 * genlmsg_multicast - multicast a netlink message to the default netns 316 * @family: the generic netlink family 317 * @skb: netlink message as socket buffer 318 * @portid: own netlink portid to avoid sending to yourself 319 * @group: offset of multicast group in groups array 320 * @flags: allocation flags 321 */ 322 static inline int genlmsg_multicast(const struct genl_family *family, 323 struct sk_buff *skb, u32 portid, 324 unsigned int group, gfp_t flags) 325 { 326 return genlmsg_multicast_netns(family, &init_net, skb, 327 portid, group, flags); 328 } 329 330 /** 331 * genlmsg_multicast_allns - multicast a netlink message to all net namespaces 332 * @family: the generic netlink family 333 * @skb: netlink message as socket buffer 334 * @portid: own netlink portid to avoid sending to yourself 335 * @group: offset of multicast group in groups array 336 * @flags: allocation flags 337 * 338 * This function must hold the RTNL or rcu_read_lock(). 339 */ 340 int genlmsg_multicast_allns(const struct genl_family *family, 341 struct sk_buff *skb, u32 portid, 342 unsigned int group, gfp_t flags); 343 344 /** 345 * genlmsg_unicast - unicast a netlink message 346 * @skb: netlink message as socket buffer 347 * @portid: netlink portid of the destination socket 348 */ 349 static inline int genlmsg_unicast(struct net *net, struct sk_buff *skb, u32 portid) 350 { 351 return nlmsg_unicast(net->genl_sock, skb, portid); 352 } 353 354 /** 355 * genlmsg_reply - reply to a request 356 * @skb: netlink message to be sent back 357 * @info: receiver information 358 */ 359 static inline int genlmsg_reply(struct sk_buff *skb, struct genl_info *info) 360 { 361 return genlmsg_unicast(genl_info_net(info), skb, info->snd_portid); 362 } 363 364 /** 365 * gennlmsg_data - head of message payload 366 * @gnlh: genetlink message header 367 */ 368 static inline void *genlmsg_data(const struct genlmsghdr *gnlh) 369 { 370 return ((unsigned char *) gnlh + GENL_HDRLEN); 371 } 372 373 /** 374 * genlmsg_len - length of message payload 375 * @gnlh: genetlink message header 376 */ 377 static inline int genlmsg_len(const struct genlmsghdr *gnlh) 378 { 379 struct nlmsghdr *nlh = (struct nlmsghdr *)((unsigned char *)gnlh - 380 NLMSG_HDRLEN); 381 return (nlh->nlmsg_len - GENL_HDRLEN - NLMSG_HDRLEN); 382 } 383 384 /** 385 * genlmsg_msg_size - length of genetlink message not including padding 386 * @payload: length of message payload 387 */ 388 static inline int genlmsg_msg_size(int payload) 389 { 390 return GENL_HDRLEN + payload; 391 } 392 393 /** 394 * genlmsg_total_size - length of genetlink message including padding 395 * @payload: length of message payload 396 */ 397 static inline int genlmsg_total_size(int payload) 398 { 399 return NLMSG_ALIGN(genlmsg_msg_size(payload)); 400 } 401 402 /** 403 * genlmsg_new - Allocate a new generic netlink message 404 * @payload: size of the message payload 405 * @flags: the type of memory to allocate. 406 */ 407 static inline struct sk_buff *genlmsg_new(size_t payload, gfp_t flags) 408 { 409 return nlmsg_new(genlmsg_total_size(payload), flags); 410 } 411 412 /** 413 * genl_set_err - report error to genetlink broadcast listeners 414 * @family: the generic netlink family 415 * @net: the network namespace to report the error to 416 * @portid: the PORTID of a process that we want to skip (if any) 417 * @group: the broadcast group that will notice the error 418 * (this is the offset of the multicast group in the groups array) 419 * @code: error code, must be negative (as usual in kernelspace) 420 * 421 * This function returns the number of broadcast listeners that have set the 422 * NETLINK_RECV_NO_ENOBUFS socket option. 423 */ 424 static inline int genl_set_err(const struct genl_family *family, 425 struct net *net, u32 portid, 426 u32 group, int code) 427 { 428 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 429 return -EINVAL; 430 group = family->mcgrp_offset + group; 431 return netlink_set_err(net->genl_sock, portid, group, code); 432 } 433 434 static inline int genl_has_listeners(const struct genl_family *family, 435 struct net *net, unsigned int group) 436 { 437 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 438 return -EINVAL; 439 group = family->mcgrp_offset + group; 440 return netlink_has_listeners(net->genl_sock, group); 441 } 442 #endif /* __NET_GENERIC_NETLINK_H */ 443