lib/genl/ctrl.c

   1 /*
   2  * lib/genl/ctrl.c              Generic Netlink Controller
   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-2006 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup genl_mngt
  14  * @defgroup ctrl Controller
  15  * @brief
  16  *
  17  * @{
  18  */
  19
  20 #include <netlink-generic.h>
  21 #include <netlink/netlink.h>
  22 #include <netlink/genl/genl.h>
  23 #include <netlink/genl/family.h>
  24 #include <netlink/genl/mngt.h>
  25 #include <netlink/genl/ctrl.h>
  26 #include <netlink/utils.h>
  27
  28 /** @cond SKIP */
  29 #define CTRL_VERSION            0x0001
  30
  31 static struct nl_cache_ops genl_ctrl_ops;
  32 /** @endcond */
  33
  34 static int ctrl_request_update(struct nl_cache *c, struct nl_handle *h)
  35 {
  36         return genl_send_simple(h, GENL_ID_CTRL, CTRL_CMD_GETFAMILY,
  37                                 CTRL_VERSION, NLM_F_DUMP);
  38 }
  39
  40 static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
  41         [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
  42         [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_STRING,
  43                                     .maxlen = GENL_NAMSIZ },
  44         [CTRL_ATTR_VERSION]     = { .type = NLA_U32 },
  45         [CTRL_ATTR_HDRSIZE]     = { .type = NLA_U32 },
  46         [CTRL_ATTR_MAXATTR]     = { .type = NLA_U32 },
  47         [CTRL_ATTR_OPS]         = { .type = NLA_NESTED },
  48 };
  49
  50 static struct nla_policy family_op_policy[CTRL_ATTR_OP_MAX+1] = {
  51         [CTRL_ATTR_OP_ID]       = { .type = NLA_U32 },
  52         [CTRL_ATTR_OP_FLAGS]    = { .type = NLA_U32 },
  53 };
  54
  55 static int ctrl_msg_parser(struct nl_cache_ops *ops, struct genl_cmd *cmd,
  56                            struct genl_info *info, void *arg)
  57 {
  58         struct genl_family *family;
  59         struct nl_parser_param *pp = arg;
  60         int err;
  61
  62         family = genl_family_alloc();
  63         if (family == NULL) {
  64                 err = nl_errno(ENOMEM);
  65                 goto errout;
  66         }
  67
  68         if (info->attrs[CTRL_ATTR_FAMILY_NAME] == NULL) {
  69                 err = nl_error(EINVAL, "Missing family name TLV");
  70                 goto errout;
  71         }
  72
  73         if (info->attrs[CTRL_ATTR_FAMILY_ID] == NULL) {
  74                 err = nl_error(EINVAL, "Missing family id TLV");
  75                 goto errout;
  76         }
  77
  78         family->ce_msgtype = info->nlh->nlmsg_type;
  79         genl_family_set_id(family,
  80                            nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]));
  81         genl_family_set_name(family,
  82                      nla_get_string(info->attrs[CTRL_ATTR_FAMILY_NAME]));
  83
  84         if (info->attrs[CTRL_ATTR_VERSION]) {
  85                 uint32_t version = nla_get_u32(info->attrs[CTRL_ATTR_VERSION]);
  86                 genl_family_set_version(family, version);
  87         }
  88
  89         if (info->attrs[CTRL_ATTR_HDRSIZE]) {
  90                 uint32_t hdrsize = nla_get_u32(info->attrs[CTRL_ATTR_HDRSIZE]);
  91                 genl_family_set_hdrsize(family, hdrsize);
  92         }
  93
  94         if (info->attrs[CTRL_ATTR_MAXATTR]) {
  95                 uint32_t maxattr = nla_get_u32(info->attrs[CTRL_ATTR_MAXATTR]);
  96                 genl_family_set_maxattr(family, maxattr);
  97         }
  98
  99         if (info->attrs[CTRL_ATTR_OPS]) {
 100                 struct nlattr *nla, *nla_ops;
 101                 int remaining;
 102
 103                 nla_ops = info->attrs[CTRL_ATTR_OPS];
 104                 nla_for_each_nested(nla, nla_ops, remaining) {
 105                         struct nlattr *tb[CTRL_ATTR_OP_MAX+1];
 106                         int flags = 0, id;
 107
 108                         err = nla_parse_nested(tb, CTRL_ATTR_OP_MAX, nla,
 109                                                family_op_policy);
 110                         if (err < 0)
 111                                 goto errout;
 112
 113                         if (tb[CTRL_ATTR_OP_ID] == NULL) {
 114                                 err = nl_errno(EINVAL);
 115                                 goto errout;
 116                         }
 117
 118                         id = nla_get_u32(tb[CTRL_ATTR_OP_ID]);
 119
 120                         if (tb[CTRL_ATTR_OP_FLAGS])
 121                                 flags = nla_get_u32(tb[CTRL_ATTR_OP_FLAGS]);
 122
 123                         err = genl_family_add_op(family, id, flags);
 124                         if (err < 0)
 125                                 goto errout;
 126
 127                 }
 128         }
 129
 130         err = pp->pp_cb((struct nl_object *) family, pp);
 131         if (err < 0)
 132                 goto errout;
 133
 134         err = P_ACCEPT;
 135
 136 errout:
 137         genl_family_put(family);
 138         return err;
 139 }
 140
 141 /**
 142  * @name Cache Management
 143  * @{
 144  */
 145
 146 struct nl_cache *genl_ctrl_alloc_cache(struct nl_handle *handle)
 147 {
 148         struct nl_cache * cache;
 149
 150         cache = nl_cache_alloc(&genl_ctrl_ops);
 151         if (cache == NULL)
 152                 return NULL;
 153
 154         if (handle && nl_cache_refill(handle, cache) < 0) {
 155                 nl_cache_free(cache);
 156                 return NULL;
 157         }
 158
 159         return cache;
 160 }
 161
 162 /**
 163  * Look up generic netlink family by id in the provided cache.
 164  * @arg cache           Generic netlink family cache.
 165  * @arg id              Family identifier.
 166  *
 167  * Searches through the cache looking for a registered family
 168  * matching the specified identifier. The caller will own a
 169  * reference on the returned object which needs to be given
 170  * back after usage using genl_family_put().
 171  *
 172  * @return Generic netlink family object or NULL if no match was found.
 173  */
 174 struct genl_family *genl_ctrl_search(struct nl_cache *cache, int id)
 175 {
 176         struct genl_family *fam;
 177
 178         if (cache->c_ops != &genl_ctrl_ops)
 179                 BUG();
 180
 181         nl_list_for_each_entry(fam, &cache->c_items, ce_list) {
 182                 if (fam->gf_id == id) {
 183                         nl_object_get((struct nl_object *) fam);
 184                         return fam;
 185                 }
 186         }
 187
 188         return NULL;
 189 }
 190
 191 /**
 192  * @name Resolver
 193  * @{
 194  */
 195
 196 /**
 197  * Look up generic netlink family by family name in the provided cache.
 198  * @arg cache           Generic netlink family cache.
 199  * @arg name            Family name.
 200  *
 201  * Searches through the cache looking for a registered family
 202  * matching the specified name. The caller will own a reference
 203  * on the returned object which needs to be given back after
 204  * usage using genl_family_put().
 205  *
 206  * @return Generic netlink family object or NULL if no match was found.
 207  */
 208 struct genl_family *genl_ctrl_search_by_name(struct nl_cache *cache,
 209                                             const char *name)
 210 {
 211         struct genl_family *fam;
 212
 213         if (cache->c_ops != &genl_ctrl_ops)
 214                 BUG();
 215
 216         nl_list_for_each_entry(fam, &cache->c_items, ce_list) {
 217                 if (!strcmp(name, fam->gf_name)) {
 218                         nl_object_get((struct nl_object *) fam);
 219                         return fam;
 220                 }
 221         }
 222
 223         return NULL;
 224 }
 225
 226 /** @} */
 227
 228 /**
 229  * Resolve generic netlink family name to its identifier
 230  * @arg handle          Netlink Handle
 231  * @arg name            Name of generic netlink family
 232  *
 233  * Resolves the generic netlink family name to its identifer and returns
 234  * it.
 235  *
 236  * @return A positive identifier or a negative error code.
 237  */
 238 int genl_ctrl_resolve(struct nl_handle *handle, const char *name)
 239 {
 240         struct nl_cache *cache;
 241         struct genl_family *family;
 242         int err;
 243
 244         cache = genl_ctrl_alloc_cache(handle);
 245         if (cache == NULL)
 246                 return nl_get_errno();
 247
 248         family = genl_ctrl_search_by_name(cache, name);
 249         if (family == NULL) {
 250                 err = nl_error(ENOENT, "Generic Netlink Family not found");
 251                 goto errout;
 252         }
 253
 254         err = genl_family_get_id(family);
 255         genl_family_put(family);
 256 errout:
 257         nl_cache_free(cache);
 258
 259         return err;
 260 }
 261
 262 /** @} */
 263
 264 static struct genl_cmd genl_cmds[] = {
 265         {
 266                 .c_id           = CTRL_CMD_NEWFAMILY,
 267                 .c_name         = "NEWFAMILY" ,
 268                 .c_maxattr      = CTRL_ATTR_MAX,
 269                 .c_attr_policy  = ctrl_policy,
 270                 .c_msg_parser   = ctrl_msg_parser,
 271         },
 272         {
 273                 .c_id           = CTRL_CMD_DELFAMILY,
 274                 .c_name         = "DELFAMILY" ,
 275         },
 276         {
 277                 .c_id           = CTRL_CMD_GETFAMILY,
 278                 .c_name         = "GETFAMILY" ,
 279         },
 280         {
 281                 .c_id           = CTRL_CMD_NEWOPS,
 282                 .c_name         = "NEWOPS" ,
 283         },
 284         {
 285                 .c_id           = CTRL_CMD_DELOPS,
 286                 .c_name         = "DELOPS" ,
 287         },
 288 };
 289
 290 static struct genl_ops genl_ops = {
 291         .o_cmds                 = genl_cmds,
 292         .o_ncmds                = ARRAY_SIZE(genl_cmds),
 293 };
 294
 295 /** @cond SKIP */
 296 extern struct nl_object_ops genl_family_ops;
 297 /** @endcond */
 298
 299 static struct nl_cache_ops genl_ctrl_ops = {
 300         .co_name                = "genl/family",
 301         .co_hdrsize             = GENL_HDRSIZE(0),
 302         .co_msgtypes            = GENL_FAMILY(GENL_ID_CTRL, "nlctrl"),
 303         .co_genl                = &genl_ops,
 304         .co_protocol            = NETLINK_GENERIC,
 305         .co_request_update      = ctrl_request_update,
 306         .co_obj_ops             = &genl_family_ops,
 307 };
 308
 309 static void __init ctrl_init(void)
 310 {
 311         genl_register(&genl_ctrl_ops);
 312 }
 313
 314 static void __exit ctrl_exit(void)
 315 {
 316         genl_unregister(&genl_ctrl_ops);
 317 }
 318
 319 /** @} */