2 * lib/genl/mngt.c Generic Netlink Management
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation version 2.1
9 * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
14 * @defgroup genl_mngt Management
16 * @par 1) Registering a generic netlink module
18 * #include <netlink/genl/mngt.h>
20 * // First step is to define all the commands being used in
21 * // particular generic netlink family. The ID and name are
22 * // mandatory to be filled out. A callback function and
23 * // most the attribute policy that comes with it must be
24 * // defined for commands expected to be issued towards
26 * static struct genl_cmd foo_cmds[] = {
28 * .c_id = FOO_CMD_NEW,
29 * .c_name = "NEWFOO" ,
30 * .c_maxattr = FOO_ATTR_MAX,
31 * .c_attr_policy = foo_policy,
32 * .c_msg_parser = foo_msg_parser,
35 * .c_id = FOO_CMD_DEL,
36 * .c_name = "DELFOO" ,
40 * // The list of commands must then be integrated into a
41 * // struct genl_ops serving as handle for this particular
43 * static struct genl_ops my_genl_ops = {
45 * .o_ncmds = ARRAY_SIZE(foo_cmds),
48 * // Using the above struct genl_ops an arbitary number of
49 * // cache handles can be associated to it.
51 * // The macro GENL_HDRSIZE() must be used to specify the
52 * // length of the header to automatically take headers on
53 * // generic layers into account.
55 * // The macro GENL_FAMILY() is used to represent the generic
56 * // netlink family id.
57 * static struct nl_cache_ops genl_foo_ops = {
58 * .co_name = "genl/foo",
59 * .co_hdrsize = GENL_HDRSIZE(sizeof(struct my_hdr)),
60 * .co_msgtypes = GENL_FAMILY(GENL_ID_GENERATE, "foo"),
61 * .co_genl = &my_genl_ops,
62 * .co_protocol = NETLINK_GENERIC,
63 * .co_request_update = foo_request_update,
64 * .co_obj_ops = &genl_foo_ops,
67 * // Finally each cache handle for a generic netlink family
68 * // must be registered using genl_register().
69 * static void __init foo_init(void)
71 * genl_register(&genl_foo_ops);
74 * // ... respectively unregsted again.
75 * static void __exit foo_exit(void)
77 * genl_unregister(&genl_foo_ops);
83 #include <netlink-generic.h>
84 #include <netlink/netlink.h>
85 #include <netlink/genl/genl.h>
86 #include <netlink/genl/mngt.h>
87 #include <netlink/genl/family.h>
88 #include <netlink/genl/ctrl.h>
89 #include <netlink/utils.h>
91 static NL_LIST_HEAD(genl_ops_list
);
93 static int genl_msg_parser(struct nl_cache_ops
*ops
, struct sockaddr_nl
*who
,
94 struct nlmsghdr
*nlh
, struct nl_parser_param
*pp
)
97 struct genlmsghdr
*ghdr
;
100 ghdr
= nlmsg_data(nlh
);
102 if (ops
->co_genl
== NULL
)
105 for (i
= 0; i
< ops
->co_genl
->o_ncmds
; i
++) {
106 cmd
= &ops
->co_genl
->o_cmds
[i
];
107 if (cmd
->c_id
== ghdr
->cmd
)
111 err
= -NLE_MSGTYPE_NOSUPPORT
;
115 if (cmd
->c_msg_parser
== NULL
)
116 err
= -NLE_OPNOTSUPP
;
118 struct nlattr
*tb
[cmd
->c_maxattr
+ 1];
119 struct genl_info info
= {
123 .userhdr
= genlmsg_data(ghdr
),
127 err
= nlmsg_parse(nlh
, ops
->co_hdrsize
, tb
, cmd
->c_maxattr
,
132 err
= cmd
->c_msg_parser(ops
, cmd
, &info
, pp
);
140 char *genl_op2name(int family
, int op
, char *buf
, size_t len
)
142 struct genl_ops
*ops
;
145 nl_list_for_each_entry(ops
, &genl_ops_list
, o_list
) {
146 if (ops
->o_family
== family
) {
147 for (i
= 0; i
< ops
->o_ncmds
; i
++) {
148 struct genl_cmd
*cmd
;
149 cmd
= &ops
->o_cmds
[i
];
151 if (cmd
->c_id
== op
) {
152 strncpy(buf
, cmd
->c_name
, len
- 1);
159 strncpy(buf
, "unknown", len
- 1);
165 * @name Register/Unregister
170 * Register generic netlink operations
171 * @arg ops cache operations
173 int genl_register(struct nl_cache_ops
*ops
)
177 if (ops
->co_protocol
!= NETLINK_GENERIC
) {
178 err
= -NLE_PROTO_MISMATCH
;
182 if (ops
->co_hdrsize
< GENL_HDRSIZE(0)) {
187 if (ops
->co_genl
== NULL
) {
192 ops
->co_genl
->o_cache_ops
= ops
;
193 ops
->co_genl
->o_name
= ops
->co_msgtypes
[0].mt_name
;
194 ops
->co_genl
->o_family
= ops
->co_msgtypes
[0].mt_id
;
195 ops
->co_msg_parser
= genl_msg_parser
;
197 /* FIXME: check for dup */
199 nl_list_add_tail(&ops
->co_genl
->o_list
, &genl_ops_list
);
201 err
= nl_cache_mngt_register(ops
);
207 * Unregister generic netlink operations
208 * @arg ops cache operations
210 void genl_unregister(struct nl_cache_ops
*ops
)
212 nl_cache_mngt_unregister(ops
);
213 nl_list_del(&ops
->co_genl
->o_list
);
219 * @name Resolving ID/Name
223 static int __genl_ops_resolve(struct nl_cache
*ctrl
, struct genl_ops
*ops
)
225 struct genl_family
*family
;
227 family
= genl_ctrl_search_by_name(ctrl
, ops
->o_name
);
228 if (family
!= NULL
) {
229 ops
->o_id
= genl_family_get_id(family
);
230 genl_family_put(family
);
235 return -NLE_OBJ_NOTFOUND
;
238 int genl_ops_resolve(struct nl_sock
*sk
, struct genl_ops
*ops
)
240 struct nl_cache
*ctrl
;
243 if ((err
= genl_ctrl_alloc_cache(sk
, &ctrl
)) < 0)
246 err
= __genl_ops_resolve(ctrl
, ops
);
253 int genl_mngt_resolve(struct nl_sock
*sk
)
255 struct nl_cache
*ctrl
;
256 struct genl_ops
*ops
;
259 if ((err
= genl_ctrl_alloc_cache(sk
, &ctrl
)) < 0)
262 nl_list_for_each_entry(ops
, &genl_ops_list
, o_list
) {
263 err
= __genl_ops_resolve(ctrl
, ops
);
This page took 0.054825 seconds and 5 git commands to generate.