package/libs/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 #ifdef disabled
 140 char *genl_op2name(int family, int op, char *buf, size_t len)
 141 {
 142         struct genl_ops *ops;
 143         int i;
 144
 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];
 150
 151                                 if (cmd->c_id == op) {
 152                                         strncpy(buf, cmd->c_name, len - 1);
 153                                         return buf;
 154                                 }
 155                         }
 156                 }
 157         }
 158
 159         strncpy(buf, "unknown", len - 1);
 160         return NULL;
 161 }
 162 #endif
 163
 164 /**
 165  * @name Register/Unregister
 166  * @{
 167  */
 168
 169 /**
 170  * Register generic netlink operations
 171  * @arg ops             cache operations
 172  */
 173 int genl_register(struct nl_cache_ops *ops)
 174 {
 175         int err;
 176
 177         if (ops->co_protocol != NETLINK_GENERIC) {
 178                 err = -NLE_PROTO_MISMATCH;
 179                 goto errout;
 180         }
 181
 182         if (ops->co_hdrsize < GENL_HDRSIZE(0)) {
 183                 err = -NLE_INVAL;
 184                 goto errout;
 185         }
 186
 187         if (ops->co_genl == NULL) {
 188                 err = -NLE_INVAL;
 189                 goto errout;
 190         }
 191
 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;
 196
 197         /* FIXME: check for dup */
 198
 199         nl_list_add_tail(&ops->co_genl->o_list, &genl_ops_list);
 200
 201         err = nl_cache_mngt_register(ops);
 202 errout:
 203         return err;
 204 }
 205
 206 /**
 207  * Unregister generic netlink operations
 208  * @arg ops             cache operations
 209  */
 210 void genl_unregister(struct nl_cache_ops *ops)
 211 {
 212         nl_cache_mngt_unregister(ops);
 213         nl_list_del(&ops->co_genl->o_list);
 214 }
 215
 216 /** @} */
 217
 218 /**
 219  * @name Resolving ID/Name
 220  * @{
 221  */
 222 #ifdef disabled
 223 static int __genl_ops_resolve(struct nl_cache *ctrl, struct genl_ops *ops)
 224 {
 225         struct genl_family *family;
 226
 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);
 231
 232                 return 0;
 233         }
 234
 235         return -NLE_OBJ_NOTFOUND;
 236 }
 237
 238 int genl_ops_resolve(struct nl_sock *sk, struct genl_ops *ops)
 239 {
 240         struct nl_cache *ctrl;
 241         int err;
 242
 243         if ((err = genl_ctrl_alloc_cache(sk, &ctrl)) < 0)
 244                 goto errout;
 245
 246         err = __genl_ops_resolve(ctrl, ops);
 247
 248         nl_cache_free(ctrl);
 249 errout:
 250         return err;
 251 }
 252
 253 int genl_mngt_resolve(struct nl_sock *sk)
 254 {
 255         struct nl_cache *ctrl;
 256         struct genl_ops *ops;
 257         int err = 0;
 258
 259         if ((err = genl_ctrl_alloc_cache(sk, &ctrl)) < 0)
 260                 goto errout;
 261
 262         nl_list_for_each_entry(ops, &genl_ops_list, o_list) {
 263                 err = __genl_ops_resolve(ctrl, ops);
 264         }
 265
 266         nl_cache_free(ctrl);
 267 errout:
 268         return err;
 269 }
 270 #endif
 271 /** @} */
 272
 273
 274 /** @} */