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-2012 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup genl
  14  * @defgroup genl_ctrl Controller (Resolver)
  15  *
  16  * Resolves Generic Netlink family names to numeric identifiers.
  17  *
  18  * The controller is a component in the kernel that resolves Generic Netlink
  19  * family names to their numeric identifiers. This module provides functions
  20  * to query the controller to access the resolving functionality.
  21  * @{
  22  */
  23
  24 #include <netlink-private/genl.h>
  25 #include <netlink/netlink.h>
  26 #include <netlink/genl/genl.h>
  27 #include <netlink/genl/family.h>
  28 #include <netlink/genl/mngt.h>
  29 #include <netlink/genl/ctrl.h>
  30 #include <netlink/utils.h>
  31
  32 /** @cond SKIP */
  33 #define CTRL_VERSION            0x0001
  34
  35 static struct nl_cache_ops genl_ctrl_ops;
  36
  37 static int ctrl_request_update(struct nl_cache *c, struct nl_sock *h)
  38 {
  39         return genl_send_simple(h, GENL_ID_CTRL, CTRL_CMD_GETFAMILY,
  40                                 CTRL_VERSION, NLM_F_DUMP);
  41 }
  42
  43 static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
  44         [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
  45         [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_STRING,
  46                                     .maxlen = GENL_NAMSIZ },
  47         [CTRL_ATTR_VERSION]     = { .type = NLA_U32 },
  48         [CTRL_ATTR_HDRSIZE]     = { .type = NLA_U32 },
  49         [CTRL_ATTR_MAXATTR]     = { .type = NLA_U32 },
  50         [CTRL_ATTR_OPS]         = { .type = NLA_NESTED },
  51         [CTRL_ATTR_MCAST_GROUPS] = { .type = NLA_NESTED },
  52 };
  53
  54 static struct nla_policy family_op_policy[CTRL_ATTR_OP_MAX+1] = {
  55         [CTRL_ATTR_OP_ID]       = { .type = NLA_U32 },
  56         [CTRL_ATTR_OP_FLAGS]    = { .type = NLA_U32 },
  57 };
  58
  59 static struct nla_policy family_grp_policy[CTRL_ATTR_MCAST_GRP_MAX+1] = {
  60         [CTRL_ATTR_MCAST_GRP_NAME] = { .type = NLA_STRING },
  61         [CTRL_ATTR_MCAST_GRP_ID]   = { .type = NLA_U32 },
  62 };
  63
  64 static int parse_mcast_grps(struct genl_family *family, struct nlattr *grp_attr)
  65 {
  66         struct nlattr *nla;
  67         int remaining, err;
  68
  69         if (!grp_attr)
  70                 BUG();
  71
  72         nla_for_each_nested(nla, grp_attr, remaining) {
  73                 struct nlattr *tb[CTRL_ATTR_MCAST_GRP_MAX+1];
  74                 int id;
  75                 const char * name;
  76
  77                 err = nla_parse_nested(tb, CTRL_ATTR_MCAST_GRP_MAX, nla,
  78                                        family_grp_policy);
  79                 if (err < 0)
  80                         goto errout;
  81
  82                 if (tb[CTRL_ATTR_MCAST_GRP_ID] == NULL) {
  83                         err = -NLE_MISSING_ATTR;
  84                         goto errout;
  85                 }
  86                 id = nla_get_u32(tb[CTRL_ATTR_MCAST_GRP_ID]);
  87
  88                 if (tb[CTRL_ATTR_MCAST_GRP_NAME] == NULL) {
  89                         err = -NLE_MISSING_ATTR;
  90                         goto errout;
  91                 }
  92                 name = nla_get_string(tb[CTRL_ATTR_MCAST_GRP_NAME]);
  93
  94                 err = genl_family_add_grp(family, id, name);
  95                 if (err < 0)
  96                         goto errout;
  97         }
  98
  99         err = 0;
 100
 101 errout:
 102         return err;
 103 }
 104
 105 static int ctrl_msg_parser(struct nl_cache_ops *ops, struct genl_cmd *cmd,
 106                            struct genl_info *info, void *arg)
 107 {
 108         struct genl_family *family;
 109         struct nl_parser_param *pp = arg;
 110         int err;
 111
 112         family = genl_family_alloc();
 113         if (family == NULL) {
 114                 err = -NLE_NOMEM;
 115                 goto errout;
 116         }
 117
 118         if (info->attrs[CTRL_ATTR_FAMILY_NAME] == NULL) {
 119                 err = -NLE_MISSING_ATTR;
 120                 goto errout;
 121         }
 122
 123         if (info->attrs[CTRL_ATTR_FAMILY_ID] == NULL) {
 124                 err = -NLE_MISSING_ATTR;
 125                 goto errout;
 126         }
 127
 128         family->ce_msgtype = info->nlh->nlmsg_type;
 129         genl_family_set_id(family,
 130                            nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]));
 131         genl_family_set_name(family,
 132                      nla_get_string(info->attrs[CTRL_ATTR_FAMILY_NAME]));
 133
 134         if (info->attrs[CTRL_ATTR_VERSION]) {
 135                 uint32_t version = nla_get_u32(info->attrs[CTRL_ATTR_VERSION]);
 136                 genl_family_set_version(family, version);
 137         }
 138
 139         if (info->attrs[CTRL_ATTR_HDRSIZE]) {
 140                 uint32_t hdrsize = nla_get_u32(info->attrs[CTRL_ATTR_HDRSIZE]);
 141                 genl_family_set_hdrsize(family, hdrsize);
 142         }
 143
 144         if (info->attrs[CTRL_ATTR_MAXATTR]) {
 145                 uint32_t maxattr = nla_get_u32(info->attrs[CTRL_ATTR_MAXATTR]);
 146                 genl_family_set_maxattr(family, maxattr);
 147         }
 148
 149         if (info->attrs[CTRL_ATTR_OPS]) {
 150                 struct nlattr *nla, *nla_ops;
 151                 int remaining;
 152
 153                 nla_ops = info->attrs[CTRL_ATTR_OPS];
 154                 nla_for_each_nested(nla, nla_ops, remaining) {
 155                         struct nlattr *tb[CTRL_ATTR_OP_MAX+1];
 156                         int flags = 0, id;
 157
 158                         err = nla_parse_nested(tb, CTRL_ATTR_OP_MAX, nla,
 159                                                family_op_policy);
 160                         if (err < 0)
 161                                 goto errout;
 162
 163                         if (tb[CTRL_ATTR_OP_ID] == NULL) {
 164                                 err = -NLE_MISSING_ATTR;
 165                                 goto errout;
 166                         }
 167
 168                         id = nla_get_u32(tb[CTRL_ATTR_OP_ID]);
 169
 170                         if (tb[CTRL_ATTR_OP_FLAGS])
 171                                 flags = nla_get_u32(tb[CTRL_ATTR_OP_FLAGS]);
 172
 173                         err = genl_family_add_op(family, id, flags);
 174                         if (err < 0)
 175                                 goto errout;
 176
 177                 }
 178         }
 179
 180         if (info->attrs[CTRL_ATTR_MCAST_GROUPS]) {
 181                 err = parse_mcast_grps(family, info->attrs[CTRL_ATTR_MCAST_GROUPS]);
 182                 if (err < 0)
 183                         goto errout;
 184         }
 185
 186         err = pp->pp_cb((struct nl_object *) family, pp);
 187 errout:
 188         genl_family_put(family);
 189         return err;
 190 }
 191
 192 /**
 193  * process responses from from the query sent by genl_ctrl_probe_by_name
 194  * @arg nl_msg          Returned message.
 195  * @arg name            genl_family structure to fill out.
 196  *
 197  * Process returned messages, filling out the missing informatino in the
 198  * genl_family structure
 199  *
 200  * @return Indicator to keep processing frames or not
 201  *
 202  */
 203 static int probe_response(struct nl_msg *msg, void *arg)
 204 {
 205         struct nlattr *tb[CTRL_ATTR_MAX+1];
 206         struct nlmsghdr *nlh = nlmsg_hdr(msg);
 207         struct genl_family *ret = (struct genl_family *)arg;
 208
 209         if (genlmsg_parse(nlh, 0, tb, CTRL_ATTR_MAX, ctrl_policy))
 210                 return NL_SKIP;
 211
 212         if (tb[CTRL_ATTR_FAMILY_ID])
 213                 genl_family_set_id(ret, nla_get_u16(tb[CTRL_ATTR_FAMILY_ID]));
 214
 215         if (tb[CTRL_ATTR_MCAST_GROUPS])
 216                 if (parse_mcast_grps(ret, tb[CTRL_ATTR_MCAST_GROUPS]) < 0)
 217                         return NL_SKIP;
 218
 219         return NL_STOP;
 220 }
 221
 222 /**
 223  * Look up generic netlink family by family name querying the kernel directly
 224  * @arg sk              Socket.
 225  * @arg name            Family name.
 226  *
 227  * Directly query's the kernel for a given family name.  The caller will own a
 228  * reference on the returned object which needsd to be given back after usage
 229  * using genl_family_put.
 230  *
 231  * Note: This API call differs from genl_ctrl_search_by_name in that it querys
 232  * the kernel directly, alowing for module autoload to take place to resolve the
 233  * family request. Using an nl_cache prevents that operation
 234  *
 235  * @return Generic netlink family object or NULL if no match was found.
 236  */
 237 static struct genl_family *genl_ctrl_probe_by_name(struct nl_sock *sk,
 238                                                    const char *name)
 239 {
 240         struct nl_msg *msg;
 241         struct genl_family *ret;
 242         struct nl_cb *cb, *orig;
 243         int rc;
 244
 245         ret = genl_family_alloc();
 246         if (!ret)
 247                 goto out;
 248
 249         genl_family_set_name(ret, name);
 250
 251         msg = nlmsg_alloc();
 252         if (!msg)
 253                 goto out_fam_free;
 254
 255         if (!(orig = nl_socket_get_cb(sk)))
 256                 goto out_msg_free;
 257
 258         cb = nl_cb_clone(orig);
 259         nl_cb_put(orig);
 260         if (!cb)
 261                 goto out_msg_free;
 262
 263         if (!genlmsg_put(msg, NL_AUTO_PORT, NL_AUTO_SEQ, GENL_ID_CTRL,
 264                         0, 0, CTRL_CMD_GETFAMILY, 1)) {
 265                 BUG();
 266                 goto out_cb_free;
 267         }
 268
 269         if (nla_put_string(msg, CTRL_ATTR_FAMILY_NAME, name) < 0)
 270                 goto out_cb_free;
 271
 272         rc = nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, probe_response,
 273                        (void *) ret);
 274         if (rc < 0)
 275                 goto out_cb_free;
 276
 277         rc = nl_send_auto_complete(sk, msg);
 278         if (rc < 0)
 279                 goto out_cb_free;
 280
 281         rc = nl_recvmsgs(sk, cb);
 282         if (rc < 0)
 283                 goto out_cb_free;
 284
 285         /* If search was successful, request may be ACKed after data */
 286         rc = wait_for_ack(sk);
 287         if (rc < 0)
 288                 goto out_cb_free;
 289
 290         if (genl_family_get_id(ret) != 0) {
 291                 nlmsg_free(msg);
 292                 nl_cb_put(cb);
 293                 return ret;
 294         }
 295
 296 out_cb_free:
 297         nl_cb_put(cb);
 298 out_msg_free:
 299         nlmsg_free(msg);
 300 out_fam_free:
 301         genl_family_put(ret);
 302         ret = NULL;
 303 out:
 304         return ret;
 305 }
 306
 307
 308 /** @endcond */
 309
 310 /**
 311  * @name Controller Cache
 312  *
 313  * The controller cache allows to keep a local copy of the list of all
 314  * kernel side registered Generic Netlink families to quickly resolve
 315  * multiple Generic Netlink family names without requiring to communicate
 316  * with the kernel for each resolving iteration.
 317  *
 318  * @{
 319  */
 320
 321 /**
 322  * Allocate a new controller cache
 323  * @arg sk              Generic Netlink socket
 324  * @arg result          Pointer to store resulting cache
 325  *
 326  * Allocates a new cache mirroring the state of the controller and stores it
 327  * in \c *result. The allocated cache will contain a list of all currently
 328  * registered kernel side Generic Netlink families. The cache is meant to be
 329  * used to resolve family names locally.
 330  *
 331  * @return 0 on success or a negative error code.
 332  */
 333 int genl_ctrl_alloc_cache(struct nl_sock *sk, struct nl_cache **result)
 334 {
 335         return nl_cache_alloc_and_fill(&genl_ctrl_ops, sk, result);
 336 }
 337
 338 /**
 339  * Search controller cache for a numeric address match
 340  * @arg cache           Controller cache
 341  * @arg id              Numeric family identifier.
 342  *
 343  * Searches a previously allocated controller cache and looks for an entry
 344  * that matches the specified numeric family identifier \c id.  If a match
 345  * is found successfully, the reference count of the matching object is
 346  * increased by one before the objet is returned.
 347  *
 348  * @see genl_ctrl_alloc_cache()
 349  * @see genl_ctrl_search_by_name()
 350  * @see genl_family_put()
 351  *
 352  * @return Generic Netlink family object or NULL if no match was found.
 353  */
 354 struct genl_family *genl_ctrl_search(struct nl_cache *cache, int id)
 355 {
 356         struct genl_family *fam;
 357
 358         if (cache->c_ops != &genl_ctrl_ops)
 359                 BUG();
 360
 361         nl_list_for_each_entry(fam, &cache->c_items, ce_list) {
 362                 if (fam->gf_id == id) {
 363                         nl_object_get((struct nl_object *) fam);
 364                         return fam;
 365                 }
 366         }
 367
 368         return NULL;
 369 }
 370
 371 /**
 372  * Search controller cache for a family name match
 373  * @arg cache           Controller cache
 374  * @arg name            Name of Generic Netlink family
 375  *
 376  * Searches a previously allocated controller cache and looks for an entry
 377  * that matches the specified family \c name. If a match is found successfully,
 378  * the reference count of the matching object is increased by one before the
 379  * objet is returned.
 380  *
 381  * @see genl_ctrl_alloc_cache()
 382  * @see genl_ctrl_search()
 383  * @see genl_family_put()
 384  *
 385  * @return Generic Netlink family object or NULL if no match was found.
 386  */
 387 struct genl_family *genl_ctrl_search_by_name(struct nl_cache *cache,
 388                                              const char *name)
 389 {
 390         struct genl_family *fam;
 391
 392         if (cache->c_ops != &genl_ctrl_ops)
 393                 BUG();
 394
 395         nl_list_for_each_entry(fam, &cache->c_items, ce_list) {
 396                 if (!strcmp(name, fam->gf_name)) {
 397                         nl_object_get((struct nl_object *) fam);
 398                         return fam;
 399                 }
 400         }
 401
 402         return NULL;
 403 }
 404
 405 /** @} */
 406
 407 /**
 408  * @name Direct Resolvers
 409  *
 410  * These functions communicate directly with the kernel and do not require
 411  * a cache to be kept up to date.
 412  *
 413  * @{
 414  */
 415
 416 /**
 417  * Resolve Generic Netlink family name to numeric identifier
 418  * @arg sk              Generic Netlink socket.
 419  * @arg name            Name of Generic Netlink family
 420  *
 421  * Resolves the Generic Netlink family name to the corresponding numeric
 422  * family identifier. This function queries the kernel directly, use
 423  * genl_ctrl_search_by_name() if you need to resolve multiple names.
 424  *
 425  * @see genl_ctrl_search_by_name()
 426  *
 427  * @return The numeric family identifier or a negative error code.
 428  */
 429 int genl_ctrl_resolve(struct nl_sock *sk, const char *name)
 430 {
 431         struct genl_family *family;
 432         int err;
 433
 434         family = genl_ctrl_probe_by_name(sk, name);
 435         if (family == NULL) {
 436                 err = -NLE_OBJ_NOTFOUND;
 437                 goto errout;
 438         }
 439
 440         err = genl_family_get_id(family);
 441         genl_family_put(family);
 442 errout:
 443         return err;
 444 }
 445
 446 static int genl_ctrl_grp_by_name(const struct genl_family *family,
 447                                  const char *grp_name)
 448 {
 449         struct genl_family_grp *grp;
 450
 451         nl_list_for_each_entry(grp, &family->gf_mc_grps, list) {
 452                 if (!strcmp(grp->name, grp_name)) {
 453                         return grp->id;
 454                 }
 455         }
 456
 457         return -NLE_OBJ_NOTFOUND;
 458 }
 459
 460 /**
 461  * Resolve Generic Netlink family group name
 462  * @arg sk              Generic Netlink socket
 463  * @arg family_name     Name of Generic Netlink family
 464  * @arg grp_name        Name of group to resolve
 465  *
 466  * Looks up the family object and resolves the group name to the numeric
 467  * group identifier.
 468  *
 469  * @return Numeric group identifier or a negative error code.
 470  */
 471 int genl_ctrl_resolve_grp(struct nl_sock *sk, const char *family_name,
 472                           const char *grp_name)
 473 {
 474
 475         struct genl_family *family;
 476         int err;
 477
 478         family = genl_ctrl_probe_by_name(sk, family_name);
 479         if (family == NULL) {
 480                 err = -NLE_OBJ_NOTFOUND;
 481                 goto errout;
 482         }
 483
 484         err = genl_ctrl_grp_by_name(family, grp_name);
 485         genl_family_put(family);
 486 errout:
 487         return err;
 488 }
 489
 490 /** @} */
 491
 492 /** @cond SKIP */
 493 static struct genl_cmd genl_cmds[] = {
 494         {
 495                 .c_id           = CTRL_CMD_NEWFAMILY,
 496                 .c_name         = "NEWFAMILY" ,
 497                 .c_maxattr      = CTRL_ATTR_MAX,
 498                 .c_attr_policy  = ctrl_policy,
 499                 .c_msg_parser   = ctrl_msg_parser,
 500         },
 501         {
 502                 .c_id           = CTRL_CMD_DELFAMILY,
 503                 .c_name         = "DELFAMILY" ,
 504         },
 505         {
 506                 .c_id           = CTRL_CMD_GETFAMILY,
 507                 .c_name         = "GETFAMILY" ,
 508         },
 509         {
 510                 .c_id           = CTRL_CMD_NEWOPS,
 511                 .c_name         = "NEWOPS" ,
 512         },
 513         {
 514                 .c_id           = CTRL_CMD_DELOPS,
 515                 .c_name         = "DELOPS" ,
 516         },
 517 };
 518
 519 static struct genl_ops genl_ops = {
 520         .o_cmds                 = genl_cmds,
 521         .o_ncmds                = ARRAY_SIZE(genl_cmds),
 522 };
 523
 524 extern struct nl_object_ops genl_family_ops;
 525
 526 static struct nl_cache_ops genl_ctrl_ops = {
 527         .co_name                = "genl/family",
 528         .co_hdrsize             = GENL_HDRSIZE(0),
 529         .co_msgtypes            = GENL_FAMILY(GENL_ID_CTRL, "nlctrl"),
 530         .co_genl                = &genl_ops,
 531         .co_protocol            = NETLINK_GENERIC,
 532         .co_request_update      = ctrl_request_update,
 533         .co_obj_ops             = &genl_family_ops,
 534 };
 535
 536 static void __init ctrl_init(void)
 537 {
 538         genl_register(&genl_ctrl_ops);
 539 }
 540
 541 static void __exit ctrl_exit(void)
 542 {
 543         genl_unregister(&genl_ctrl_ops);
 544 }
 545 /** @endcond */
 546
 547 /** @} */