package/libnl-tiny/src/genl_mngt.c

   1 /*
   2  * lib/genl/mngt.c              Generic Netlink Management
   3  *
   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
   7  *      of the License.
   8  *
   9  * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup genl
  14  * @defgroup genl_mngt Management
  15  *
  16  * @par 1) Registering a generic netlink module
  17  * @code
  18  * #include <netlink/genl/mngt.h>
  19  *
  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
  25  * // userspace.
  26  * static struct genl_cmd foo_cmds[] = {
  27  *      {
  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,
  33  *      },
  34  *      {
  35  *              .c_id           = FOO_CMD_DEL,
  36  *              .c_name         = "DELFOO" ,
  37  *      },
  38  * };
  39  *
  40  * // The list of commands must then be integrated into a
  41  * // struct genl_ops serving as handle for this particular
  42  * // family.
  43  * static struct genl_ops my_genl_ops = {
  44  *      .o_cmds                 = foo_cmds,
  45  *      .o_ncmds                = ARRAY_SIZE(foo_cmds),
  46  * };
  47  *
  48  * // Using the above struct genl_ops an arbitary number of
  49  * // cache handles can be associated to it.
  50  * //
  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.
  54  * //
  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,
  65  * };
  66  *
  67  * // Finally each cache handle for a generic netlink family
  68  * // must be registered using genl_register().
  69  * static void __init foo_init(void)
  70  * {
  71  *      genl_register(&genl_foo_ops);
  72  * }
  73  *
  74  * // ... respectively unregsted again.
  75  * static void __exit foo_exit(void)
  76  * {
  77  *      genl_unregister(&genl_foo_ops);
  78  * }
  79  * @endcode
  80  * @{
  81  */
  82
  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>
  90
  91 static NL_LIST_HEAD(genl_ops_list);
  92
  93 static int genl_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
  94                            struct nlmsghdr *nlh, struct nl_parser_param *pp)
  95 {
  96         int i, err;
  97         struct genlmsghdr *ghdr;
  98         struct genl_cmd *cmd;
  99
 100         ghdr = nlmsg_data(nlh);
 101
 102         if (ops->co_genl == NULL)
 103                 BUG();
 104
 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)
 108                         goto found;
 109         }
 110
 111         err = -NLE_MSGTYPE_NOSUPPORT;
 112         goto errout;
 113
 114 found:
 115         if (cmd->c_msg_parser == NULL)
 116                 err = -NLE_OPNOTSUPP;
 117         else {
 118                 struct nlattr *tb[cmd->c_maxattr + 1];
 119                 struct genl_info info = {
 120                         .who = who,
 121                         .nlh = nlh,
 122                         .genlhdr = ghdr,
 123                         .userhdr = genlmsg_data(ghdr),
 124                         .attrs = tb,
 125                 };
 126
 127                 err = nlmsg_parse(nlh, ops->co_hdrsize, tb, cmd->c_maxattr,
 128                                   cmd->c_attr_policy);
 129                 if (err < 0)
 130                         goto errout;
 131
 132                 err = cmd->c_msg_parser(ops, cmd, &info, pp);
 133         }
 134 errout:
 135         return err;
 136
 137 }
 138
 139 char *genl_op2name(int family, int op, char *buf, size_t len)
 140 {
 141         struct genl_ops *ops;
 142         int i;
 143
 144         nl_list_for_each_entry(ops, &genl_ops_list, o_list) {
 145                 if (ops->o_family == family) {
 146                         for (i = 0; i < ops->o_ncmds; i++) {
 147                                 struct genl_cmd *cmd;
 148                                 cmd = &ops->o_cmds[i];
 149
 150                                 if (cmd->c_id == op) {
 151                                         strncpy(buf, cmd->c_name, len - 1);
 152                                         return buf;
 153                                 }
 154                         }
 155                 }
 156         }
 157
 158         strncpy(buf, "unknown", len - 1);
 159         return NULL;
 160 }
 161
 162
 163 /**
 164  * @name Register/Unregister
 165  * @{
 166  */
 167
 168 /**
 169  * Register generic netlink operations
 170  * @arg ops             cache operations
 171  */
 172 int genl_register(struct nl_cache_ops *ops)
 173 {
 174         int err;
 175
 176         if (ops->co_protocol != NETLINK_GENERIC) {
 177                 err = -NLE_PROTO_MISMATCH;
 178                 goto errout;
 179         }
 180
 181         if (ops->co_hdrsize < GENL_HDRSIZE(0)) {
 182                 err = -NLE_INVAL;
 183                 goto errout;
 184         }
 185
 186         if (ops->co_genl == NULL) {
 187                 err = -NLE_INVAL;
 188                 goto errout;
 189         }
 190
 191         ops->co_genl->o_cache_ops = ops;
 192         ops->co_genl->o_name = ops->co_msgtypes[0].mt_name;
 193         ops->co_genl->o_family = ops->co_msgtypes[0].mt_id;
 194         ops->co_msg_parser = genl_msg_parser;
 195
 196         /* FIXME: check for dup */
 197
 198         nl_list_add_tail(&ops->co_genl->o_list, &genl_ops_list);
 199
 200         err = nl_cache_mngt_register(ops);
 201 errout:
 202         return err;
 203 }
 204
 205 /**
 206  * Unregister generic netlink operations
 207  * @arg ops             cache operations
 208  */
 209 void genl_unregister(struct nl_cache_ops *ops)
 210 {
 211         nl_cache_mngt_unregister(ops);
 212         nl_list_del(&ops->co_genl->o_list);
 213 }
 214
 215 /** @} */
 216
 217 /**
 218  * @name Resolving ID/Name
 219  * @{
 220  */
 221 #ifdef disabled
 222 static int __genl_ops_resolve(struct nl_cache *ctrl, struct genl_ops *ops)
 223 {
 224         struct genl_family *family;
 225
 226         family = genl_ctrl_search_by_name(ctrl, ops->o_name);
 227         if (family != NULL) {
 228                 ops->o_id = genl_family_get_id(family);
 229                 genl_family_put(family);
 230
 231                 return 0;
 232         }
 233
 234         return -NLE_OBJ_NOTFOUND;
 235 }
 236
 237 int genl_ops_resolve(struct nl_sock *sk, struct genl_ops *ops)
 238 {
 239         struct nl_cache *ctrl;
 240         int err;
 241
 242         if ((err = genl_ctrl_alloc_cache(sk, &ctrl)) < 0)
 243                 goto errout;
 244
 245         err = __genl_ops_resolve(ctrl, ops);
 246
 247         nl_cache_free(ctrl);
 248 errout:
 249         return err;
 250 }
 251
 252 int genl_mngt_resolve(struct nl_sock *sk)
 253 {
 254         struct nl_cache *ctrl;
 255         struct genl_ops *ops;
 256         int err = 0;
 257
 258         if ((err = genl_ctrl_alloc_cache(sk, &ctrl)) < 0)
 259                 goto errout;
 260
 261         nl_list_for_each_entry(ops, &genl_ops_list, o_list) {
 262                 err = __genl_ops_resolve(ctrl, ops);
 263         }
 264
 265         nl_cache_free(ctrl);
 266 errout:
 267         return err;
 268 }
 269 #endif
 270 /** @} */
 271
 272
 273 /** @} */