genetlink.h 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344
  1. #ifndef __NET_GENERIC_NETLINK_H
  2. #define __NET_GENERIC_NETLINK_H
  3. #include <linux/genetlink.h>
  4. #include <net/netlink.h>
  5. #include <net/net_namespace.h>
  6. /**
  7. * struct genl_multicast_group - generic netlink multicast group
  8. * @name: name of the multicast group, names are per-family
  9. * @id: multicast group ID, assigned by the core, to use with
  10. * genlmsg_multicast().
  11. * @list: list entry for linking
  12. * @family: pointer to family, need not be set before registering
  13. */
  14. struct genl_multicast_group {
  15. struct genl_family *family; /* private */
  16. struct list_head list; /* private */
  17. char name[GENL_NAMSIZ];
  18. u32 id;
  19. };
  20. struct genl_ops;
  21. struct genl_info;
  22. /**
  23. * struct genl_family - generic netlink family
  24. * @id: protocol family idenfitier
  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
  29. * @netnsok: set to true if the family can handle network
  30. * namespaces and should be presented in all of them
  31. * @pre_doit: called before an operation's doit callback, it may
  32. * do additional, common, filtering and return an error
  33. * @post_doit: called after an operation's doit callback, it may
  34. * undo operations done by pre_doit, for example release locks
  35. * @attrbuf: buffer to store parsed attributes
  36. * @ops_list: list of all assigned operations
  37. * @family_list: family list
  38. * @mcast_groups: multicast groups list
  39. */
  40. struct genl_family {
  41. unsigned int id;
  42. unsigned int hdrsize;
  43. char name[GENL_NAMSIZ];
  44. unsigned int version;
  45. unsigned int maxattr;
  46. bool netnsok;
  47. int (*pre_doit)(struct genl_ops *ops,
  48. struct sk_buff *skb,
  49. struct genl_info *info);
  50. void (*post_doit)(struct genl_ops *ops,
  51. struct sk_buff *skb,
  52. struct genl_info *info);
  53. struct nlattr ** attrbuf; /* private */
  54. struct list_head ops_list; /* private */
  55. struct list_head family_list; /* private */
  56. struct list_head mcast_groups; /* private */
  57. };
  58. /**
  59. * struct genl_info - receiving information
  60. * @snd_seq: sending sequence number
  61. * @snd_pid: netlink pid of sender
  62. * @nlhdr: netlink message header
  63. * @genlhdr: generic netlink message header
  64. * @userhdr: user specific header
  65. * @attrs: netlink attributes
  66. * @_net: network namespace
  67. * @user_ptr: user pointers
  68. */
  69. struct genl_info {
  70. u32 snd_seq;
  71. u32 snd_pid;
  72. struct nlmsghdr * nlhdr;
  73. struct genlmsghdr * genlhdr;
  74. void * userhdr;
  75. struct nlattr ** attrs;
  76. #ifdef CONFIG_NET_NS
  77. struct net * _net;
  78. #endif
  79. void * user_ptr[2];
  80. };
  81. static inline struct net *genl_info_net(struct genl_info *info)
  82. {
  83. return read_pnet(&info->_net);
  84. }
  85. static inline void genl_info_net_set(struct genl_info *info, struct net *net)
  86. {
  87. write_pnet(&info->_net, net);
  88. }
  89. /**
  90. * struct genl_ops - generic netlink operations
  91. * @cmd: command identifier
  92. * @internal_flags: flags used by the family
  93. * @flags: flags
  94. * @policy: attribute validation policy
  95. * @doit: standard command callback
  96. * @dumpit: callback for dumpers
  97. * @done: completion callback for dumps
  98. * @ops_list: operations list
  99. */
  100. struct genl_ops {
  101. u8 cmd;
  102. u8 internal_flags;
  103. unsigned int flags;
  104. const struct nla_policy *policy;
  105. int (*doit)(struct sk_buff *skb,
  106. struct genl_info *info);
  107. int (*dumpit)(struct sk_buff *skb,
  108. struct netlink_callback *cb);
  109. int (*done)(struct netlink_callback *cb);
  110. struct list_head ops_list;
  111. };
  112. extern int genl_register_family(struct genl_family *family);
  113. extern int genl_register_family_with_ops(struct genl_family *family,
  114. struct genl_ops *ops, size_t n_ops);
  115. extern int genl_unregister_family(struct genl_family *family);
  116. extern int genl_register_ops(struct genl_family *, struct genl_ops *ops);
  117. extern int genl_unregister_ops(struct genl_family *, struct genl_ops *ops);
  118. extern int genl_register_mc_group(struct genl_family *family,
  119. struct genl_multicast_group *grp);
  120. extern void genl_unregister_mc_group(struct genl_family *family,
  121. struct genl_multicast_group *grp);
  122. extern void genl_notify(struct sk_buff *skb, struct net *net, u32 pid,
  123. u32 group, struct nlmsghdr *nlh, gfp_t flags);
  124. /**
  125. * genlmsg_put - Add generic netlink header to netlink message
  126. * @skb: socket buffer holding the message
  127. * @pid: netlink pid the message is addressed to
  128. * @seq: sequence number (usually the one of the sender)
  129. * @family: generic netlink family
  130. * @flags netlink message flags
  131. * @cmd: generic netlink command
  132. *
  133. * Returns pointer to user specific header
  134. */
  135. static inline void *genlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
  136. struct genl_family *family, int flags, u8 cmd)
  137. {
  138. struct nlmsghdr *nlh;
  139. struct genlmsghdr *hdr;
  140. nlh = nlmsg_put(skb, pid, seq, family->id, GENL_HDRLEN +
  141. family->hdrsize, flags);
  142. if (nlh == NULL)
  143. return NULL;
  144. hdr = nlmsg_data(nlh);
  145. hdr->cmd = cmd;
  146. hdr->version = family->version;
  147. hdr->reserved = 0;
  148. return (char *) hdr + GENL_HDRLEN;
  149. }
  150. /**
  151. * genlmsg_nlhdr - Obtain netlink header from user specified header
  152. * @user_hdr: user header as returned from genlmsg_put()
  153. * @family: generic netlink family
  154. *
  155. * Returns pointer to netlink header.
  156. */
  157. static inline struct nlmsghdr *genlmsg_nlhdr(void *user_hdr,
  158. struct genl_family *family)
  159. {
  160. return (struct nlmsghdr *)((char *)user_hdr -
  161. family->hdrsize -
  162. GENL_HDRLEN -
  163. NLMSG_HDRLEN);
  164. }
  165. /**
  166. * genl_dump_check_consistent - check if sequence is consistent and advertise if not
  167. * @cb: netlink callback structure that stores the sequence number
  168. * @user_hdr: user header as returned from genlmsg_put()
  169. * @family: generic netlink family
  170. *
  171. * Cf. nl_dump_check_consistent(), this just provides a wrapper to make it
  172. * simpler to use with generic netlink.
  173. */
  174. static inline void genl_dump_check_consistent(struct netlink_callback *cb,
  175. void *user_hdr,
  176. struct genl_family *family)
  177. {
  178. nl_dump_check_consistent(cb, genlmsg_nlhdr(user_hdr, family));
  179. }
  180. /**
  181. * genlmsg_put_reply - Add generic netlink header to a reply message
  182. * @skb: socket buffer holding the message
  183. * @info: receiver info
  184. * @family: generic netlink family
  185. * @flags: netlink message flags
  186. * @cmd: generic netlink command
  187. *
  188. * Returns pointer to user specific header
  189. */
  190. static inline void *genlmsg_put_reply(struct sk_buff *skb,
  191. struct genl_info *info,
  192. struct genl_family *family,
  193. int flags, u8 cmd)
  194. {
  195. return genlmsg_put(skb, info->snd_pid, info->snd_seq, family,
  196. flags, cmd);
  197. }
  198. /**
  199. * genlmsg_end - Finalize a generic netlink message
  200. * @skb: socket buffer the message is stored in
  201. * @hdr: user specific header
  202. */
  203. static inline int genlmsg_end(struct sk_buff *skb, void *hdr)
  204. {
  205. return nlmsg_end(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN);
  206. }
  207. /**
  208. * genlmsg_cancel - Cancel construction of a generic netlink message
  209. * @skb: socket buffer the message is stored in
  210. * @hdr: generic netlink message header
  211. */
  212. static inline void genlmsg_cancel(struct sk_buff *skb, void *hdr)
  213. {
  214. if (hdr)
  215. nlmsg_cancel(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN);
  216. }
  217. /**
  218. * genlmsg_multicast_netns - multicast a netlink message to a specific netns
  219. * @net: the net namespace
  220. * @skb: netlink message as socket buffer
  221. * @pid: own netlink pid to avoid sending to yourself
  222. * @group: multicast group id
  223. * @flags: allocation flags
  224. */
  225. static inline int genlmsg_multicast_netns(struct net *net, struct sk_buff *skb,
  226. u32 pid, unsigned int group, gfp_t flags)
  227. {
  228. return nlmsg_multicast(net->genl_sock, skb, pid, group, flags);
  229. }
  230. /**
  231. * genlmsg_multicast - multicast a netlink message to the default netns
  232. * @skb: netlink message as socket buffer
  233. * @pid: own netlink pid to avoid sending to yourself
  234. * @group: multicast group id
  235. * @flags: allocation flags
  236. */
  237. static inline int genlmsg_multicast(struct sk_buff *skb, u32 pid,
  238. unsigned int group, gfp_t flags)
  239. {
  240. return genlmsg_multicast_netns(&init_net, skb, pid, group, flags);
  241. }
  242. /**
  243. * genlmsg_multicast_allns - multicast a netlink message to all net namespaces
  244. * @skb: netlink message as socket buffer
  245. * @pid: own netlink pid to avoid sending to yourself
  246. * @group: multicast group id
  247. * @flags: allocation flags
  248. *
  249. * This function must hold the RTNL or rcu_read_lock().
  250. */
  251. int genlmsg_multicast_allns(struct sk_buff *skb, u32 pid,
  252. unsigned int group, gfp_t flags);
  253. /**
  254. * genlmsg_unicast - unicast a netlink message
  255. * @skb: netlink message as socket buffer
  256. * @pid: netlink pid of the destination socket
  257. */
  258. static inline int genlmsg_unicast(struct net *net, struct sk_buff *skb, u32 pid)
  259. {
  260. return nlmsg_unicast(net->genl_sock, skb, pid);
  261. }
  262. /**
  263. * genlmsg_reply - reply to a request
  264. * @skb: netlink message to be sent back
  265. * @info: receiver information
  266. */
  267. static inline int genlmsg_reply(struct sk_buff *skb, struct genl_info *info)
  268. {
  269. return genlmsg_unicast(genl_info_net(info), skb, info->snd_pid);
  270. }
  271. /**
  272. * gennlmsg_data - head of message payload
  273. * @gnlh: genetlink message header
  274. */
  275. static inline void *genlmsg_data(const struct genlmsghdr *gnlh)
  276. {
  277. return ((unsigned char *) gnlh + GENL_HDRLEN);
  278. }
  279. /**
  280. * genlmsg_len - length of message payload
  281. * @gnlh: genetlink message header
  282. */
  283. static inline int genlmsg_len(const struct genlmsghdr *gnlh)
  284. {
  285. struct nlmsghdr *nlh = (struct nlmsghdr *)((unsigned char *)gnlh -
  286. NLMSG_HDRLEN);
  287. return (nlh->nlmsg_len - GENL_HDRLEN - NLMSG_HDRLEN);
  288. }
  289. /**
  290. * genlmsg_msg_size - length of genetlink message not including padding
  291. * @payload: length of message payload
  292. */
  293. static inline int genlmsg_msg_size(int payload)
  294. {
  295. return GENL_HDRLEN + payload;
  296. }
  297. /**
  298. * genlmsg_total_size - length of genetlink message including padding
  299. * @payload: length of message payload
  300. */
  301. static inline int genlmsg_total_size(int payload)
  302. {
  303. return NLMSG_ALIGN(genlmsg_msg_size(payload));
  304. }
  305. /**
  306. * genlmsg_new - Allocate a new generic netlink message
  307. * @payload: size of the message payload
  308. * @flags: the type of memory to allocate.
  309. */
  310. static inline struct sk_buff *genlmsg_new(size_t payload, gfp_t flags)
  311. {
  312. return nlmsg_new(genlmsg_total_size(payload), flags);
  313. }
  314. #endif /* __NET_GENERIC_NETLINK_H */