Merge branches 'acpi-tables', 'acpi-osl', 'acpi-misc' and 'acpi-tools'
[linux-2.6-microblaze.git] / include / linux / netlink.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __LINUX_NETLINK_H
3 #define __LINUX_NETLINK_H
4
5
6 #include <linux/capability.h>
7 #include <linux/skbuff.h>
8 #include <linux/export.h>
9 #include <net/scm.h>
10 #include <uapi/linux/netlink.h>
11
12 struct net;
13
14 static inline struct nlmsghdr *nlmsg_hdr(const struct sk_buff *skb)
15 {
16         return (struct nlmsghdr *)skb->data;
17 }
18
19 enum netlink_skb_flags {
20         NETLINK_SKB_DST         = 0x8,  /* Dst set in sendto or sendmsg */
21 };
22
23 struct netlink_skb_parms {
24         struct scm_creds        creds;          /* Skb credentials      */
25         __u32                   portid;
26         __u32                   dst_group;
27         __u32                   flags;
28         struct sock             *sk;
29         bool                    nsid_is_set;
30         int                     nsid;
31 };
32
33 #define NETLINK_CB(skb)         (*(struct netlink_skb_parms*)&((skb)->cb))
34 #define NETLINK_CREDS(skb)      (&NETLINK_CB((skb)).creds)
35
36
37 void netlink_table_grab(void);
38 void netlink_table_ungrab(void);
39
40 #define NL_CFG_F_NONROOT_RECV   (1 << 0)
41 #define NL_CFG_F_NONROOT_SEND   (1 << 1)
42
43 /* optional Netlink kernel configuration parameters */
44 struct netlink_kernel_cfg {
45         unsigned int    groups;
46         unsigned int    flags;
47         void            (*input)(struct sk_buff *skb);
48         struct mutex    *cb_mutex;
49         int             (*bind)(struct net *net, int group);
50         void            (*unbind)(struct net *net, int group);
51         bool            (*compare)(struct net *net, struct sock *sk);
52 };
53
54 struct sock *__netlink_kernel_create(struct net *net, int unit,
55                                             struct module *module,
56                                             struct netlink_kernel_cfg *cfg);
57 static inline struct sock *
58 netlink_kernel_create(struct net *net, int unit, struct netlink_kernel_cfg *cfg)
59 {
60         return __netlink_kernel_create(net, unit, THIS_MODULE, cfg);
61 }
62
63 /* this can be increased when necessary - don't expose to userland */
64 #define NETLINK_MAX_COOKIE_LEN  20
65
66 /**
67  * struct netlink_ext_ack - netlink extended ACK report struct
68  * @_msg: message string to report - don't access directly, use
69  *      %NL_SET_ERR_MSG
70  * @bad_attr: attribute with error
71  * @cookie: cookie data to return to userspace (for success)
72  * @cookie_len: actual cookie data length
73  */
74 struct netlink_ext_ack {
75         const char *_msg;
76         const struct nlattr *bad_attr;
77         u8 cookie[NETLINK_MAX_COOKIE_LEN];
78         u8 cookie_len;
79 };
80
81 /* Always use this macro, this allows later putting the
82  * message into a separate section or such for things
83  * like translation or listing all possible messages.
84  * Currently string formatting is not supported (due
85  * to the lack of an output buffer.)
86  */
87 #define NL_SET_ERR_MSG(extack, msg) do {                \
88         static const char __msg[] = msg;                \
89         struct netlink_ext_ack *__extack = (extack);    \
90                                                         \
91         if (__extack)                                   \
92                 __extack->_msg = __msg;                 \
93 } while (0)
94
95 #define NL_SET_ERR_MSG_MOD(extack, msg)                 \
96         NL_SET_ERR_MSG((extack), KBUILD_MODNAME ": " msg)
97
98 #define NL_SET_BAD_ATTR(extack, attr) do {              \
99         if ((extack))                                   \
100                 (extack)->bad_attr = (attr);            \
101 } while (0)
102
103 #define NL_SET_ERR_MSG_ATTR(extack, attr, msg) do {     \
104         static const char __msg[] = msg;                \
105         struct netlink_ext_ack *__extack = (extack);    \
106                                                         \
107         if (__extack) {                                 \
108                 __extack->_msg = __msg;                 \
109                 __extack->bad_attr = (attr);            \
110         }                                               \
111 } while (0)
112
113 static inline void nl_set_extack_cookie_u64(struct netlink_ext_ack *extack,
114                                             u64 cookie)
115 {
116         u64 __cookie = cookie;
117
118         memcpy(extack->cookie, &__cookie, sizeof(__cookie));
119         extack->cookie_len = sizeof(__cookie);
120 }
121
122 void netlink_kernel_release(struct sock *sk);
123 int __netlink_change_ngroups(struct sock *sk, unsigned int groups);
124 int netlink_change_ngroups(struct sock *sk, unsigned int groups);
125 void __netlink_clear_multicast_users(struct sock *sk, unsigned int group);
126 void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err,
127                  const struct netlink_ext_ack *extack);
128 int netlink_has_listeners(struct sock *sk, unsigned int group);
129 bool netlink_strict_get_check(struct sk_buff *skb);
130
131 int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 portid, int nonblock);
132 int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 portid,
133                       __u32 group, gfp_t allocation);
134 int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb,
135                                __u32 portid, __u32 group, gfp_t allocation,
136                                int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),
137                                void *filter_data);
138 int netlink_set_err(struct sock *ssk, __u32 portid, __u32 group, int code);
139 int netlink_register_notifier(struct notifier_block *nb);
140 int netlink_unregister_notifier(struct notifier_block *nb);
141
142 /* finegrained unicast helpers: */
143 struct sock *netlink_getsockbyfilp(struct file *filp);
144 int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
145                       long *timeo, struct sock *ssk);
146 void netlink_detachskb(struct sock *sk, struct sk_buff *skb);
147 int netlink_sendskb(struct sock *sk, struct sk_buff *skb);
148
149 static inline struct sk_buff *
150 netlink_skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
151 {
152         struct sk_buff *nskb;
153
154         nskb = skb_clone(skb, gfp_mask);
155         if (!nskb)
156                 return NULL;
157
158         /* This is a large skb, set destructor callback to release head */
159         if (is_vmalloc_addr(skb->head))
160                 nskb->destructor = skb->destructor;
161
162         return nskb;
163 }
164
165 /*
166  *      skb should fit one page. This choice is good for headerless malloc.
167  *      But we should limit to 8K so that userspace does not have to
168  *      use enormous buffer sizes on recvmsg() calls just to avoid
169  *      MSG_TRUNC when PAGE_SIZE is very large.
170  */
171 #if PAGE_SIZE < 8192UL
172 #define NLMSG_GOODSIZE  SKB_WITH_OVERHEAD(PAGE_SIZE)
173 #else
174 #define NLMSG_GOODSIZE  SKB_WITH_OVERHEAD(8192UL)
175 #endif
176
177 #define NLMSG_DEFAULT_SIZE (NLMSG_GOODSIZE - NLMSG_HDRLEN)
178
179
180 struct netlink_callback {
181         struct sk_buff          *skb;
182         const struct nlmsghdr   *nlh;
183         int                     (*dump)(struct sk_buff * skb,
184                                         struct netlink_callback *cb);
185         int                     (*done)(struct netlink_callback *cb);
186         void                    *data;
187         /* the module that dump function belong to */
188         struct module           *module;
189         struct netlink_ext_ack  *extack;
190         u16                     family;
191         u16                     min_dump_alloc;
192         bool                    strict_check;
193         u16                     answer_flags;
194         unsigned int            prev_seq, seq;
195         long                    args[6];
196 };
197
198 struct netlink_notify {
199         struct net *net;
200         u32 portid;
201         int protocol;
202 };
203
204 struct nlmsghdr *
205 __nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int len, int flags);
206
207 struct netlink_dump_control {
208         int (*start)(struct netlink_callback *);
209         int (*dump)(struct sk_buff *skb, struct netlink_callback *);
210         int (*done)(struct netlink_callback *);
211         void *data;
212         struct module *module;
213         u16 min_dump_alloc;
214 };
215
216 int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
217                                 const struct nlmsghdr *nlh,
218                                 struct netlink_dump_control *control);
219 static inline int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
220                                      const struct nlmsghdr *nlh,
221                                      struct netlink_dump_control *control)
222 {
223         if (!control->module)
224                 control->module = THIS_MODULE;
225
226         return __netlink_dump_start(ssk, skb, nlh, control);
227 }
228
229 struct netlink_tap {
230         struct net_device *dev;
231         struct module *module;
232         struct list_head list;
233 };
234
235 int netlink_add_tap(struct netlink_tap *nt);
236 int netlink_remove_tap(struct netlink_tap *nt);
237
238 bool __netlink_ns_capable(const struct netlink_skb_parms *nsp,
239                           struct user_namespace *ns, int cap);
240 bool netlink_ns_capable(const struct sk_buff *skb,
241                         struct user_namespace *ns, int cap);
242 bool netlink_capable(const struct sk_buff *skb, int cap);
243 bool netlink_net_capable(const struct sk_buff *skb, int cap);
244
245 #endif  /* __LINUX_NETLINK_H */