Root/package/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
169static size_t default_msg_size;
170
171static void __init init_msg_size(void)
172{
173    default_msg_size = getpagesize();
174}
175
176/**
177 * @name Attribute Access
178 * @{
179 */
180
181//** @} */
182
183/**
184 * @name Message Parsing
185 * @{
186 */
187
188/**
189 * check if the netlink message fits into the remaining bytes
190 * @arg nlh netlink message header
191 * @arg remaining number of bytes remaining in message stream
192 */
193int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
194{
195    return (remaining >= sizeof(struct nlmsghdr) &&
196        nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
197        nlh->nlmsg_len <= remaining);
198}
199
200/**
201 * next netlink message in message stream
202 * @arg nlh netlink message header
203 * @arg remaining number of bytes remaining in message stream
204 *
205 * @returns the next netlink message in the message stream and
206 * decrements remaining by the size of the current message.
207 */
208struct nlmsghdr *nlmsg_next(struct nlmsghdr *nlh, int *remaining)
209{
210    int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
211
212    *remaining -= totlen;
213
214    return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
215}
216
217/**
218 * parse attributes of a netlink message
219 * @arg nlh netlink message header
220 * @arg hdrlen length of family specific header
221 * @arg tb destination array with maxtype+1 elements
222 * @arg maxtype maximum attribute type to be expected
223 * @arg policy validation policy
224 *
225 * See nla_parse()
226 */
227int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[],
228        int maxtype, struct nla_policy *policy)
229{
230    if (!nlmsg_valid_hdr(nlh, hdrlen))
231        return -NLE_MSG_TOOSHORT;
232
233    return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
234             nlmsg_attrlen(nlh, hdrlen), policy);
235}
236
237/**
238 * nlmsg_validate - validate a netlink message including attributes
239 * @arg nlh netlinket message header
240 * @arg hdrlen length of familiy specific header
241 * @arg maxtype maximum attribute type to be expected
242 * @arg policy validation policy
243 */
244int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
245           struct nla_policy *policy)
246{
247    if (!nlmsg_valid_hdr(nlh, hdrlen))
248        return -NLE_MSG_TOOSHORT;
249
250    return nla_validate(nlmsg_attrdata(nlh, hdrlen),
251                nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
252}
253
254/** @} */
255
256/**
257 * @name Message Building/Access
258 * @{
259 */
260
261static struct nl_msg *__nlmsg_alloc(size_t len)
262{
263    struct nl_msg *nm;
264
265    nm = calloc(1, sizeof(*nm));
266    if (!nm)
267        goto errout;
268
269    nm->nm_refcnt = 1;
270
271    nm->nm_nlh = malloc(len);
272    if (!nm->nm_nlh)
273        goto errout;
274
275    memset(nm->nm_nlh, 0, sizeof(struct nlmsghdr));
276
277    nm->nm_protocol = -1;
278    nm->nm_size = len;
279    nm->nm_nlh->nlmsg_len = nlmsg_total_size(0);
280
281    NL_DBG(2, "msg %p: Allocated new message, maxlen=%zu\n", nm, len);
282
283    return nm;
284errout:
285    free(nm);
286    return NULL;
287}
288
289/**
290 * Allocate a new netlink message with the default maximum payload size.
291 *
292 * Allocates a new netlink message without any further payload. The
293 * maximum payload size defaults to PAGESIZE or as otherwise specified
294 * with nlmsg_set_default_size().
295 *
296 * @return Newly allocated netlink message or NULL.
297 */
298struct nl_msg *nlmsg_alloc(void)
299{
300    return __nlmsg_alloc(default_msg_size);
301}
302
303/**
304 * Allocate a new netlink message with maximum payload size specified.
305 */
306struct nl_msg *nlmsg_alloc_size(size_t max)
307{
308    return __nlmsg_alloc(max);
309}
310
311/**
312 * Allocate a new netlink message and inherit netlink message header
313 * @arg hdr Netlink message header template
314 *
315 * Allocates a new netlink message and inherits the original message
316 * header. If \a hdr is not NULL it will be used as a template for
317 * the netlink message header, otherwise the header is left blank.
318 *
319 * @return Newly allocated netlink message or NULL
320 */
321struct nl_msg *nlmsg_inherit(struct nlmsghdr *hdr)
322{
323    struct nl_msg *nm;
324
325    nm = nlmsg_alloc();
326    if (nm && hdr) {
327        struct nlmsghdr *new = nm->nm_nlh;
328
329        new->nlmsg_type = hdr->nlmsg_type;
330        new->nlmsg_flags = hdr->nlmsg_flags;
331        new->nlmsg_seq = hdr->nlmsg_seq;
332        new->nlmsg_pid = hdr->nlmsg_pid;
333    }
334
335    return nm;
336}
337
338/**
339 * Allocate a new netlink message
340 * @arg nlmsgtype Netlink message type
341 * @arg flags Message flags.
342 *
343 * @return Newly allocated netlink message or NULL.
344 */
345struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags)
346{
347    struct nl_msg *msg;
348    struct nlmsghdr nlh = {
349        .nlmsg_type = nlmsgtype,
350        .nlmsg_flags = flags,
351    };
352
353    msg = nlmsg_inherit(&nlh);
354    if (msg)
355        NL_DBG(2, "msg %p: Allocated new simple message\n", msg);
356
357    return msg;
358}
359
360/**
361 * Set the default maximum message payload size for allocated messages
362 * @arg max Size of payload in bytes.
363 */
364void nlmsg_set_default_size(size_t max)
365{
366    if (max < nlmsg_total_size(0))
367        max = nlmsg_total_size(0);
368
369    default_msg_size = max;
370}
371
372/**
373 * Convert a netlink message received from a netlink socket to a nl_msg
374 * @arg hdr Netlink message received from netlink socket.
375 *
376 * Allocates a new netlink message and copies all of the data pointed to
377 * by \a hdr into the new message object.
378 *
379 * @return Newly allocated netlink message or NULL.
380 */
381struct nl_msg *nlmsg_convert(struct nlmsghdr *hdr)
382{
383    struct nl_msg *nm;
384
385    nm = __nlmsg_alloc(NLMSG_ALIGN(hdr->nlmsg_len));
386    if (!nm)
387        goto errout;
388
389    memcpy(nm->nm_nlh, hdr, hdr->nlmsg_len);
390
391    return nm;
392errout:
393    nlmsg_free(nm);
394    return NULL;
395}
396
397/**
398 * Reserve room for additional data in a netlink message
399 * @arg n netlink message
400 * @arg len length of additional data to reserve room for
401 * @arg pad number of bytes to align data to
402 *
403 * Reserves room for additional data at the tail of the an
404 * existing netlink message. Eventual padding required will
405 * be zeroed out.
406 *
407 * @return Pointer to start of additional data tailroom or NULL.
408 */
409void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad)
410{
411    void *buf = n->nm_nlh;
412    size_t nlmsg_len = n->nm_nlh->nlmsg_len;
413    size_t tlen;
414
415    tlen = pad ? ((len + (pad - 1)) & ~(pad - 1)) : len;
416
417    if ((tlen + nlmsg_len) > n->nm_size)
418        return NULL;
419
420    buf += nlmsg_len;
421    n->nm_nlh->nlmsg_len += tlen;
422
423    if (tlen > len)
424        memset(buf + len, 0, tlen - len);
425
426    NL_DBG(2, "msg %p: Reserved %zu bytes, pad=%d, nlmsg_len=%d\n",
427          n, len, pad, n->nm_nlh->nlmsg_len);
428
429    return buf;
430}
431
432/**
433 * Append data to tail of a netlink message
434 * @arg n netlink message
435 * @arg data data to add
436 * @arg len length of data
437 * @arg pad Number of bytes to align data to.
438 *
439 * Extends the netlink message as needed and appends the data of given
440 * length to the message.
441 *
442 * @return 0 on success or a negative error code
443 */
444int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
445{
446    void *tmp;
447
448    tmp = nlmsg_reserve(n, len, pad);
449    if (tmp == NULL)
450        return -NLE_NOMEM;
451
452    memcpy(tmp, data, len);
453    NL_DBG(2, "msg %p: Appended %zu bytes with padding %d\n", n, len, pad);
454
455    return 0;
456}
457
458/**
459 * Add a netlink message header to a netlink message
460 * @arg n netlink message
461 * @arg pid netlink process id or NL_AUTO_PID
462 * @arg seq sequence number of message or NL_AUTO_SEQ
463 * @arg type message type
464 * @arg payload length of message payload
465 * @arg flags message flags
466 *
467 * Adds or overwrites the netlink message header in an existing message
468 * object. If \a payload is greater-than zero additional room will be
469 * reserved, f.e. for family specific headers. It can be accesed via
470 * nlmsg_data().
471 *
472 * @return A pointer to the netlink message header or NULL.
473 */
474struct nlmsghdr *nlmsg_put(struct nl_msg *n, uint32_t pid, uint32_t seq,
475               int type, int payload, int flags)
476{
477    struct nlmsghdr *nlh;
478
479    if (n->nm_nlh->nlmsg_len < NLMSG_HDRLEN)
480        BUG();
481
482    nlh = (struct nlmsghdr *) n->nm_nlh;
483    nlh->nlmsg_type = type;
484    nlh->nlmsg_flags = flags;
485    nlh->nlmsg_pid = pid;
486    nlh->nlmsg_seq = seq;
487
488    NL_DBG(2, "msg %p: Added netlink header type=%d, flags=%d, pid=%d, "
489          "seq=%d\n", n, type, flags, pid, seq);
490
491    if (payload > 0 &&
492        nlmsg_reserve(n, payload, NLMSG_ALIGNTO) == NULL)
493        return NULL;
494
495    return nlh;
496}
497
498/**
499 * Release a reference from an netlink message
500 * @arg msg message to release reference from
501 *
502 * Frees memory after the last reference has been released.
503 */
504void nlmsg_free(struct nl_msg *msg)
505{
506    if (!msg)
507        return;
508
509    msg->nm_refcnt--;
510    NL_DBG(4, "Returned message reference %p, %d remaining\n",
511           msg, msg->nm_refcnt);
512
513    if (msg->nm_refcnt < 0)
514        BUG();
515
516    if (msg->nm_refcnt <= 0) {
517        free(msg->nm_nlh);
518        free(msg);
519        NL_DBG(2, "msg %p: Freed\n", msg);
520    }
521}
522
523/** @} */
524
525/**
526 * @name Direct Parsing
527 * @{
528 */
529
530/** @cond SKIP */
531struct dp_xdata {
532    void (*cb)(struct nl_object *, void *);
533    void *arg;
534};
535/** @endcond */
536
537static int parse_cb(struct nl_object *obj, struct nl_parser_param *p)
538{
539    struct dp_xdata *x = p->pp_arg;
540
541    x->cb(obj, x->arg);
542    return 0;
543}
544
545int nl_msg_parse(struct nl_msg *msg, void (*cb)(struct nl_object *, void *),
546         void *arg)
547{
548    struct nl_cache_ops *ops;
549    struct nl_parser_param p = {
550        .pp_cb = parse_cb
551    };
552    struct dp_xdata x = {
553        .cb = cb,
554        .arg = arg,
555    };
556
557    ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
558                     nlmsg_hdr(msg)->nlmsg_type);
559    if (ops == NULL)
560        return -NLE_MSGTYPE_NOSUPPORT;
561    p.pp_arg = &x;
562
563    return nl_cache_parse(ops, NULL, nlmsg_hdr(msg), &p);
564}
565
566/** @} */
567

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive