blob: 43e72419c868b38d660fef2a89519bd9898f2a64 [file] [log] [blame]
Thomas Graf482a8522005-11-10 02:25:56 +01001/*
2 * NETLINK Generic Netlink Family
3 *
4 * Authors: Jamal Hadi Salim
5 * Thomas Graf <tgraf@suug.ch>
6 */
7
8#include <linux/config.h>
9#include <linux/module.h>
10#include <linux/kernel.h>
11#include <linux/errno.h>
12#include <linux/types.h>
13#include <linux/socket.h>
14#include <linux/string.h>
15#include <linux/skbuff.h>
16#include <net/sock.h>
17#include <net/genetlink.h>
18
19struct sock *genl_sock = NULL;
20
21static DECLARE_MUTEX(genl_sem); /* serialization of message processing */
22
23static void genl_lock(void)
24{
25 down(&genl_sem);
26}
27
28static int genl_trylock(void)
29{
30 return down_trylock(&genl_sem);
31}
32
33static void genl_unlock(void)
34{
35 up(&genl_sem);
36
37 if (genl_sock && genl_sock->sk_receive_queue.qlen)
38 genl_sock->sk_data_ready(genl_sock, 0);
39}
40
41#define GENL_FAM_TAB_SIZE 16
42#define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1)
43
44static struct list_head family_ht[GENL_FAM_TAB_SIZE];
45
46static int genl_ctrl_event(int event, void *data);
47
48static inline unsigned int genl_family_hash(unsigned int id)
49{
50 return id & GENL_FAM_TAB_MASK;
51}
52
53static inline struct list_head *genl_family_chain(unsigned int id)
54{
55 return &family_ht[genl_family_hash(id)];
56}
57
58static struct genl_family *genl_family_find_byid(unsigned int id)
59{
60 struct genl_family *f;
61
62 list_for_each_entry(f, genl_family_chain(id), family_list)
63 if (f->id == id)
64 return f;
65
66 return NULL;
67}
68
69static struct genl_family *genl_family_find_byname(char *name)
70{
71 struct genl_family *f;
72 int i;
73
74 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
75 list_for_each_entry(f, genl_family_chain(i), family_list)
76 if (strcmp(f->name, name) == 0)
77 return f;
78
79 return NULL;
80}
81
82static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family)
83{
84 struct genl_ops *ops;
85
86 list_for_each_entry(ops, &family->ops_list, ops_list)
87 if (ops->cmd == cmd)
88 return ops;
89
90 return NULL;
91}
92
93/* Of course we are going to have problems once we hit
94 * 2^16 alive types, but that can only happen by year 2K
95*/
96static inline u16 genl_generate_id(void)
97{
98 static u16 id_gen_idx;
99 int overflowed = 0;
100
101 do {
102 if (id_gen_idx == 0)
103 id_gen_idx = GENL_MIN_ID;
104
105 if (++id_gen_idx > GENL_MAX_ID) {
106 if (!overflowed) {
107 overflowed = 1;
108 id_gen_idx = 0;
109 continue;
110 } else
111 return 0;
112 }
113
114 } while (genl_family_find_byid(id_gen_idx));
115
116 return id_gen_idx;
117}
118
119/**
120 * genl_register_ops - register generic netlink operations
121 * @family: generic netlink family
122 * @ops: operations to be registered
123 *
124 * Registers the specified operations and assigns them to the specified
125 * family. Either a doit or dumpit callback must be specified or the
126 * operation will fail. Only one operation structure per command
127 * identifier may be registered.
128 *
129 * See include/net/genetlink.h for more documenation on the operations
130 * structure.
131 *
132 * Returns 0 on success or a negative error code.
133 */
134int genl_register_ops(struct genl_family *family, struct genl_ops *ops)
135{
136 int err = -EINVAL;
137
138 if (ops->dumpit == NULL && ops->doit == NULL)
139 goto errout;
140
141 if (genl_get_cmd(ops->cmd, family)) {
142 err = -EEXIST;
143 goto errout;
144 }
145
146 genl_lock();
147 list_add_tail(&ops->ops_list, &family->ops_list);
148 genl_unlock();
149
150 genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
151 err = 0;
152errout:
153 return err;
154}
155
156/**
157 * genl_unregister_ops - unregister generic netlink operations
158 * @family: generic netlink family
159 * @ops: operations to be unregistered
160 *
161 * Unregisters the specified operations and unassigns them from the
162 * specified family. The operation blocks until the current message
163 * processing has finished and doesn't start again until the
164 * unregister process has finished.
165 *
166 * Note: It is not necessary to unregister all operations before
167 * unregistering the family, unregistering the family will cause
168 * all assigned operations to be unregistered automatically.
169 *
170 * Returns 0 on success or a negative error code.
171 */
172int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops)
173{
174 struct genl_ops *rc;
175
176 genl_lock();
177 list_for_each_entry(rc, &family->ops_list, ops_list) {
178 if (rc == ops) {
179 list_del(&ops->ops_list);
180 genl_unlock();
181 genl_ctrl_event(CTRL_CMD_DELOPS, ops);
182 return 0;
183 }
184 }
185 genl_unlock();
186
187 return -ENOENT;
188}
189
190/**
191 * genl_register_family - register a generic netlink family
192 * @family: generic netlink family
193 *
194 * Registers the specified family after validating it first. Only one
195 * family may be registered with the same family name or identifier.
196 * The family id may equal GENL_ID_GENERATE causing an unique id to
197 * be automatically generated and assigned.
198 *
199 * Return 0 on success or a negative error code.
200 */
201int genl_register_family(struct genl_family *family)
202{
203 int err = -EINVAL;
204
205 if (family->id && family->id < GENL_MIN_ID)
206 goto errout;
207
208 if (family->id > GENL_MAX_ID)
209 goto errout;
210
211 INIT_LIST_HEAD(&family->ops_list);
212
213 genl_lock();
214
215 if (genl_family_find_byname(family->name)) {
216 err = -EEXIST;
217 goto errout_locked;
218 }
219
220 if (genl_family_find_byid(family->id)) {
221 err = -EEXIST;
222 goto errout_locked;
223 }
224
Thomas Graf482a8522005-11-10 02:25:56 +0100225 if (family->id == GENL_ID_GENERATE) {
226 u16 newid = genl_generate_id();
227
228 if (!newid) {
229 err = -ENOMEM;
230 goto errout_locked;
231 }
232
233 family->id = newid;
234 }
235
236 if (family->maxattr) {
237 family->attrbuf = kmalloc((family->maxattr+1) *
238 sizeof(struct nlattr *), GFP_KERNEL);
239 if (family->attrbuf == NULL) {
240 err = -ENOMEM;
Jamal Hadi Salime200bd82006-02-13 15:51:24 -0800241 goto errout_locked;
Thomas Graf482a8522005-11-10 02:25:56 +0100242 }
243 } else
244 family->attrbuf = NULL;
245
246 list_add_tail(&family->family_list, genl_family_chain(family->id));
247 genl_unlock();
248
249 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
250
251 return 0;
252
253errout_locked:
254 genl_unlock();
255errout:
256 return err;
257}
258
259/**
260 * genl_unregister_family - unregister generic netlink family
261 * @family: generic netlink family
262 *
263 * Unregisters the specified family.
264 *
265 * Returns 0 on success or a negative error code.
266 */
267int genl_unregister_family(struct genl_family *family)
268{
269 struct genl_family *rc;
270
271 genl_lock();
272
273 list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
274 if (family->id != rc->id || strcmp(rc->name, family->name))
275 continue;
276
277 list_del(&rc->family_list);
278 INIT_LIST_HEAD(&family->ops_list);
279 genl_unlock();
280
Thomas Graf482a8522005-11-10 02:25:56 +0100281 kfree(family->attrbuf);
282 genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
283 return 0;
284 }
285
286 genl_unlock();
287
288 return -ENOENT;
289}
290
Jamal Hadi Salime200bd82006-02-13 15:51:24 -0800291static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
Thomas Graf482a8522005-11-10 02:25:56 +0100292 int *errp)
293{
294 struct genl_ops *ops;
295 struct genl_family *family;
296 struct genl_info info;
297 struct genlmsghdr *hdr = nlmsg_data(nlh);
298 int hdrlen, err = -EINVAL;
299
300 if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
301 goto ignore;
302
303 if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
304 goto ignore;
305
306 family = genl_family_find_byid(nlh->nlmsg_type);
307 if (family == NULL) {
308 err = -ENOENT;
309 goto errout;
310 }
311
312 hdrlen = GENL_HDRLEN + family->hdrsize;
313 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
314 goto errout;
315
316 ops = genl_get_cmd(hdr->cmd, family);
317 if (ops == NULL) {
318 err = -EOPNOTSUPP;
319 goto errout;
320 }
321
322 if ((ops->flags & GENL_ADMIN_PERM) && security_netlink_recv(skb)) {
323 err = -EPERM;
324 goto errout;
325 }
326
327 if (nlh->nlmsg_flags & NLM_F_DUMP) {
328 if (ops->dumpit == NULL) {
329 err = -EOPNOTSUPP;
330 goto errout;
331 }
332
333 *errp = err = netlink_dump_start(genl_sock, skb, nlh,
334 ops->dumpit, NULL);
335 if (err == 0)
336 skb_pull(skb, min(NLMSG_ALIGN(nlh->nlmsg_len),
337 skb->len));
338 return -1;
339 }
340
341 if (ops->doit == NULL) {
342 err = -EOPNOTSUPP;
343 goto errout;
344 }
345
346 if (family->attrbuf) {
347 err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
348 ops->policy);
349 if (err < 0)
350 goto errout;
351 }
352
353 info.snd_seq = nlh->nlmsg_seq;
354 info.snd_pid = NETLINK_CB(skb).pid;
355 info.nlhdr = nlh;
356 info.genlhdr = nlmsg_data(nlh);
357 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
358 info.attrs = family->attrbuf;
359
360 *errp = err = ops->doit(skb, &info);
361 return err;
362
363ignore:
364 return 0;
365
366errout:
367 *errp = err;
368 return -1;
369}
370
371static void genl_rcv(struct sock *sk, int len)
372{
373 unsigned int qlen = 0;
374
375 do {
376 if (genl_trylock())
377 return;
Jamal Hadi Salime200bd82006-02-13 15:51:24 -0800378 netlink_run_queue(sk, &qlen, genl_rcv_msg);
Thomas Graf482a8522005-11-10 02:25:56 +0100379 genl_unlock();
380 } while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen);
381}
382
383/**************************************************************************
384 * Controller
385 **************************************************************************/
386
387static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
388 u32 flags, struct sk_buff *skb, u8 cmd)
389{
390 void *hdr;
391
392 hdr = genlmsg_put(skb, pid, seq, GENL_ID_CTRL, 0, flags, cmd,
393 family->version);
394 if (hdr == NULL)
395 return -1;
396
397 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
398 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
399
400 return genlmsg_end(skb, hdr);
401
402nla_put_failure:
403 return genlmsg_cancel(skb, hdr);
404}
405
406static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
407{
408
409 int i, n = 0;
410 struct genl_family *rt;
411 int chains_to_skip = cb->args[0];
412 int fams_to_skip = cb->args[1];
413
414 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
415 if (i < chains_to_skip)
416 continue;
417 n = 0;
418 list_for_each_entry(rt, genl_family_chain(i), family_list) {
419 if (++n < fams_to_skip)
420 continue;
421 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
422 cb->nlh->nlmsg_seq, NLM_F_MULTI,
423 skb, CTRL_CMD_NEWFAMILY) < 0)
424 goto errout;
425 }
426
427 fams_to_skip = 0;
428 }
429
430errout:
431 cb->args[0] = i;
432 cb->args[1] = n;
433
434 return skb->len;
435}
436
437static struct sk_buff *ctrl_build_msg(struct genl_family *family, u32 pid,
Per Lidenb461d2f2006-01-03 14:13:29 -0800438 int seq, u8 cmd)
Thomas Graf482a8522005-11-10 02:25:56 +0100439{
440 struct sk_buff *skb;
441 int err;
442
443 skb = nlmsg_new(NLMSG_GOODSIZE);
444 if (skb == NULL)
445 return ERR_PTR(-ENOBUFS);
446
447 err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
448 if (err < 0) {
449 nlmsg_free(skb);
450 return ERR_PTR(err);
451 }
452
453 return skb;
454}
455
456static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] __read_mostly = {
457 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
458 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_STRING },
459};
460
461static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
462{
463 struct sk_buff *msg;
464 struct genl_family *res = NULL;
465 int err = -EINVAL;
466
467 if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
468 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
469 res = genl_family_find_byid(id);
470 }
471
472 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
473 char name[GENL_NAMSIZ];
474
475 if (nla_strlcpy(name, info->attrs[CTRL_ATTR_FAMILY_NAME],
476 GENL_NAMSIZ) >= GENL_NAMSIZ)
477 goto errout;
478
479 res = genl_family_find_byname(name);
480 }
481
482 if (res == NULL) {
483 err = -ENOENT;
484 goto errout;
485 }
486
487 msg = ctrl_build_msg(res, info->snd_pid, info->snd_seq,
488 CTRL_CMD_NEWFAMILY);
489 if (IS_ERR(msg)) {
490 err = PTR_ERR(msg);
491 goto errout;
492 }
493
494 err = genlmsg_unicast(msg, info->snd_pid);
495errout:
496 return err;
497}
498
499static int genl_ctrl_event(int event, void *data)
500{
501 struct sk_buff *msg;
502
503 if (genl_sock == NULL)
504 return 0;
505
506 switch (event) {
507 case CTRL_CMD_NEWFAMILY:
508 case CTRL_CMD_DELFAMILY:
509 msg = ctrl_build_msg(data, 0, 0, event);
510 if (IS_ERR(msg))
511 return PTR_ERR(msg);
512
513 genlmsg_multicast(msg, 0, GENL_ID_CTRL);
514 break;
515 }
516
517 return 0;
518}
519
520static struct genl_ops genl_ctrl_ops = {
521 .cmd = CTRL_CMD_GETFAMILY,
522 .doit = ctrl_getfamily,
523 .dumpit = ctrl_dumpfamily,
524 .policy = ctrl_policy,
525};
526
527static struct genl_family genl_ctrl = {
528 .id = GENL_ID_CTRL,
529 .name = "nlctrl",
530 .version = 0x1,
531 .maxattr = CTRL_ATTR_MAX,
Thomas Graf482a8522005-11-10 02:25:56 +0100532};
533
534static int __init genl_init(void)
535{
536 int i, err;
537
538 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
539 INIT_LIST_HEAD(&family_ht[i]);
540
541 err = genl_register_family(&genl_ctrl);
542 if (err < 0)
543 goto errout;
544
545 err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
546 if (err < 0)
547 goto errout_register;
548
549 netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
550 genl_sock = netlink_kernel_create(NETLINK_GENERIC, GENL_MAX_ID,
551 genl_rcv, THIS_MODULE);
Jamal Hadi Salime200bd82006-02-13 15:51:24 -0800552 if (genl_sock == NULL)
Thomas Graf482a8522005-11-10 02:25:56 +0100553 panic("GENL: Cannot initialize generic netlink\n");
Thomas Graf482a8522005-11-10 02:25:56 +0100554
555 return 0;
556
557errout_register:
558 genl_unregister_family(&genl_ctrl);
559errout:
560 panic("GENL: Cannot register controller: %d\n", err);
Thomas Graf482a8522005-11-10 02:25:56 +0100561}
562
563subsys_initcall(genl_init);
564
565EXPORT_SYMBOL(genl_sock);
566EXPORT_SYMBOL(genl_register_ops);
567EXPORT_SYMBOL(genl_unregister_ops);
568EXPORT_SYMBOL(genl_register_family);
569EXPORT_SYMBOL(genl_unregister_family);