xref: /openbmc/linux/net/netlink/genetlink.c (revision 87c2ce3b)
1 /*
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 
19 struct sock *genl_sock = NULL;
20 
21 static DECLARE_MUTEX(genl_sem); /* serialization of message processing */
22 
23 static void genl_lock(void)
24 {
25 	down(&genl_sem);
26 }
27 
28 static int genl_trylock(void)
29 {
30 	return down_trylock(&genl_sem);
31 }
32 
33 static 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 
44 static struct list_head family_ht[GENL_FAM_TAB_SIZE];
45 
46 static int genl_ctrl_event(int event, void *data);
47 
48 static inline unsigned int genl_family_hash(unsigned int id)
49 {
50 	return id & GENL_FAM_TAB_MASK;
51 }
52 
53 static inline struct list_head *genl_family_chain(unsigned int id)
54 {
55 	return &family_ht[genl_family_hash(id)];
56 }
57 
58 static 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 
69 static 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 
82 static 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 */
96 static 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  */
134 int 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;
152 errout:
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  */
172 int 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  */
201 int 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 
225 	if (!try_module_get(family->owner)) {
226 		err = -EBUSY;
227 		goto errout_locked;
228 	}
229 
230 	if (family->id == GENL_ID_GENERATE) {
231 		u16 newid = genl_generate_id();
232 
233 		if (!newid) {
234 			err = -ENOMEM;
235 			goto errout_locked;
236 		}
237 
238 		family->id = newid;
239 	}
240 
241 	if (family->maxattr) {
242 		family->attrbuf = kmalloc((family->maxattr+1) *
243 					sizeof(struct nlattr *), GFP_KERNEL);
244 		if (family->attrbuf == NULL) {
245 			err = -ENOMEM;
246 			goto errout;
247 		}
248 	} else
249 		family->attrbuf = NULL;
250 
251 	list_add_tail(&family->family_list, genl_family_chain(family->id));
252 	genl_unlock();
253 
254 	genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
255 
256 	return 0;
257 
258 errout_locked:
259 	genl_unlock();
260 errout:
261 	return err;
262 }
263 
264 /**
265  * genl_unregister_family - unregister generic netlink family
266  * @family: generic netlink family
267  *
268  * Unregisters the specified family.
269  *
270  * Returns 0 on success or a negative error code.
271  */
272 int genl_unregister_family(struct genl_family *family)
273 {
274 	struct genl_family *rc;
275 
276 	genl_lock();
277 
278 	list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
279 		if (family->id != rc->id || strcmp(rc->name, family->name))
280 			continue;
281 
282 		list_del(&rc->family_list);
283 		INIT_LIST_HEAD(&family->ops_list);
284 		genl_unlock();
285 
286 		module_put(family->owner);
287 		kfree(family->attrbuf);
288 		genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
289 		return 0;
290 	}
291 
292 	genl_unlock();
293 
294 	return -ENOENT;
295 }
296 
297 static inline int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
298 			       int *errp)
299 {
300 	struct genl_ops *ops;
301 	struct genl_family *family;
302 	struct genl_info info;
303 	struct genlmsghdr *hdr = nlmsg_data(nlh);
304 	int hdrlen, err = -EINVAL;
305 
306 	if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
307 		goto ignore;
308 
309 	if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
310 		goto ignore;
311 
312        	family = genl_family_find_byid(nlh->nlmsg_type);
313 	if (family == NULL) {
314 		err = -ENOENT;
315 		goto errout;
316 	}
317 
318 	hdrlen = GENL_HDRLEN + family->hdrsize;
319 	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
320 		goto errout;
321 
322 	ops = genl_get_cmd(hdr->cmd, family);
323 	if (ops == NULL) {
324 		err = -EOPNOTSUPP;
325 		goto errout;
326 	}
327 
328 	if ((ops->flags & GENL_ADMIN_PERM) && security_netlink_recv(skb)) {
329 		err = -EPERM;
330 		goto errout;
331 	}
332 
333 	if (nlh->nlmsg_flags & NLM_F_DUMP) {
334 		if (ops->dumpit == NULL) {
335 			err = -EOPNOTSUPP;
336 			goto errout;
337 		}
338 
339 		*errp = err = netlink_dump_start(genl_sock, skb, nlh,
340 						 ops->dumpit, NULL);
341 		if (err == 0)
342 			skb_pull(skb, min(NLMSG_ALIGN(nlh->nlmsg_len),
343 					  skb->len));
344 		return -1;
345 	}
346 
347 	if (ops->doit == NULL) {
348 		err = -EOPNOTSUPP;
349 		goto errout;
350 	}
351 
352 	if (family->attrbuf) {
353 		err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
354 				  ops->policy);
355 		if (err < 0)
356 			goto errout;
357 	}
358 
359 	info.snd_seq = nlh->nlmsg_seq;
360 	info.snd_pid = NETLINK_CB(skb).pid;
361 	info.nlhdr = nlh;
362 	info.genlhdr = nlmsg_data(nlh);
363 	info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
364 	info.attrs = family->attrbuf;
365 
366 	*errp = err = ops->doit(skb, &info);
367 	return err;
368 
369 ignore:
370 	return 0;
371 
372 errout:
373 	*errp = err;
374 	return -1;
375 }
376 
377 static void genl_rcv(struct sock *sk, int len)
378 {
379 	unsigned int qlen = 0;
380 
381 	do {
382 		if (genl_trylock())
383 			return;
384 		netlink_run_queue(sk, &qlen, &genl_rcv_msg);
385 		genl_unlock();
386 	} while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen);
387 }
388 
389 /**************************************************************************
390  * Controller
391  **************************************************************************/
392 
393 static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
394 			  u32 flags, struct sk_buff *skb, u8 cmd)
395 {
396 	void *hdr;
397 
398 	hdr = genlmsg_put(skb, pid, seq, GENL_ID_CTRL, 0, flags, cmd,
399 			  family->version);
400 	if (hdr == NULL)
401 		return -1;
402 
403 	NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
404 	NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
405 
406 	return genlmsg_end(skb, hdr);
407 
408 nla_put_failure:
409 	return genlmsg_cancel(skb, hdr);
410 }
411 
412 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
413 {
414 
415 	int i, n = 0;
416 	struct genl_family *rt;
417 	int chains_to_skip = cb->args[0];
418 	int fams_to_skip = cb->args[1];
419 
420 	for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
421 		if (i < chains_to_skip)
422 			continue;
423 		n = 0;
424 		list_for_each_entry(rt, genl_family_chain(i), family_list) {
425 			if (++n < fams_to_skip)
426 				continue;
427 			if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
428 					   cb->nlh->nlmsg_seq, NLM_F_MULTI,
429 					   skb, CTRL_CMD_NEWFAMILY) < 0)
430 				goto errout;
431 		}
432 
433 		fams_to_skip = 0;
434 	}
435 
436 errout:
437 	cb->args[0] = i;
438 	cb->args[1] = n;
439 
440 	return skb->len;
441 }
442 
443 static struct sk_buff *ctrl_build_msg(struct genl_family *family, u32 pid,
444 				      int seq, u8 cmd)
445 {
446 	struct sk_buff *skb;
447 	int err;
448 
449 	skb = nlmsg_new(NLMSG_GOODSIZE);
450 	if (skb == NULL)
451 		return ERR_PTR(-ENOBUFS);
452 
453 	err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
454 	if (err < 0) {
455 		nlmsg_free(skb);
456 		return ERR_PTR(err);
457 	}
458 
459 	return skb;
460 }
461 
462 static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] __read_mostly = {
463 	[CTRL_ATTR_FAMILY_ID]	= { .type = NLA_U16 },
464 	[CTRL_ATTR_FAMILY_NAME]	= { .type = NLA_STRING },
465 };
466 
467 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
468 {
469 	struct sk_buff *msg;
470 	struct genl_family *res = NULL;
471 	int err = -EINVAL;
472 
473 	if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
474 		u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
475 		res = genl_family_find_byid(id);
476 	}
477 
478 	if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
479 		char name[GENL_NAMSIZ];
480 
481 		if (nla_strlcpy(name, info->attrs[CTRL_ATTR_FAMILY_NAME],
482 				GENL_NAMSIZ) >= GENL_NAMSIZ)
483 			goto errout;
484 
485 		res = genl_family_find_byname(name);
486 	}
487 
488 	if (res == NULL) {
489 		err = -ENOENT;
490 		goto errout;
491 	}
492 
493 	msg = ctrl_build_msg(res, info->snd_pid, info->snd_seq,
494 			     CTRL_CMD_NEWFAMILY);
495 	if (IS_ERR(msg)) {
496 		err = PTR_ERR(msg);
497 		goto errout;
498 	}
499 
500 	err = genlmsg_unicast(msg, info->snd_pid);
501 errout:
502 	return err;
503 }
504 
505 static int genl_ctrl_event(int event, void *data)
506 {
507 	struct sk_buff *msg;
508 
509 	if (genl_sock == NULL)
510 		return 0;
511 
512 	switch (event) {
513 	case CTRL_CMD_NEWFAMILY:
514 	case CTRL_CMD_DELFAMILY:
515 		msg = ctrl_build_msg(data, 0, 0, event);
516 		if (IS_ERR(msg))
517 			return PTR_ERR(msg);
518 
519 		genlmsg_multicast(msg, 0, GENL_ID_CTRL);
520 		break;
521 	}
522 
523 	return 0;
524 }
525 
526 static struct genl_ops genl_ctrl_ops = {
527 	.cmd		= CTRL_CMD_GETFAMILY,
528 	.doit		= ctrl_getfamily,
529 	.dumpit		= ctrl_dumpfamily,
530 	.policy		= ctrl_policy,
531 };
532 
533 static struct genl_family genl_ctrl = {
534 	.id = GENL_ID_CTRL,
535 	.name = "nlctrl",
536 	.version = 0x1,
537 	.maxattr = CTRL_ATTR_MAX,
538 	.owner = THIS_MODULE,
539 };
540 
541 static int __init genl_init(void)
542 {
543 	int i, err;
544 
545 	for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
546 		INIT_LIST_HEAD(&family_ht[i]);
547 
548 	err = genl_register_family(&genl_ctrl);
549 	if (err < 0)
550 		goto errout;
551 
552 	err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
553 	if (err < 0)
554 		goto errout_register;
555 
556 	netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
557 	genl_sock = netlink_kernel_create(NETLINK_GENERIC, GENL_MAX_ID,
558 					  genl_rcv, THIS_MODULE);
559 	if (genl_sock == NULL) {
560 		panic("GENL: Cannot initialize generic netlink\n");
561 		return -ENOMEM;
562 	}
563 
564 	return 0;
565 
566 errout_register:
567 	genl_unregister_family(&genl_ctrl);
568 errout:
569 	panic("GENL: Cannot register controller: %d\n", err);
570 	return err;
571 }
572 
573 subsys_initcall(genl_init);
574 
575 EXPORT_SYMBOL(genl_sock);
576 EXPORT_SYMBOL(genl_register_ops);
577 EXPORT_SYMBOL(genl_unregister_ops);
578 EXPORT_SYMBOL(genl_register_family);
579 EXPORT_SYMBOL(genl_unregister_family);
580