package/libs/libnl-tiny/src/msg.c

   1 /*
   2  * lib/msg.c            Netlink Messages Interface
   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 core
  14  * @defgroup msg Messages
  15  * Netlink Message Construction/Parsing Interface
  16  *
  17  * The following information is partly extracted from RFC3549
  18  * (ftp://ftp.rfc-editor.org/in-notes/rfc3549.txt)
  19  *
  20  * @par Message Format
  21  * Netlink messages consist of a byte stream with one or multiple
  22  * Netlink headers and an associated payload.  If the payload is too big
  23  * to fit into a single message it, can be split over multiple Netlink
  24  * messages, collectively called a multipart message.  For multipart
  25  * messages, the first and all following headers have the \c NLM_F_MULTI
  26  * Netlink header flag set, except for the last header which has the
  27  * Netlink header type \c NLMSG_DONE.
  28  *
  29  * @par
  30  * The Netlink message header (\link nlmsghdr struct nlmsghdr\endlink) is shown below.
  31  * @code
  32  * 0                   1                   2                   3
  33  * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  34  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  35  * |                          Length                             |
  36  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  37  * |            Type              |           Flags              |
  38  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  39  * |                      Sequence Number                        |
  40  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  41  * |                      Process ID (PID)                       |
  42  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  43  * @endcode
  44  *
  45  * @par
  46  * The netlink message header and payload must be aligned properly:
  47  * @code
  48  *  <------- NLMSG_ALIGN(hlen) ------> <---- NLMSG_ALIGN(len) --->
  49  * +----------------------------+- - -+- - - - - - - - - - -+- - -+
  50  * |           Header           | Pad |       Payload       | Pad |
  51  * |      struct nlmsghdr       |     |                     |     |
  52  * +----------------------------+- - -+- - - - - - - - - - -+- - -+
  53  * @endcode
  54  * @par
  55  * Message Format:
  56  * @code
  57  *    <--- nlmsg_total_size(payload)  --->
  58  *    <-- nlmsg_msg_size(payload) ->
  59  *   +----------+- - -+-------------+- - -+-------- - -
  60  *   | nlmsghdr | Pad |   Payload   | Pad | nlmsghdr
  61  *   +----------+- - -+-------------+- - -+-------- - -
  62  *   nlmsg_data(nlh)---^                   ^
  63  *   nlmsg_next(nlh)-----------------------+
  64  * @endcode
  65  * @par
  66  * The payload may consist of arbitary data but may have strict
  67  * alignment and formatting rules depening on the specific netlink
  68  * families.
  69  * @par
  70  * @code
  71  *    <---------------------- nlmsg_len(nlh) --------------------->
  72  *    <------ hdrlen ------>       <- nlmsg_attrlen(nlh, hdrlen) ->
  73  *   +----------------------+- - -+--------------------------------+
  74  *   |     Family Header    | Pad |           Attributes           |
  75  *   +----------------------+- - -+--------------------------------+
  76  *   nlmsg_attrdata(nlh, hdrlen)---^
  77  * @endcode
  78  * @par The ACK Netlink Message
  79  * This message is actually used to denote both an ACK and a NACK.
  80  * Typically, the direction is from FEC to CPC (in response to an ACK
  81  * request message).  However, the CPC should be able to send ACKs back
  82  * to FEC when requested.
  83  * @code
  84  *  0                   1                   2                   3
  85  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  86  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  87  * |                       Netlink message header                  |
  88  * |                       type = NLMSG_ERROR                      |
  89  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  90  * |                          Error code                           |
  91  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  92  * |                       OLD Netlink message header              |
  93  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  94  * @endcode
  95  *
  96  * @par Example
  97  * @code
  98  * // Various methods exist to create/allocate a new netlink
  99  * // message.
 100  * //
 101  * // nlmsg_alloc() will allocate an empty netlink message with
 102  * // a maximum payload size which defaults to the page size of
 103  * // the system. This default size can be modified using the
 104  * // function nlmsg_set_default_size().
 105  * struct nl_msg *msg = nlmsg_alloc();
 106  *
 107  * // Very often, the message type and message flags are known
 108  * // at allocation time while the other fields are auto generated:
 109  * struct nl_msg *msg = nlmsg_alloc_simple(MY_TYPE, MY_FLAGS);
 110  *
 111  * // Alternatively an existing netlink message header can be used
 112  * // to inherit the header values:
 113  * struct nlmsghdr hdr = {
 114  *      .nlmsg_type = MY_TYPE,
 115  *      .nlmsg_flags = MY_FLAGS,
 116  * };
 117  * struct nl_msg *msg = nlmsg_inherit(&hdr);
 118  *
 119  * // Last but not least, netlink messages received from netlink sockets
 120  * // can be converted into nl_msg objects using nlmsg_convert(). This
 121  * // will create a message with a maximum payload size which equals the
 122  * // length of the existing netlink message, therefore no more data can
 123  * // be appened without calling nlmsg_expand() first.
 124  * struct nl_msg *msg = nlmsg_convert(nlh_from_nl_sock);
 125  *
 126  * // Payload may be added to the message via nlmsg_append(). The fourth
 127  * // parameter specifies the number of alignment bytes the data should
 128  * // be padding with at the end. Common values are 0 to disable it or
 129  * // NLMSG_ALIGNTO to ensure proper netlink message padding.
 130  * nlmsg_append(msg, &mydata, sizeof(mydata), 0);
 131  *
 132  * // Sometimes it may be necessary to reserve room for data but defer
 133  * // the actual copying to a later point, nlmsg_reserve() can be used
 134  * // for this purpose:
 135  * void *data = nlmsg_reserve(msg, sizeof(mydata), NLMSG_ALIGNTO);
 136  *
 137  * // Attributes may be added using the attributes interface.
 138  *
 139  * // After successful use of the message, the memory must be freed
 140  * // using nlmsg_free()
 141  * nlmsg_free(msg);
 142  * @endcode
 143  *
 144  * @par 4) Parsing messages
 145  * @code
 146  * int n;
 147  * unsigned char *buf;
 148  * struct nlmsghdr *hdr;
 149  *
 150  * n = nl_recv(handle, NULL, &buf);
 151  *
 152  * hdr = (struct nlmsghdr *) buf;
 153  * while (nlmsg_ok(hdr, n)) {
 154  *      // Process message here...
 155  *      hdr = nlmsg_next(hdr, &n);
 156  * }
 157  * @endcode
 158  * @{
 159  */
 160
 161 #include <netlink-local.h>
 162 #include <netlink/netlink.h>
 163 #include <netlink/utils.h>
 164 #include <netlink/cache.h>
 165 #include <netlink/attr.h>
 166 #include <netlink/msg.h>
 167 #include <linux/socket.h>
 168
 169 static size_t default_msg_size = 4096;
 170
 171 /**
 172  * @name Attribute Access
 173  * @{
 174  */
 175
 176 //** @} */
 177
 178 /**
 179  * @name Message Parsing
 180  * @{
 181  */
 182
 183 /**
 184  * check if the netlink message fits into the remaining bytes
 185  * @arg nlh             netlink message header
 186  * @arg remaining       number of bytes remaining in message stream
 187  */
 188 int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
 189 {
 190         return (remaining >= sizeof(struct nlmsghdr) &&
 191                 nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
 192                 nlh->nlmsg_len <= remaining);
 193 }
 194
 195 /**
 196  * next netlink message in message stream
 197  * @arg nlh             netlink message header
 198  * @arg remaining       number of bytes remaining in message stream
 199  *
 200  * @returns the next netlink message in the message stream and
 201  * decrements remaining by the size of the current message.
 202  */
 203 struct nlmsghdr *nlmsg_next(struct nlmsghdr *nlh, int *remaining)
 204 {
 205         int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
 206
 207         *remaining -= totlen;
 208
 209         return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
 210 }
 211
 212 /**
 213  * parse attributes of a netlink message
 214  * @arg nlh             netlink message header
 215  * @arg hdrlen          length of family specific header
 216  * @arg tb              destination array with maxtype+1 elements
 217  * @arg maxtype         maximum attribute type to be expected
 218  * @arg policy          validation policy
 219  *
 220  * See nla_parse()
 221  */
 222 int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[],
 223                 int maxtype, struct nla_policy *policy)
 224 {
 225         if (!nlmsg_valid_hdr(nlh, hdrlen))
 226                 return -NLE_MSG_TOOSHORT;
 227
 228         return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
 229                          nlmsg_attrlen(nlh, hdrlen), policy);
 230 }
 231
 232 /**
 233  * nlmsg_validate - validate a netlink message including attributes
 234  * @arg nlh             netlinket message header
 235  * @arg hdrlen          length of familiy specific header
 236  * @arg maxtype         maximum attribute type to be expected
 237  * @arg policy          validation policy
 238  */
 239 int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
 240                    struct nla_policy *policy)
 241 {
 242         if (!nlmsg_valid_hdr(nlh, hdrlen))
 243                 return -NLE_MSG_TOOSHORT;
 244
 245         return nla_validate(nlmsg_attrdata(nlh, hdrlen),
 246                             nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
 247 }
 248
 249 /** @} */
 250
 251 /**
 252  * @name Message Building/Access
 253  * @{
 254  */
 255
 256 static struct nl_msg *__nlmsg_alloc(size_t len)
 257 {
 258         struct nl_msg *nm;
 259
 260         nm = calloc(1, sizeof(*nm));
 261         if (!nm)
 262                 goto errout;
 263
 264         nm->nm_refcnt = 1;
 265
 266         nm->nm_nlh = malloc(len);
 267         if (!nm->nm_nlh)
 268                 goto errout;
 269
 270         memset(nm->nm_nlh, 0, sizeof(struct nlmsghdr));
 271
 272         nm->nm_protocol = -1;
 273         nm->nm_size = len;
 274         nm->nm_nlh->nlmsg_len = nlmsg_total_size(0);
 275
 276         NL_DBG(2, "msg %p: Allocated new message, maxlen=%zu\n", nm, len);
 277
 278         return nm;
 279 errout:
 280         free(nm);
 281         return NULL;
 282 }
 283
 284 /**
 285  * Allocate a new netlink message with the default maximum payload size.
 286  *
 287  * Allocates a new netlink message without any further payload. The
 288  * maximum payload size defaults to PAGESIZE or as otherwise specified
 289  * with nlmsg_set_default_size().
 290  *
 291  * @return Newly allocated netlink message or NULL.
 292  */
 293 struct nl_msg *nlmsg_alloc(void)
 294 {
 295         return __nlmsg_alloc(default_msg_size);
 296 }
 297
 298 /**
 299  * Allocate a new netlink message with maximum payload size specified.
 300  */
 301 struct nl_msg *nlmsg_alloc_size(size_t max)
 302 {
 303         return __nlmsg_alloc(max);
 304 }
 305
 306 /**
 307  * Allocate a new netlink message and inherit netlink message header
 308  * @arg hdr             Netlink message header template
 309  *
 310  * Allocates a new netlink message and inherits the original message
 311  * header. If \a hdr is not NULL it will be used as a template for
 312  * the netlink message header, otherwise the header is left blank.
 313  *
 314  * @return Newly allocated netlink message or NULL
 315  */
 316 struct nl_msg *nlmsg_inherit(struct nlmsghdr *hdr)
 317 {
 318         struct nl_msg *nm;
 319
 320         nm = nlmsg_alloc();
 321         if (nm && hdr) {
 322                 struct nlmsghdr *new = nm->nm_nlh;
 323
 324                 new->nlmsg_type = hdr->nlmsg_type;
 325                 new->nlmsg_flags = hdr->nlmsg_flags;
 326                 new->nlmsg_seq = hdr->nlmsg_seq;
 327                 new->nlmsg_pid = hdr->nlmsg_pid;
 328         }
 329
 330         return nm;
 331 }
 332
 333 /**
 334  * Allocate a new netlink message
 335  * @arg nlmsgtype       Netlink message type
 336  * @arg flags           Message flags.
 337  *
 338  * @return Newly allocated netlink message or NULL.
 339  */
 340 struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags)
 341 {
 342         struct nl_msg *msg;
 343         struct nlmsghdr nlh = {
 344                 .nlmsg_type = nlmsgtype,
 345                 .nlmsg_flags = flags,
 346         };
 347
 348         msg = nlmsg_inherit(&nlh);
 349         if (msg)
 350                 NL_DBG(2, "msg %p: Allocated new simple message\n", msg);
 351
 352         return msg;
 353 }
 354
 355 /**
 356  * Set the default maximum message payload size for allocated messages
 357  * @arg max             Size of payload in bytes.
 358  */
 359 void nlmsg_set_default_size(size_t max)
 360 {
 361         if (max < nlmsg_total_size(0))
 362                 max = nlmsg_total_size(0);
 363
 364         default_msg_size = max;
 365 }
 366
 367 /**
 368  * Convert a netlink message received from a netlink socket to a nl_msg
 369  * @arg hdr             Netlink message received from netlink socket.
 370  *
 371  * Allocates a new netlink message and copies all of the data pointed to
 372  * by \a hdr into the new message object.
 373  *
 374  * @return Newly allocated netlink message or NULL.
 375  */
 376 struct nl_msg *nlmsg_convert(struct nlmsghdr *hdr)
 377 {
 378         struct nl_msg *nm;
 379
 380         nm = __nlmsg_alloc(NLMSG_ALIGN(hdr->nlmsg_len));
 381         if (!nm)
 382                 goto errout;
 383
 384         memcpy(nm->nm_nlh, hdr, hdr->nlmsg_len);
 385
 386         return nm;
 387 errout:
 388         nlmsg_free(nm);
 389         return NULL;
 390 }
 391
 392 /**
 393  * Reserve room for additional data in a netlink message
 394  * @arg n               netlink message
 395  * @arg len             length of additional data to reserve room for
 396  * @arg pad             number of bytes to align data to
 397  *
 398  * Reserves room for additional data at the tail of the an
 399  * existing netlink message. Eventual padding required will
 400  * be zeroed out.
 401  *
 402  * @return Pointer to start of additional data tailroom or NULL.
 403  */
 404 void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad)
 405 {
 406         void *buf = n->nm_nlh;
 407         size_t nlmsg_len = n->nm_nlh->nlmsg_len;
 408         size_t tlen;
 409
 410         tlen = pad ? ((len + (pad - 1)) & ~(pad - 1)) : len;
 411
 412         if ((tlen + nlmsg_len) > n->nm_size)
 413                 return NULL;
 414
 415         buf += nlmsg_len;
 416         n->nm_nlh->nlmsg_len += tlen;
 417
 418         if (tlen > len)
 419                 memset(buf + len, 0, tlen - len);
 420
 421         NL_DBG(2, "msg %p: Reserved %zu bytes, pad=%d, nlmsg_len=%d\n",
 422                   n, len, pad, n->nm_nlh->nlmsg_len);
 423
 424         return buf;
 425 }
 426
 427 /**
 428  * Append data to tail of a netlink message
 429  * @arg n               netlink message
 430  * @arg data            data to add
 431  * @arg len             length of data
 432  * @arg pad             Number of bytes to align data to.
 433  *
 434  * Extends the netlink message as needed and appends the data of given
 435  * length to the message.
 436  *
 437  * @return 0 on success or a negative error code
 438  */
 439 int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
 440 {
 441         void *tmp;
 442
 443         tmp = nlmsg_reserve(n, len, pad);
 444         if (tmp == NULL)
 445                 return -NLE_NOMEM;
 446
 447         memcpy(tmp, data, len);
 448         NL_DBG(2, "msg %p: Appended %zu bytes with padding %d\n", n, len, pad);
 449
 450         return 0;
 451 }
 452
 453 /**
 454  * Add a netlink message header to a netlink message
 455  * @arg n               netlink message
 456  * @arg pid             netlink process id or NL_AUTO_PID
 457  * @arg seq             sequence number of message or NL_AUTO_SEQ
 458  * @arg type            message type
 459  * @arg payload         length of message payload
 460  * @arg flags           message flags
 461  *
 462  * Adds or overwrites the netlink message header in an existing message
 463  * object. If \a payload is greater-than zero additional room will be
 464  * reserved, f.e. for family specific headers. It can be accesed via
 465  * nlmsg_data().
 466  *
 467  * @return A pointer to the netlink message header or NULL.
 468  */
 469 struct nlmsghdr *nlmsg_put(struct nl_msg *n, uint32_t pid, uint32_t seq,
 470                            int type, int payload, int flags)
 471 {
 472         struct nlmsghdr *nlh;
 473
 474         if (n->nm_nlh->nlmsg_len < NLMSG_HDRLEN)
 475                 BUG();
 476
 477         nlh = (struct nlmsghdr *) n->nm_nlh;
 478         nlh->nlmsg_type = type;
 479         nlh->nlmsg_flags = flags;
 480         nlh->nlmsg_pid = pid;
 481         nlh->nlmsg_seq = seq;
 482
 483         NL_DBG(2, "msg %p: Added netlink header type=%d, flags=%d, pid=%d, "
 484                   "seq=%d\n", n, type, flags, pid, seq);
 485
 486         if (payload > 0 &&
 487             nlmsg_reserve(n, payload, NLMSG_ALIGNTO) == NULL)
 488                 return NULL;
 489
 490         return nlh;
 491 }
 492
 493 /**
 494  * Release a reference from an netlink message
 495  * @arg msg             message to release reference from
 496  *
 497  * Frees memory after the last reference has been released.
 498  */
 499 void nlmsg_free(struct nl_msg *msg)
 500 {
 501         if (!msg)
 502                 return;
 503
 504         msg->nm_refcnt--;
 505         NL_DBG(4, "Returned message reference %p, %d remaining\n",
 506                msg, msg->nm_refcnt);
 507
 508         if (msg->nm_refcnt < 0)
 509                 BUG();
 510
 511         if (msg->nm_refcnt <= 0) {
 512                 free(msg->nm_nlh);
 513                 free(msg);
 514                 NL_DBG(2, "msg %p: Freed\n", msg);
 515         }
 516 }
 517
 518 /** @} */
 519
 520 /**
 521  * @name Direct Parsing
 522  * @{
 523  */
 524
 525 /** @cond SKIP */
 526 struct dp_xdata {
 527         void (*cb)(struct nl_object *, void *);
 528         void *arg;
 529 };
 530 /** @endcond */
 531
 532 static int parse_cb(struct nl_object *obj, struct nl_parser_param *p)
 533 {
 534         struct dp_xdata *x = p->pp_arg;
 535
 536         x->cb(obj, x->arg);
 537         return 0;
 538 }
 539
 540 int nl_msg_parse(struct nl_msg *msg, void (*cb)(struct nl_object *, void *),
 541                  void *arg)
 542 {
 543         struct nl_cache_ops *ops;
 544         struct nl_parser_param p = {
 545                 .pp_cb = parse_cb
 546         };
 547         struct dp_xdata x = {
 548                 .cb = cb,
 549                 .arg = arg,
 550         };
 551
 552         ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
 553                                      nlmsg_hdr(msg)->nlmsg_type);
 554         if (ops == NULL)
 555                 return -NLE_MSGTYPE_NOSUPPORT;
 556         p.pp_arg = &x;
 557
 558         return nl_cache_parse(ops, NULL, nlmsg_hdr(msg), &p);
 559 }
 560
 561 /** @} */