039516f6cd80443c7a8cf2dc3a78fe9e43e42ef6
2 * NETLINK Generic Netlink Family
4 * Authors: Jamal Hadi Salim
5 * Thomas Graf <tgraf@suug.ch>
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/errno.h>
11 #include <linux/types.h>
12 #include <linux/socket.h>
13 #include <linux/string.h>
14 #include <linux/skbuff.h>
15 #include <linux/mutex.h>
17 #include <net/genetlink.h>
19 struct sock
*genl_sock
= NULL
;
21 static DEFINE_MUTEX(genl_mutex
); /* serialization of message processing */
23 static void genl_lock(void)
25 mutex_lock(&genl_mutex
);
28 static int genl_trylock(void)
30 return !mutex_trylock(&genl_mutex
);
33 static void genl_unlock(void)
35 mutex_unlock(&genl_mutex
);
37 if (genl_sock
&& genl_sock
->sk_receive_queue
.qlen
)
38 genl_sock
->sk_data_ready(genl_sock
, 0);
41 #define GENL_FAM_TAB_SIZE 16
42 #define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1)
44 static struct list_head family_ht
[GENL_FAM_TAB_SIZE
];
46 static int genl_ctrl_event(int event
, void *data
);
48 static inline unsigned int genl_family_hash(unsigned int id
)
50 return id
& GENL_FAM_TAB_MASK
;
53 static inline struct list_head
*genl_family_chain(unsigned int id
)
55 return &family_ht
[genl_family_hash(id
)];
58 static struct genl_family
*genl_family_find_byid(unsigned int id
)
60 struct genl_family
*f
;
62 list_for_each_entry(f
, genl_family_chain(id
), family_list
)
69 static struct genl_family
*genl_family_find_byname(char *name
)
71 struct genl_family
*f
;
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)
82 static struct genl_ops
*genl_get_cmd(u8 cmd
, struct genl_family
*family
)
86 list_for_each_entry(ops
, &family
->ops_list
, ops_list
)
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
96 static inline u16
genl_generate_id(void)
98 static u16 id_gen_idx
;
103 id_gen_idx
= GENL_MIN_ID
;
105 if (++id_gen_idx
> GENL_MAX_ID
) {
114 } while (genl_family_find_byid(id_gen_idx
));
120 * genl_register_ops - register generic netlink operations
121 * @family: generic netlink family
122 * @ops: operations to be registered
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.
129 * See include/net/genetlink.h for more documenation on the operations
132 * Returns 0 on success or a negative error code.
134 int genl_register_ops(struct genl_family
*family
, struct genl_ops
*ops
)
138 if (ops
->dumpit
== NULL
&& ops
->doit
== NULL
)
141 if (genl_get_cmd(ops
->cmd
, family
)) {
147 ops
->flags
|= GENL_CMD_CAP_DUMP
;
149 ops
->flags
|= GENL_CMD_CAP_DO
;
151 ops
->flags
|= GENL_CMD_CAP_HASPOL
;
154 list_add_tail(&ops
->ops_list
, &family
->ops_list
);
157 genl_ctrl_event(CTRL_CMD_NEWOPS
, ops
);
164 * genl_unregister_ops - unregister generic netlink operations
165 * @family: generic netlink family
166 * @ops: operations to be unregistered
168 * Unregisters the specified operations and unassigns them from the
169 * specified family. The operation blocks until the current message
170 * processing has finished and doesn't start again until the
171 * unregister process has finished.
173 * Note: It is not necessary to unregister all operations before
174 * unregistering the family, unregistering the family will cause
175 * all assigned operations to be unregistered automatically.
177 * Returns 0 on success or a negative error code.
179 int genl_unregister_ops(struct genl_family
*family
, struct genl_ops
*ops
)
184 list_for_each_entry(rc
, &family
->ops_list
, ops_list
) {
186 list_del(&ops
->ops_list
);
188 genl_ctrl_event(CTRL_CMD_DELOPS
, ops
);
198 * genl_register_family - register a generic netlink family
199 * @family: generic netlink family
201 * Registers the specified family after validating it first. Only one
202 * family may be registered with the same family name or identifier.
203 * The family id may equal GENL_ID_GENERATE causing an unique id to
204 * be automatically generated and assigned.
206 * Return 0 on success or a negative error code.
208 int genl_register_family(struct genl_family
*family
)
212 if (family
->id
&& family
->id
< GENL_MIN_ID
)
215 if (family
->id
> GENL_MAX_ID
)
218 INIT_LIST_HEAD(&family
->ops_list
);
222 if (genl_family_find_byname(family
->name
)) {
227 if (genl_family_find_byid(family
->id
)) {
232 if (family
->id
== GENL_ID_GENERATE
) {
233 u16 newid
= genl_generate_id();
243 if (family
->maxattr
) {
244 family
->attrbuf
= kmalloc((family
->maxattr
+1) *
245 sizeof(struct nlattr
*), GFP_KERNEL
);
246 if (family
->attrbuf
== NULL
) {
251 family
->attrbuf
= NULL
;
253 list_add_tail(&family
->family_list
, genl_family_chain(family
->id
));
256 genl_ctrl_event(CTRL_CMD_NEWFAMILY
, family
);
267 * genl_unregister_family - unregister generic netlink family
268 * @family: generic netlink family
270 * Unregisters the specified family.
272 * Returns 0 on success or a negative error code.
274 int genl_unregister_family(struct genl_family
*family
)
276 struct genl_family
*rc
;
280 list_for_each_entry(rc
, genl_family_chain(family
->id
), family_list
) {
281 if (family
->id
!= rc
->id
|| strcmp(rc
->name
, family
->name
))
284 list_del(&rc
->family_list
);
285 INIT_LIST_HEAD(&family
->ops_list
);
288 kfree(family
->attrbuf
);
289 genl_ctrl_event(CTRL_CMD_DELFAMILY
, family
);
298 static int genl_rcv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
301 struct genl_ops
*ops
;
302 struct genl_family
*family
;
303 struct genl_info info
;
304 struct genlmsghdr
*hdr
= nlmsg_data(nlh
);
305 int hdrlen
, err
= -EINVAL
;
307 if (nlh
->nlmsg_type
< NLMSG_MIN_TYPE
)
310 family
= genl_family_find_byid(nlh
->nlmsg_type
);
311 if (family
== NULL
) {
316 hdrlen
= GENL_HDRLEN
+ family
->hdrsize
;
317 if (nlh
->nlmsg_len
< nlmsg_msg_size(hdrlen
))
320 ops
= genl_get_cmd(hdr
->cmd
, family
);
326 if ((ops
->flags
& GENL_ADMIN_PERM
) && security_netlink_recv(skb
, CAP_NET_ADMIN
)) {
331 if (nlh
->nlmsg_flags
& NLM_F_DUMP
) {
332 if (ops
->dumpit
== NULL
) {
337 *errp
= err
= netlink_dump_start(genl_sock
, skb
, nlh
,
338 ops
->dumpit
, ops
->done
);
340 skb_pull(skb
, min(NLMSG_ALIGN(nlh
->nlmsg_len
),
345 if (ops
->doit
== NULL
) {
350 if (family
->attrbuf
) {
351 err
= nlmsg_parse(nlh
, hdrlen
, family
->attrbuf
, family
->maxattr
,
357 info
.snd_seq
= nlh
->nlmsg_seq
;
358 info
.snd_pid
= NETLINK_CB(skb
).pid
;
360 info
.genlhdr
= nlmsg_data(nlh
);
361 info
.userhdr
= nlmsg_data(nlh
) + GENL_HDRLEN
;
362 info
.attrs
= family
->attrbuf
;
364 *errp
= err
= ops
->doit(skb
, &info
);
375 static void genl_rcv(struct sock
*sk
, int len
)
377 unsigned int qlen
= 0;
382 netlink_run_queue(sk
, &qlen
, genl_rcv_msg
);
384 } while (qlen
&& genl_sock
&& genl_sock
->sk_receive_queue
.qlen
);
387 /**************************************************************************
389 **************************************************************************/
391 static struct genl_family genl_ctrl
= {
395 .maxattr
= CTRL_ATTR_MAX
,
398 static int ctrl_fill_info(struct genl_family
*family
, u32 pid
, u32 seq
,
399 u32 flags
, struct sk_buff
*skb
, u8 cmd
)
403 hdr
= genlmsg_put(skb
, pid
, seq
, &genl_ctrl
, flags
, cmd
);
407 NLA_PUT_STRING(skb
, CTRL_ATTR_FAMILY_NAME
, family
->name
);
408 NLA_PUT_U16(skb
, CTRL_ATTR_FAMILY_ID
, family
->id
);
409 NLA_PUT_U32(skb
, CTRL_ATTR_VERSION
, family
->version
);
410 NLA_PUT_U32(skb
, CTRL_ATTR_HDRSIZE
, family
->hdrsize
);
411 NLA_PUT_U32(skb
, CTRL_ATTR_MAXATTR
, family
->maxattr
);
413 if (!list_empty(&family
->ops_list
)) {
414 struct nlattr
*nla_ops
;
415 struct genl_ops
*ops
;
418 nla_ops
= nla_nest_start(skb
, CTRL_ATTR_OPS
);
420 goto nla_put_failure
;
422 list_for_each_entry(ops
, &family
->ops_list
, ops_list
) {
425 nest
= nla_nest_start(skb
, idx
++);
427 goto nla_put_failure
;
429 NLA_PUT_U32(skb
, CTRL_ATTR_OP_ID
, ops
->cmd
);
430 NLA_PUT_U32(skb
, CTRL_ATTR_OP_FLAGS
, ops
->flags
);
432 nla_nest_end(skb
, nest
);
435 nla_nest_end(skb
, nla_ops
);
438 return genlmsg_end(skb
, hdr
);
441 return genlmsg_cancel(skb
, hdr
);
444 static int ctrl_dumpfamily(struct sk_buff
*skb
, struct netlink_callback
*cb
)
448 struct genl_family
*rt
;
449 int chains_to_skip
= cb
->args
[0];
450 int fams_to_skip
= cb
->args
[1];
452 if (chains_to_skip
!= 0)
455 for (i
= 0; i
< GENL_FAM_TAB_SIZE
; i
++) {
456 if (i
< chains_to_skip
)
459 list_for_each_entry(rt
, genl_family_chain(i
), family_list
) {
460 if (++n
< fams_to_skip
)
462 if (ctrl_fill_info(rt
, NETLINK_CB(cb
->skb
).pid
,
463 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
464 skb
, CTRL_CMD_NEWFAMILY
) < 0)
472 if (chains_to_skip
!= 0)
481 static struct sk_buff
*ctrl_build_msg(struct genl_family
*family
, u32 pid
,
487 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
489 return ERR_PTR(-ENOBUFS
);
491 err
= ctrl_fill_info(family
, pid
, seq
, 0, skb
, cmd
);
500 static struct nla_policy ctrl_policy
[CTRL_ATTR_MAX
+1] __read_mostly
= {
501 [CTRL_ATTR_FAMILY_ID
] = { .type
= NLA_U16
},
502 [CTRL_ATTR_FAMILY_NAME
] = { .type
= NLA_NUL_STRING
,
503 .len
= GENL_NAMSIZ
- 1 },
506 static int ctrl_getfamily(struct sk_buff
*skb
, struct genl_info
*info
)
509 struct genl_family
*res
= NULL
;
512 if (info
->attrs
[CTRL_ATTR_FAMILY_ID
]) {
513 u16 id
= nla_get_u16(info
->attrs
[CTRL_ATTR_FAMILY_ID
]);
514 res
= genl_family_find_byid(id
);
517 if (info
->attrs
[CTRL_ATTR_FAMILY_NAME
]) {
520 name
= nla_data(info
->attrs
[CTRL_ATTR_FAMILY_NAME
]);
521 res
= genl_family_find_byname(name
);
529 msg
= ctrl_build_msg(res
, info
->snd_pid
, info
->snd_seq
,
536 err
= genlmsg_reply(msg
, info
);
541 static int genl_ctrl_event(int event
, void *data
)
545 if (genl_sock
== NULL
)
549 case CTRL_CMD_NEWFAMILY
:
550 case CTRL_CMD_DELFAMILY
:
551 msg
= ctrl_build_msg(data
, 0, 0, event
);
555 genlmsg_multicast(msg
, 0, GENL_ID_CTRL
, GFP_KERNEL
);
562 static struct genl_ops genl_ctrl_ops
= {
563 .cmd
= CTRL_CMD_GETFAMILY
,
564 .doit
= ctrl_getfamily
,
565 .dumpit
= ctrl_dumpfamily
,
566 .policy
= ctrl_policy
,
569 static int __init
genl_init(void)
573 for (i
= 0; i
< GENL_FAM_TAB_SIZE
; i
++)
574 INIT_LIST_HEAD(&family_ht
[i
]);
576 err
= genl_register_family(&genl_ctrl
);
580 err
= genl_register_ops(&genl_ctrl
, &genl_ctrl_ops
);
582 goto errout_register
;
584 netlink_set_nonroot(NETLINK_GENERIC
, NL_NONROOT_RECV
);
585 genl_sock
= netlink_kernel_create(NETLINK_GENERIC
, GENL_MAX_ID
,
586 genl_rcv
, THIS_MODULE
);
587 if (genl_sock
== NULL
)
588 panic("GENL: Cannot initialize generic netlink\n");
593 genl_unregister_family(&genl_ctrl
);
595 panic("GENL: Cannot register controller: %d\n", err
);
598 subsys_initcall(genl_init
);
600 EXPORT_SYMBOL(genl_sock
);
601 EXPORT_SYMBOL(genl_register_ops
);
602 EXPORT_SYMBOL(genl_unregister_ops
);
603 EXPORT_SYMBOL(genl_register_family
);
604 EXPORT_SYMBOL(genl_unregister_family
);
This page took 0.061478 seconds and 4 git commands to generate.