Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 2 | #ifndef __NET_GENERIC_NETLINK_H |
| 3 | #define __NET_GENERIC_NETLINK_H |
| 4 | |
| 5 | #include <linux/genetlink.h> |
| 6 | #include <net/netlink.h> |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 7 | #include <net/net_namespace.h> |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 8 | |
Thomas Graf | 58050fc | 2012-06-28 03:57:45 +0000 | [diff] [blame] | 9 | #define GENLMSG_DEFAULT_SIZE (NLMSG_DEFAULT_SIZE - GENL_HDRLEN) |
| 10 | |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 11 | /** |
Johannes Berg | 2dbba6f | 2007-07-18 15:47:52 -0700 | [diff] [blame] | 12 | * struct genl_multicast_group - generic netlink multicast group |
| 13 | * @name: name of the multicast group, names are per-family |
Johannes Berg | 2dbba6f | 2007-07-18 15:47:52 -0700 | [diff] [blame] | 14 | */ |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 15 | struct genl_multicast_group { |
Johannes Berg | 2dbba6f | 2007-07-18 15:47:52 -0700 | [diff] [blame] | 16 | char name[GENL_NAMSIZ]; |
Johannes Berg | 2dbba6f | 2007-07-18 15:47:52 -0700 | [diff] [blame] | 17 | }; |
| 18 | |
Johannes Berg | ff4c92d | 2010-10-04 21:14:03 +0200 | [diff] [blame] | 19 | struct genl_ops; |
| 20 | struct genl_info; |
| 21 | |
Johannes Berg | 2dbba6f | 2007-07-18 15:47:52 -0700 | [diff] [blame] | 22 | /** |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 23 | * struct genl_family - generic netlink family |
Johannes Berg | a07ea4d | 2016-10-24 14:40:02 +0200 | [diff] [blame] | 24 | * @id: protocol family identifier (private) |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 25 | * @hdrsize: length of user specific header in bytes |
| 26 | * @name: name of family |
| 27 | * @version: protocol version |
| 28 | * @maxattr: maximum number of attributes supported |
Johannes Berg | 3b0f31f | 2019-03-21 22:51:02 +0100 | [diff] [blame] | 29 | * @policy: netlink policy |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 30 | * @netnsok: set to true if the family can handle network |
| 31 | * namespaces and should be presented in all of them |
Johannes Berg | f555f3d | 2015-01-16 11:37:12 +0100 | [diff] [blame] | 32 | * @parallel_ops: operations can be called in parallel and aren't |
| 33 | * synchronized by the core genetlink code |
Johannes Berg | ff4c92d | 2010-10-04 21:14:03 +0200 | [diff] [blame] | 34 | * @pre_doit: called before an operation's doit callback, it may |
| 35 | * do additional, common, filtering and return an error |
| 36 | * @post_doit: called after an operation's doit callback, it may |
| 37 | * undo operations done by pre_doit, for example release locks |
Johannes Berg | c380d9a | 2014-12-23 20:54:40 +0100 | [diff] [blame] | 38 | * @mcast_bind: a socket bound to the given multicast group (which |
| 39 | * is given as the offset into the groups array) |
Johannes Berg | ee1c2442 | 2015-01-16 11:37:14 +0100 | [diff] [blame] | 40 | * @mcast_unbind: a socket was unbound from the given multicast group. |
| 41 | * Note that unbind() will not be called symmetrically if the |
| 42 | * generic netlink family is removed while there are still open |
| 43 | * sockets. |
Johannes Berg | 489111e | 2016-10-24 14:40:03 +0200 | [diff] [blame] | 44 | * @attrbuf: buffer to store parsed attributes (private) |
Johannes Berg | 489111e | 2016-10-24 14:40:03 +0200 | [diff] [blame] | 45 | * @mcgrps: multicast groups used by this family |
| 46 | * @n_mcgrps: number of multicast groups |
Johannes Berg | 2a94fe4 | 2013-11-19 15:19:39 +0100 | [diff] [blame] | 47 | * @mcgrp_offset: starting number of multicast group IDs in this family |
Johannes Berg | 489111e | 2016-10-24 14:40:03 +0200 | [diff] [blame] | 48 | * (private) |
| 49 | * @ops: the operations supported by this family |
| 50 | * @n_ops: number of operations supported by this family |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 51 | */ |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 52 | struct genl_family { |
David S. Miller | 98e4321 | 2016-11-13 12:14:59 -0500 | [diff] [blame] | 53 | int id; /* private */ |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 54 | unsigned int hdrsize; |
| 55 | char name[GENL_NAMSIZ]; |
| 56 | unsigned int version; |
| 57 | unsigned int maxattr; |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 58 | bool netnsok; |
Pravin B Shelar | def31174 | 2013-04-23 07:48:30 +0000 | [diff] [blame] | 59 | bool parallel_ops; |
Johannes Berg | 3b0f31f | 2019-03-21 22:51:02 +0100 | [diff] [blame] | 60 | const struct nla_policy *policy; |
Johannes Berg | f84f771 | 2013-11-14 17:14:45 +0100 | [diff] [blame] | 61 | int (*pre_doit)(const struct genl_ops *ops, |
Johannes Berg | ff4c92d | 2010-10-04 21:14:03 +0200 | [diff] [blame] | 62 | struct sk_buff *skb, |
| 63 | struct genl_info *info); |
Johannes Berg | f84f771 | 2013-11-14 17:14:45 +0100 | [diff] [blame] | 64 | void (*post_doit)(const struct genl_ops *ops, |
Johannes Berg | ff4c92d | 2010-10-04 21:14:03 +0200 | [diff] [blame] | 65 | struct sk_buff *skb, |
| 66 | struct genl_info *info); |
Johannes Berg | 023e2cf | 2014-12-23 21:00:06 +0100 | [diff] [blame] | 67 | int (*mcast_bind)(struct net *net, int group); |
| 68 | void (*mcast_unbind)(struct net *net, int group); |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 69 | struct nlattr ** attrbuf; /* private */ |
Johannes Berg | 489111e | 2016-10-24 14:40:03 +0200 | [diff] [blame] | 70 | const struct genl_ops * ops; |
| 71 | const struct genl_multicast_group *mcgrps; |
| 72 | unsigned int n_ops; |
| 73 | unsigned int n_mcgrps; |
Johannes Berg | 2a94fe4 | 2013-11-19 15:19:39 +0100 | [diff] [blame] | 74 | unsigned int mcgrp_offset; /* private */ |
Pravin B Shelar | 33c6b1f | 2013-08-23 12:45:04 -0700 | [diff] [blame] | 75 | struct module *module; |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 76 | }; |
| 77 | |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 78 | /** |
| 79 | * struct genl_info - receiving information |
| 80 | * @snd_seq: sending sequence number |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 81 | * @snd_portid: netlink portid of sender |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 82 | * @nlhdr: netlink message header |
| 83 | * @genlhdr: generic netlink message header |
| 84 | * @userhdr: user specific header |
| 85 | * @attrs: netlink attributes |
Johannes Berg | ff4c92d | 2010-10-04 21:14:03 +0200 | [diff] [blame] | 86 | * @_net: network namespace |
| 87 | * @user_ptr: user pointers |
Johannes Berg | 7ab606d | 2017-04-12 14:34:05 +0200 | [diff] [blame] | 88 | * @extack: extended ACK report struct |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 89 | */ |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 90 | struct genl_info { |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 91 | u32 snd_seq; |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 92 | u32 snd_portid; |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 93 | struct nlmsghdr * nlhdr; |
| 94 | struct genlmsghdr * genlhdr; |
| 95 | void * userhdr; |
| 96 | struct nlattr ** attrs; |
Eric W. Biederman | 0c5c9fb | 2015-03-11 23:06:44 -0500 | [diff] [blame] | 97 | possible_net_t _net; |
Johannes Berg | ff4c92d | 2010-10-04 21:14:03 +0200 | [diff] [blame] | 98 | void * user_ptr[2]; |
Johannes Berg | 7ab606d | 2017-04-12 14:34:05 +0200 | [diff] [blame] | 99 | struct netlink_ext_ack *extack; |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 100 | }; |
| 101 | |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 102 | static inline struct net *genl_info_net(struct genl_info *info) |
| 103 | { |
Eric Dumazet | c2d9ba9 | 2010-06-01 06:51:19 +0000 | [diff] [blame] | 104 | return read_pnet(&info->_net); |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | static inline void genl_info_net_set(struct genl_info *info, struct net *net) |
| 108 | { |
Eric Dumazet | c2d9ba9 | 2010-06-01 06:51:19 +0000 | [diff] [blame] | 109 | write_pnet(&info->_net, net); |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 110 | } |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 111 | |
Johannes Berg | 7ab606d | 2017-04-12 14:34:05 +0200 | [diff] [blame] | 112 | #define GENL_SET_ERR_MSG(info, msg) NL_SET_ERR_MSG((info)->extack, msg) |
| 113 | |
| 114 | static inline int genl_err_attr(struct genl_info *info, int err, |
Michal Kubecek | 6fce10f | 2018-08-28 18:51:58 +0200 | [diff] [blame] | 115 | const struct nlattr *attr) |
Johannes Berg | 7ab606d | 2017-04-12 14:34:05 +0200 | [diff] [blame] | 116 | { |
| 117 | info->extack->bad_attr = attr; |
| 118 | |
| 119 | return err; |
| 120 | } |
| 121 | |
Johannes Berg | ef6243a | 2019-04-26 14:07:31 +0200 | [diff] [blame] | 122 | enum genl_validate_flags { |
| 123 | GENL_DONT_VALIDATE_STRICT = BIT(0), |
| 124 | GENL_DONT_VALIDATE_DUMP = BIT(1), |
| 125 | GENL_DONT_VALIDATE_DUMP_STRICT = BIT(2), |
| 126 | }; |
| 127 | |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 128 | /** |
Jiri Pirko | 1927f41 | 2019-10-05 20:04:34 +0200 | [diff] [blame] | 129 | * struct genl_info - info that is available during dumpit op call |
Jiri Pirko | bf813b0 | 2019-10-05 20:04:36 +0200 | [diff] [blame] | 130 | * @family: generic netlink family - for internal genl code usage |
Jiri Pirko | 1927f41 | 2019-10-05 20:04:34 +0200 | [diff] [blame] | 131 | * @ops: generic netlink ops - for internal genl code usage |
Jiri Pirko | bf813b0 | 2019-10-05 20:04:36 +0200 | [diff] [blame] | 132 | * @attrs: netlink attributes |
Jiri Pirko | 1927f41 | 2019-10-05 20:04:34 +0200 | [diff] [blame] | 133 | */ |
| 134 | struct genl_dumpit_info { |
Jiri Pirko | bf813b0 | 2019-10-05 20:04:36 +0200 | [diff] [blame] | 135 | const struct genl_family *family; |
Jiri Pirko | 1927f41 | 2019-10-05 20:04:34 +0200 | [diff] [blame] | 136 | const struct genl_ops *ops; |
Jiri Pirko | bf813b0 | 2019-10-05 20:04:36 +0200 | [diff] [blame] | 137 | struct nlattr **attrs; |
Jiri Pirko | 1927f41 | 2019-10-05 20:04:34 +0200 | [diff] [blame] | 138 | }; |
| 139 | |
| 140 | static inline const struct genl_dumpit_info * |
| 141 | genl_dumpit_info(struct netlink_callback *cb) |
| 142 | { |
| 143 | return cb->data; |
| 144 | } |
| 145 | |
| 146 | /** |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 147 | * struct genl_ops - generic netlink operations |
| 148 | * @cmd: command identifier |
Johannes Berg | ff4c92d | 2010-10-04 21:14:03 +0200 | [diff] [blame] | 149 | * @internal_flags: flags used by the family |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 150 | * @flags: flags |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 151 | * @doit: standard command callback |
Tom Herbert | fc9e50f | 2015-12-15 15:41:37 -0800 | [diff] [blame] | 152 | * @start: start callback for dumps |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 153 | * @dumpit: callback for dumpers |
Jamal Hadi Salim | a4d1366 | 2006-12-01 20:07:42 -0800 | [diff] [blame] | 154 | * @done: completion callback for dumps |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 155 | */ |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 156 | struct genl_ops { |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 157 | int (*doit)(struct sk_buff *skb, |
| 158 | struct genl_info *info); |
Tom Herbert | fc9e50f | 2015-12-15 15:41:37 -0800 | [diff] [blame] | 159 | int (*start)(struct netlink_callback *cb); |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 160 | int (*dumpit)(struct sk_buff *skb, |
| 161 | struct netlink_callback *cb); |
Jamal Hadi Salim | a4d1366 | 2006-12-01 20:07:42 -0800 | [diff] [blame] | 162 | int (*done)(struct netlink_callback *cb); |
Johannes Berg | 3f5ccd0 | 2013-11-14 17:14:47 +0100 | [diff] [blame] | 163 | u8 cmd; |
| 164 | u8 internal_flags; |
| 165 | u8 flags; |
Johannes Berg | ef6243a | 2019-04-26 14:07:31 +0200 | [diff] [blame] | 166 | u8 validate; |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 167 | }; |
| 168 | |
Johannes Berg | 489111e | 2016-10-24 14:40:03 +0200 | [diff] [blame] | 169 | int genl_register_family(struct genl_family *family); |
Johannes Berg | 2ae0f17 | 2016-10-24 14:40:04 +0200 | [diff] [blame] | 170 | int genl_unregister_family(const struct genl_family *family); |
| 171 | void genl_notify(const struct genl_family *family, struct sk_buff *skb, |
Jiri Benc | 92c14d9 | 2015-09-22 18:56:43 +0200 | [diff] [blame] | 172 | struct genl_info *info, u32 group, gfp_t flags); |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 173 | |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 174 | void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, |
Johannes Berg | 2ae0f17 | 2016-10-24 14:40:04 +0200 | [diff] [blame] | 175 | const struct genl_family *family, int flags, u8 cmd); |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 176 | |
| 177 | /** |
Johannes Berg | 670dc28 | 2011-06-20 13:40:46 +0200 | [diff] [blame] | 178 | * genlmsg_nlhdr - Obtain netlink header from user specified header |
| 179 | * @user_hdr: user header as returned from genlmsg_put() |
Johannes Berg | 670dc28 | 2011-06-20 13:40:46 +0200 | [diff] [blame] | 180 | * |
| 181 | * Returns pointer to netlink header. |
| 182 | */ |
Michal Kubecek | 0a833c2 | 2017-11-15 13:09:32 +0100 | [diff] [blame] | 183 | static inline struct nlmsghdr *genlmsg_nlhdr(void *user_hdr) |
Johannes Berg | 670dc28 | 2011-06-20 13:40:46 +0200 | [diff] [blame] | 184 | { |
| 185 | return (struct nlmsghdr *)((char *)user_hdr - |
Johannes Berg | 670dc28 | 2011-06-20 13:40:46 +0200 | [diff] [blame] | 186 | GENL_HDRLEN - |
| 187 | NLMSG_HDRLEN); |
| 188 | } |
| 189 | |
| 190 | /** |
Johannes Berg | 8cb0817 | 2019-04-26 14:07:28 +0200 | [diff] [blame] | 191 | * genlmsg_parse_deprecated - parse attributes of a genetlink message |
Joe Stringer | 7b1883c | 2015-01-21 16:42:51 -0800 | [diff] [blame] | 192 | * @nlh: netlink message header |
| 193 | * @family: genetlink message family |
| 194 | * @tb: destination array with maxtype+1 elements |
| 195 | * @maxtype: maximum attribute type to be expected |
| 196 | * @policy: validation policy |
Johannes Berg | fceb643 | 2017-04-12 14:34:07 +0200 | [diff] [blame] | 197 | * @extack: extended ACK report struct |
| 198 | */ |
Johannes Berg | 8cb0817 | 2019-04-26 14:07:28 +0200 | [diff] [blame] | 199 | static inline int genlmsg_parse_deprecated(const struct nlmsghdr *nlh, |
| 200 | const struct genl_family *family, |
| 201 | struct nlattr *tb[], int maxtype, |
| 202 | const struct nla_policy *policy, |
| 203 | struct netlink_ext_ack *extack) |
Joe Stringer | 7b1883c | 2015-01-21 16:42:51 -0800 | [diff] [blame] | 204 | { |
Johannes Berg | 8cb0817 | 2019-04-26 14:07:28 +0200 | [diff] [blame] | 205 | return __nlmsg_parse(nlh, family->hdrsize + GENL_HDRLEN, tb, maxtype, |
| 206 | policy, NL_VALIDATE_LIBERAL, extack); |
Joe Stringer | 7b1883c | 2015-01-21 16:42:51 -0800 | [diff] [blame] | 207 | } |
| 208 | |
| 209 | /** |
Johannes Berg | 3de6440 | 2019-04-26 14:07:29 +0200 | [diff] [blame] | 210 | * genlmsg_parse - parse attributes of a genetlink message |
| 211 | * @nlh: netlink message header |
| 212 | * @family: genetlink message family |
| 213 | * @tb: destination array with maxtype+1 elements |
| 214 | * @maxtype: maximum attribute type to be expected |
| 215 | * @policy: validation policy |
| 216 | * @extack: extended ACK report struct |
| 217 | */ |
| 218 | static inline int genlmsg_parse(const struct nlmsghdr *nlh, |
| 219 | const struct genl_family *family, |
| 220 | struct nlattr *tb[], int maxtype, |
| 221 | const struct nla_policy *policy, |
| 222 | struct netlink_ext_ack *extack) |
| 223 | { |
| 224 | return __nlmsg_parse(nlh, family->hdrsize + GENL_HDRLEN, tb, maxtype, |
| 225 | policy, NL_VALIDATE_STRICT, extack); |
| 226 | } |
| 227 | |
| 228 | /** |
Johannes Berg | 670dc28 | 2011-06-20 13:40:46 +0200 | [diff] [blame] | 229 | * genl_dump_check_consistent - check if sequence is consistent and advertise if not |
| 230 | * @cb: netlink callback structure that stores the sequence number |
| 231 | * @user_hdr: user header as returned from genlmsg_put() |
Johannes Berg | 670dc28 | 2011-06-20 13:40:46 +0200 | [diff] [blame] | 232 | * |
| 233 | * Cf. nl_dump_check_consistent(), this just provides a wrapper to make it |
| 234 | * simpler to use with generic netlink. |
| 235 | */ |
| 236 | static inline void genl_dump_check_consistent(struct netlink_callback *cb, |
Michal Kubecek | 0a833c2 | 2017-11-15 13:09:32 +0100 | [diff] [blame] | 237 | void *user_hdr) |
Johannes Berg | 670dc28 | 2011-06-20 13:40:46 +0200 | [diff] [blame] | 238 | { |
Michal Kubecek | 0a833c2 | 2017-11-15 13:09:32 +0100 | [diff] [blame] | 239 | nl_dump_check_consistent(cb, genlmsg_nlhdr(user_hdr)); |
Johannes Berg | 670dc28 | 2011-06-20 13:40:46 +0200 | [diff] [blame] | 240 | } |
| 241 | |
| 242 | /** |
Thomas Graf | 17c157c | 2006-11-14 19:46:02 -0800 | [diff] [blame] | 243 | * genlmsg_put_reply - Add generic netlink header to a reply message |
| 244 | * @skb: socket buffer holding the message |
| 245 | * @info: receiver info |
| 246 | * @family: generic netlink family |
| 247 | * @flags: netlink message flags |
| 248 | * @cmd: generic netlink command |
| 249 | * |
| 250 | * Returns pointer to user specific header |
| 251 | */ |
| 252 | static inline void *genlmsg_put_reply(struct sk_buff *skb, |
| 253 | struct genl_info *info, |
Johannes Berg | 2ae0f17 | 2016-10-24 14:40:04 +0200 | [diff] [blame] | 254 | const struct genl_family *family, |
Thomas Graf | 17c157c | 2006-11-14 19:46:02 -0800 | [diff] [blame] | 255 | int flags, u8 cmd) |
| 256 | { |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 257 | return genlmsg_put(skb, info->snd_portid, info->snd_seq, family, |
Thomas Graf | 17c157c | 2006-11-14 19:46:02 -0800 | [diff] [blame] | 258 | flags, cmd); |
| 259 | } |
| 260 | |
| 261 | /** |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 262 | * genlmsg_end - Finalize a generic netlink message |
| 263 | * @skb: socket buffer the message is stored in |
| 264 | * @hdr: user specific header |
| 265 | */ |
Johannes Berg | 053c095 | 2015-01-16 22:09:00 +0100 | [diff] [blame] | 266 | static inline void genlmsg_end(struct sk_buff *skb, void *hdr) |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 267 | { |
Johannes Berg | 053c095 | 2015-01-16 22:09:00 +0100 | [diff] [blame] | 268 | nlmsg_end(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN); |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | /** |
| 272 | * genlmsg_cancel - Cancel construction of a generic netlink message |
| 273 | * @skb: socket buffer the message is stored in |
| 274 | * @hdr: generic netlink message header |
| 275 | */ |
Thomas Graf | bc3ed28 | 2008-06-03 16:36:54 -0700 | [diff] [blame] | 276 | static inline void genlmsg_cancel(struct sk_buff *skb, void *hdr) |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 277 | { |
Julia Lawall | 38db9e1 | 2011-01-28 05:43:40 +0000 | [diff] [blame] | 278 | if (hdr) |
| 279 | nlmsg_cancel(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN); |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | /** |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 283 | * genlmsg_multicast_netns - multicast a netlink message to a specific netns |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame] | 284 | * @family: the generic netlink family |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 285 | * @net: the net namespace |
| 286 | * @skb: netlink message as socket buffer |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 287 | * @portid: own netlink portid to avoid sending to yourself |
Johannes Berg | 2a94fe4 | 2013-11-19 15:19:39 +0100 | [diff] [blame] | 288 | * @group: offset of multicast group in groups array |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 289 | * @flags: allocation flags |
| 290 | */ |
Johannes Berg | 2ae0f17 | 2016-10-24 14:40:04 +0200 | [diff] [blame] | 291 | static inline int genlmsg_multicast_netns(const struct genl_family *family, |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame] | 292 | struct net *net, struct sk_buff *skb, |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 293 | u32 portid, unsigned int group, gfp_t flags) |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 294 | { |
Johannes Berg | 220815a | 2013-11-21 18:17:04 +0100 | [diff] [blame] | 295 | if (WARN_ON_ONCE(group >= family->n_mcgrps)) |
Johannes Berg | 2a94fe4 | 2013-11-19 15:19:39 +0100 | [diff] [blame] | 296 | return -EINVAL; |
| 297 | group = family->mcgrp_offset + group; |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 298 | return nlmsg_multicast(net->genl_sock, skb, portid, group, flags); |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 299 | } |
| 300 | |
| 301 | /** |
| 302 | * genlmsg_multicast - multicast a netlink message to the default netns |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame] | 303 | * @family: the generic netlink family |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 304 | * @skb: netlink message as socket buffer |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 305 | * @portid: own netlink portid to avoid sending to yourself |
Johannes Berg | 2a94fe4 | 2013-11-19 15:19:39 +0100 | [diff] [blame] | 306 | * @group: offset of multicast group in groups array |
Thomas Graf | d387f6a | 2006-08-15 00:31:06 -0700 | [diff] [blame] | 307 | * @flags: allocation flags |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 308 | */ |
Johannes Berg | 2ae0f17 | 2016-10-24 14:40:04 +0200 | [diff] [blame] | 309 | static inline int genlmsg_multicast(const struct genl_family *family, |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame] | 310 | struct sk_buff *skb, u32 portid, |
Thomas Graf | d387f6a | 2006-08-15 00:31:06 -0700 | [diff] [blame] | 311 | unsigned int group, gfp_t flags) |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 312 | { |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame] | 313 | return genlmsg_multicast_netns(family, &init_net, skb, |
| 314 | portid, group, flags); |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 315 | } |
| 316 | |
| 317 | /** |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 318 | * genlmsg_multicast_allns - multicast a netlink message to all net namespaces |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame] | 319 | * @family: the generic netlink family |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 320 | * @skb: netlink message as socket buffer |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 321 | * @portid: own netlink portid to avoid sending to yourself |
Johannes Berg | 2a94fe4 | 2013-11-19 15:19:39 +0100 | [diff] [blame] | 322 | * @group: offset of multicast group in groups array |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 323 | * @flags: allocation flags |
| 324 | * |
| 325 | * This function must hold the RTNL or rcu_read_lock(). |
| 326 | */ |
Johannes Berg | 2ae0f17 | 2016-10-24 14:40:04 +0200 | [diff] [blame] | 327 | int genlmsg_multicast_allns(const struct genl_family *family, |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame] | 328 | struct sk_buff *skb, u32 portid, |
Johannes Berg | 134e637 | 2009-07-10 09:51:34 +0000 | [diff] [blame] | 329 | unsigned int group, gfp_t flags); |
| 330 | |
| 331 | /** |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 332 | * genlmsg_unicast - unicast a netlink message |
| 333 | * @skb: netlink message as socket buffer |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 334 | * @portid: netlink portid of the destination socket |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 335 | */ |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 336 | static inline int genlmsg_unicast(struct net *net, struct sk_buff *skb, u32 portid) |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 337 | { |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 338 | return nlmsg_unicast(net->genl_sock, skb, portid); |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 339 | } |
| 340 | |
Balbir Singh | fb0ba6bd | 2006-07-14 00:24:39 -0700 | [diff] [blame] | 341 | /** |
Thomas Graf | 81878d2 | 2006-11-14 19:45:27 -0800 | [diff] [blame] | 342 | * genlmsg_reply - reply to a request |
| 343 | * @skb: netlink message to be sent back |
| 344 | * @info: receiver information |
| 345 | */ |
| 346 | static inline int genlmsg_reply(struct sk_buff *skb, struct genl_info *info) |
| 347 | { |
Eric W. Biederman | 15e4730 | 2012-09-07 20:12:54 +0000 | [diff] [blame] | 348 | return genlmsg_unicast(genl_info_net(info), skb, info->snd_portid); |
Thomas Graf | 81878d2 | 2006-11-14 19:45:27 -0800 | [diff] [blame] | 349 | } |
| 350 | |
| 351 | /** |
Balbir Singh | fb0ba6bd | 2006-07-14 00:24:39 -0700 | [diff] [blame] | 352 | * gennlmsg_data - head of message payload |
Justin P. Mattock | 70f23fd | 2011-05-10 10:16:21 +0200 | [diff] [blame] | 353 | * @gnlh: genetlink message header |
Balbir Singh | fb0ba6bd | 2006-07-14 00:24:39 -0700 | [diff] [blame] | 354 | */ |
| 355 | static inline void *genlmsg_data(const struct genlmsghdr *gnlh) |
| 356 | { |
| 357 | return ((unsigned char *) gnlh + GENL_HDRLEN); |
| 358 | } |
| 359 | |
| 360 | /** |
| 361 | * genlmsg_len - length of message payload |
| 362 | * @gnlh: genetlink message header |
| 363 | */ |
| 364 | static inline int genlmsg_len(const struct genlmsghdr *gnlh) |
| 365 | { |
| 366 | struct nlmsghdr *nlh = (struct nlmsghdr *)((unsigned char *)gnlh - |
| 367 | NLMSG_HDRLEN); |
| 368 | return (nlh->nlmsg_len - GENL_HDRLEN - NLMSG_HDRLEN); |
| 369 | } |
| 370 | |
Balbir Singh | 17db952 | 2006-09-30 23:28:51 -0700 | [diff] [blame] | 371 | /** |
| 372 | * genlmsg_msg_size - length of genetlink message not including padding |
| 373 | * @payload: length of message payload |
| 374 | */ |
| 375 | static inline int genlmsg_msg_size(int payload) |
| 376 | { |
| 377 | return GENL_HDRLEN + payload; |
| 378 | } |
| 379 | |
| 380 | /** |
| 381 | * genlmsg_total_size - length of genetlink message including padding |
| 382 | * @payload: length of message payload |
| 383 | */ |
| 384 | static inline int genlmsg_total_size(int payload) |
| 385 | { |
| 386 | return NLMSG_ALIGN(genlmsg_msg_size(payload)); |
| 387 | } |
| 388 | |
Thomas Graf | 3dabc71 | 2006-11-14 19:44:52 -0800 | [diff] [blame] | 389 | /** |
| 390 | * genlmsg_new - Allocate a new generic netlink message |
| 391 | * @payload: size of the message payload |
| 392 | * @flags: the type of memory to allocate. |
| 393 | */ |
| 394 | static inline struct sk_buff *genlmsg_new(size_t payload, gfp_t flags) |
| 395 | { |
| 396 | return nlmsg_new(genlmsg_total_size(payload), flags); |
| 397 | } |
| 398 | |
Johannes Berg | 62b68e9 | 2013-11-19 15:19:37 +0100 | [diff] [blame] | 399 | /** |
| 400 | * genl_set_err - report error to genetlink broadcast listeners |
Johannes Berg | 68eb550 | 2013-11-19 15:19:38 +0100 | [diff] [blame] | 401 | * @family: the generic netlink family |
Johannes Berg | 62b68e9 | 2013-11-19 15:19:37 +0100 | [diff] [blame] | 402 | * @net: the network namespace to report the error to |
| 403 | * @portid: the PORTID of a process that we want to skip (if any) |
| 404 | * @group: the broadcast group that will notice the error |
Johannes Berg | 2a94fe4 | 2013-11-19 15:19:39 +0100 | [diff] [blame] | 405 | * (this is the offset of the multicast group in the groups array) |
Johannes Berg | 62b68e9 | 2013-11-19 15:19:37 +0100 | [diff] [blame] | 406 | * @code: error code, must be negative (as usual in kernelspace) |
| 407 | * |
| 408 | * This function returns the number of broadcast listeners that have set the |
| 409 | * NETLINK_RECV_NO_ENOBUFS socket option. |
| 410 | */ |
Johannes Berg | 2ae0f17 | 2016-10-24 14:40:04 +0200 | [diff] [blame] | 411 | static inline int genl_set_err(const struct genl_family *family, |
| 412 | struct net *net, u32 portid, |
| 413 | u32 group, int code) |
Johannes Berg | 62b68e9 | 2013-11-19 15:19:37 +0100 | [diff] [blame] | 414 | { |
Johannes Berg | 91398a0 | 2013-11-21 18:20:28 +0100 | [diff] [blame] | 415 | if (WARN_ON_ONCE(group >= family->n_mcgrps)) |
| 416 | return -EINVAL; |
| 417 | group = family->mcgrp_offset + group; |
Johannes Berg | 62b68e9 | 2013-11-19 15:19:37 +0100 | [diff] [blame] | 418 | return netlink_set_err(net->genl_sock, portid, group, code); |
| 419 | } |
Thomas Graf | 3dabc71 | 2006-11-14 19:44:52 -0800 | [diff] [blame] | 420 | |
Johannes Berg | 2ae0f17 | 2016-10-24 14:40:04 +0200 | [diff] [blame] | 421 | static inline int genl_has_listeners(const struct genl_family *family, |
Johannes Berg | f8403a2 | 2014-12-22 18:56:36 +0100 | [diff] [blame] | 422 | struct net *net, unsigned int group) |
Nicolas Dichtel | 0d56637 | 2014-09-18 10:31:03 +0200 | [diff] [blame] | 423 | { |
| 424 | if (WARN_ON_ONCE(group >= family->n_mcgrps)) |
| 425 | return -EINVAL; |
| 426 | group = family->mcgrp_offset + group; |
Johannes Berg | f8403a2 | 2014-12-22 18:56:36 +0100 | [diff] [blame] | 427 | return netlink_has_listeners(net->genl_sock, group); |
Nicolas Dichtel | 0d56637 | 2014-09-18 10:31:03 +0200 | [diff] [blame] | 428 | } |
Thomas Graf | 482a852 | 2005-11-10 02:25:56 +0100 | [diff] [blame] | 429 | #endif /* __NET_GENERIC_NETLINK_H */ |