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 <linux/socket.h>
167
168 static size_t default_msg_size;
169
init_msg_size(void)170 static void __init init_msg_size(void)
171 {
172 default_msg_size = getpagesize();
173 }
174
175 /**
176 * @name Size Calculations
177 * @{
178 */
179
180 /**
181 * length of netlink message not including padding
182 * @arg payload length of message payload
183 */
nlmsg_msg_size(int payload)184 int nlmsg_msg_size(int payload)
185 {
186 return NLMSG_HDRLEN + payload;
187 }
188
189 /**
190 * length of netlink message including padding
191 * @arg payload length of message payload
192 */
nlmsg_total_size(int payload)193 int nlmsg_total_size(int payload)
194 {
195 return NLMSG_ALIGN(nlmsg_msg_size(payload));
196 }
197
198 /**
199 * length of padding at the message's tail
200 * @arg payload length of message payload
201 */
nlmsg_padlen(int payload)202 int nlmsg_padlen(int payload)
203 {
204 return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
205 }
206
207 /** @} */
208
209 /**
210 * @name Payload Access
211 * @{
212 */
213
214 /**
215 * head of message payload
216 * @arg nlh netlink messsage header
217 */
nlmsg_data(const struct nlmsghdr * nlh)218 void *nlmsg_data(const struct nlmsghdr *nlh)
219 {
220 return (unsigned char *) nlh + NLMSG_HDRLEN;
221 }
222
nlmsg_tail(const struct nlmsghdr * nlh)223 void *nlmsg_tail(const struct nlmsghdr *nlh)
224 {
225 return (unsigned char *) nlh + NLMSG_ALIGN(nlh->nlmsg_len);
226 }
227
228 /**
229 * length of message payload
230 * @arg nlh netlink message header
231 */
nlmsg_len(const struct nlmsghdr * nlh)232 int nlmsg_len(const struct nlmsghdr *nlh)
233 {
234 return nlh->nlmsg_len - NLMSG_HDRLEN;
235 }
236
237 /** @} */
238
239 /**
240 * @name Attribute Access
241 * @{
242 */
243
244 /**
245 * head of attributes data
246 * @arg nlh netlink message header
247 * @arg hdrlen length of family specific header
248 */
nlmsg_attrdata(const struct nlmsghdr * nlh,int hdrlen)249 struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh, int hdrlen)
250 {
251 unsigned char *data = nlmsg_data(nlh);
252 return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
253 }
254
255 /**
256 * length of attributes data
257 * @arg nlh netlink message header
258 * @arg hdrlen length of family specific header
259 */
nlmsg_attrlen(const struct nlmsghdr * nlh,int hdrlen)260 int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
261 {
262 return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
263 }
264
265 /** @} */
266
267 /**
268 * @name Message Parsing
269 * @{
270 */
271
nlmsg_valid_hdr(const struct nlmsghdr * nlh,int hdrlen)272 int nlmsg_valid_hdr(const struct nlmsghdr *nlh, int hdrlen)
273 {
274 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
275 return 0;
276
277 return 1;
278 }
279
280 /**
281 * check if the netlink message fits into the remaining bytes
282 * @arg nlh netlink message header
283 * @arg remaining number of bytes remaining in message stream
284 */
nlmsg_ok(const struct nlmsghdr * nlh,int remaining)285 int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
286 {
287 return (remaining >= (int)sizeof(struct nlmsghdr) &&
288 nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
289 nlh->nlmsg_len <= remaining);
290 }
291
292 /**
293 * next netlink message in message stream
294 * @arg nlh netlink message header
295 * @arg remaining number of bytes remaining in message stream
296 *
297 * @returns the next netlink message in the message stream and
298 * decrements remaining by the size of the current message.
299 */
nlmsg_next(struct nlmsghdr * nlh,int * remaining)300 struct nlmsghdr *nlmsg_next(struct nlmsghdr *nlh, int *remaining)
301 {
302 int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
303
304 *remaining -= totlen;
305
306 return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
307 }
308
309 /**
310 * parse attributes of a netlink message
311 * @arg nlh netlink message header
312 * @arg hdrlen length of family specific header
313 * @arg tb destination array with maxtype+1 elements
314 * @arg maxtype maximum attribute type to be expected
315 * @arg policy validation policy
316 *
317 * See nla_parse()
318 */
nlmsg_parse(struct nlmsghdr * nlh,int hdrlen,struct nlattr * tb[],int maxtype,struct nla_policy * policy)319 int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[],
320 int maxtype, struct nla_policy *policy)
321 {
322 if (!nlmsg_valid_hdr(nlh, hdrlen))
323 return -NLE_MSG_TOOSHORT;
324
325 return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
326 nlmsg_attrlen(nlh, hdrlen), policy);
327 }
328
329 /**
330 * nlmsg_find_attr - find a specific attribute in a netlink message
331 * @arg nlh netlink message header
332 * @arg hdrlen length of familiy specific header
333 * @arg attrtype type of attribute to look for
334 *
335 * Returns the first attribute which matches the specified type.
336 */
nlmsg_find_attr(struct nlmsghdr * nlh,int hdrlen,int attrtype)337 struct nlattr *nlmsg_find_attr(struct nlmsghdr *nlh, int hdrlen, int attrtype)
338 {
339 return nla_find(nlmsg_attrdata(nlh, hdrlen),
340 nlmsg_attrlen(nlh, hdrlen), attrtype);
341 }
342
343 /**
344 * nlmsg_validate - validate a netlink message including attributes
345 * @arg nlh netlinket message header
346 * @arg hdrlen length of familiy specific header
347 * @arg maxtype maximum attribute type to be expected
348 * @arg policy validation policy
349 */
nlmsg_validate(struct nlmsghdr * nlh,int hdrlen,int maxtype,struct nla_policy * policy)350 int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
351 struct nla_policy *policy)
352 {
353 if (!nlmsg_valid_hdr(nlh, hdrlen))
354 return -NLE_MSG_TOOSHORT;
355
356 return nla_validate(nlmsg_attrdata(nlh, hdrlen),
357 nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
358 }
359
360 /** @} */
361
362 /**
363 * @name Message Building/Access
364 * @{
365 */
366
__nlmsg_alloc(size_t len)367 static struct nl_msg *__nlmsg_alloc(size_t len)
368 {
369 struct nl_msg *nm;
370
371 nm = calloc(1, sizeof(*nm));
372 if (!nm)
373 goto errout;
374
375 nm->nm_refcnt = 1;
376
377 nm->nm_nlh = malloc(len);
378 if (!nm->nm_nlh)
379 goto errout;
380
381 memset(nm->nm_nlh, 0, sizeof(struct nlmsghdr));
382
383 nm->nm_protocol = -1;
384 nm->nm_size = len;
385 nm->nm_nlh->nlmsg_len = nlmsg_total_size(0);
386
387 NL_DBG(2, "msg %p: Allocated new message, maxlen=%zu\n", nm, len);
388
389 return nm;
390 errout:
391 free(nm);
392 return NULL;
393 }
394
395 /**
396 * Allocate a new netlink message with the default maximum payload size.
397 *
398 * Allocates a new netlink message without any further payload. The
399 * maximum payload size defaults to PAGESIZE or as otherwise specified
400 * with nlmsg_set_default_size().
401 *
402 * @return Newly allocated netlink message or NULL.
403 */
nlmsg_alloc(void)404 struct nl_msg *nlmsg_alloc(void)
405 {
406 return __nlmsg_alloc(default_msg_size);
407 }
408
409 /**
410 * Allocate a new netlink message with maximum payload size specified.
411 */
nlmsg_alloc_size(size_t max)412 struct nl_msg *nlmsg_alloc_size(size_t max)
413 {
414 return __nlmsg_alloc(max);
415 }
416
417 /**
418 * Allocate a new netlink message and inherit netlink message header
419 * @arg hdr Netlink message header template
420 *
421 * Allocates a new netlink message and inherits the original message
422 * header. If \a hdr is not NULL it will be used as a template for
423 * the netlink message header, otherwise the header is left blank.
424 *
425 * @return Newly allocated netlink message or NULL
426 */
nlmsg_inherit(struct nlmsghdr * hdr)427 struct nl_msg *nlmsg_inherit(struct nlmsghdr *hdr)
428 {
429 struct nl_msg *nm;
430
431 nm = nlmsg_alloc();
432 if (nm && hdr) {
433 struct nlmsghdr *new = nm->nm_nlh;
434
435 new->nlmsg_type = hdr->nlmsg_type;
436 new->nlmsg_flags = hdr->nlmsg_flags;
437 new->nlmsg_seq = hdr->nlmsg_seq;
438 new->nlmsg_pid = hdr->nlmsg_pid;
439 }
440
441 return nm;
442 }
443
444 /**
445 * Allocate a new netlink message
446 * @arg nlmsgtype Netlink message type
447 * @arg flags Message flags.
448 *
449 * @return Newly allocated netlink message or NULL.
450 */
nlmsg_alloc_simple(int nlmsgtype,int flags)451 struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags)
452 {
453 struct nl_msg *msg;
454 struct nlmsghdr nlh = {
455 .nlmsg_type = nlmsgtype,
456 .nlmsg_flags = flags,
457 };
458
459 msg = nlmsg_inherit(&nlh);
460 if (msg)
461 NL_DBG(2, "msg %p: Allocated new simple message\n", msg);
462
463 return msg;
464 }
465
466 /**
467 * Set the default maximum message payload size for allocated messages
468 * @arg max Size of payload in bytes.
469 */
nlmsg_set_default_size(size_t max)470 void nlmsg_set_default_size(size_t max)
471 {
472 if (max < nlmsg_total_size(0))
473 max = nlmsg_total_size(0);
474
475 default_msg_size = max;
476 }
477
478 /**
479 * Convert a netlink message received from a netlink socket to a nl_msg
480 * @arg hdr Netlink message received from netlink socket.
481 *
482 * Allocates a new netlink message and copies all of the data pointed to
483 * by \a hdr into the new message object.
484 *
485 * @return Newly allocated netlink message or NULL.
486 */
nlmsg_convert(struct nlmsghdr * hdr)487 struct nl_msg *nlmsg_convert(struct nlmsghdr *hdr)
488 {
489 struct nl_msg *nm;
490
491 nm = __nlmsg_alloc(NLMSG_ALIGN(hdr->nlmsg_len));
492 if (!nm)
493 goto errout;
494
495 memcpy(nm->nm_nlh, hdr, hdr->nlmsg_len);
496
497 return nm;
498 errout:
499 nlmsg_free(nm);
500 return NULL;
501 }
502
503 /**
504 * Reserve room for additional data in a netlink message
505 * @arg n netlink message
506 * @arg len length of additional data to reserve room for
507 * @arg pad number of bytes to align data to
508 *
509 * Reserves room for additional data at the tail of the an
510 * existing netlink message. Eventual padding required will
511 * be zeroed out.
512 *
513 * @return Pointer to start of additional data tailroom or NULL.
514 */
nlmsg_reserve(struct nl_msg * n,size_t len,int pad)515 void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad)
516 {
517 void *buf = n->nm_nlh;
518 size_t nlmsg_len = n->nm_nlh->nlmsg_len;
519 size_t tlen;
520
521 if (len > n->nm_size)
522 return NULL;
523
524 tlen = pad ? ((len + (pad - 1)) & ~(pad - 1)) : len;
525
526 if ((tlen + nlmsg_len) > n->nm_size)
527 return NULL;
528
529 buf += nlmsg_len;
530 n->nm_nlh->nlmsg_len += tlen;
531
532 if (tlen > len)
533 memset(buf + len, 0, tlen - len);
534
535 NL_DBG(2, "msg %p: Reserved %zu bytes, pad=%d, nlmsg_len=%d\n",
536 n, len, pad, n->nm_nlh->nlmsg_len);
537
538 return buf;
539 }
540
541 /**
542 * Append data to tail of a netlink message
543 * @arg n netlink message
544 * @arg data data to add
545 * @arg len length of data
546 * @arg pad Number of bytes to align data to.
547 *
548 * Extends the netlink message as needed and appends the data of given
549 * length to the message.
550 *
551 * @return 0 on success or a negative error code
552 */
nlmsg_append(struct nl_msg * n,void * data,size_t len,int pad)553 int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
554 {
555 void *tmp;
556
557 tmp = nlmsg_reserve(n, len, pad);
558 if (tmp == NULL)
559 return -NLE_NOMEM;
560
561 memcpy(tmp, data, len);
562 NL_DBG(2, "msg %p: Appended %zu bytes with padding %d\n", n, len, pad);
563
564 return 0;
565 }
566
567 /**
568 * Expand maximum payload size of a netlink message
569 * @arg n Netlink message.
570 * @arg newlen New maximum payload size.
571 *
572 * Reallocates the payload section of a netlink message and increases
573 * the maximum payload size of the message.
574 *
575 * @note Any pointers pointing to old payload block will be stale and
576 * need to be refetched. Therfore, do not expand while constructing
577 * nested attributes or while reserved data blocks are held.
578 *
579 * @return 0 on success or a negative error code.
580 */
nlmsg_expand(struct nl_msg * n,size_t newlen)581 int nlmsg_expand(struct nl_msg *n, size_t newlen)
582 {
583 void *tmp;
584
585 if (newlen <= n->nm_size)
586 return -NLE_INVAL;
587
588 tmp = realloc(n->nm_nlh, newlen);
589 if (tmp == NULL)
590 return -NLE_NOMEM;
591
592 n->nm_nlh = tmp;
593 n->nm_size = newlen;
594
595 return 0;
596 }
597
598 /**
599 * Add a netlink message header to a netlink message
600 * @arg n netlink message
601 * @arg pid netlink process id or NL_AUTO_PID
602 * @arg seq sequence number of message or NL_AUTO_SEQ
603 * @arg type message type
604 * @arg payload length of message payload
605 * @arg flags message flags
606 *
607 * Adds or overwrites the netlink message header in an existing message
608 * object. If \a payload is greater-than zero additional room will be
609 * reserved, f.e. for family specific headers. It can be accesed via
610 * nlmsg_data().
611 *
612 * @return A pointer to the netlink message header or NULL.
613 */
nlmsg_put(struct nl_msg * n,uint32_t pid,uint32_t seq,int type,int payload,int flags)614 struct nlmsghdr *nlmsg_put(struct nl_msg *n, uint32_t pid, uint32_t seq,
615 int type, int payload, int flags)
616 {
617 struct nlmsghdr *nlh;
618
619 if (n->nm_nlh->nlmsg_len < NLMSG_HDRLEN)
620 BUG();
621
622 nlh = (struct nlmsghdr *) n->nm_nlh;
623 nlh->nlmsg_type = type;
624 nlh->nlmsg_flags = flags;
625 nlh->nlmsg_pid = pid;
626 nlh->nlmsg_seq = seq;
627
628 NL_DBG(2, "msg %p: Added netlink header type=%d, flags=%d, pid=%d, "
629 "seq=%d\n", n, type, flags, pid, seq);
630
631 if (payload > 0 &&
632 nlmsg_reserve(n, payload, NLMSG_ALIGNTO) == NULL)
633 return NULL;
634
635 return nlh;
636 }
637
638 /**
639 * Return actual netlink message
640 * @arg n netlink message
641 *
642 * Returns the actual netlink message casted to the type of the netlink
643 * message header.
644 *
645 * @return A pointer to the netlink message.
646 */
nlmsg_hdr(struct nl_msg * n)647 struct nlmsghdr *nlmsg_hdr(struct nl_msg *n)
648 {
649 return n->nm_nlh;
650 }
651
652 /**
653 * Acquire a reference on a netlink message
654 * @arg msg message to acquire reference from
655 */
nlmsg_get(struct nl_msg * msg)656 void nlmsg_get(struct nl_msg *msg)
657 {
658 msg->nm_refcnt++;
659 NL_DBG(4, "New reference to message %p, total %d\n",
660 msg, msg->nm_refcnt);
661 }
662
663 /**
664 * Release a reference from an netlink message
665 * @arg msg message to release reference from
666 *
667 * Frees memory after the last reference has been released.
668 */
nlmsg_free(struct nl_msg * msg)669 void nlmsg_free(struct nl_msg *msg)
670 {
671 if (!msg)
672 return;
673
674 msg->nm_refcnt--;
675 NL_DBG(4, "Returned message reference %p, %d remaining\n",
676 msg, msg->nm_refcnt);
677
678 if (msg->nm_refcnt < 0)
679 BUG();
680
681 if (msg->nm_refcnt <= 0) {
682 free(msg->nm_nlh);
683 free(msg);
684 NL_DBG(2, "msg %p: Freed\n", msg);
685 }
686 }
687
688 /** @} */
689
690 /**
691 * @name Attributes
692 * @{
693 */
694
nlmsg_set_proto(struct nl_msg * msg,int protocol)695 void nlmsg_set_proto(struct nl_msg *msg, int protocol)
696 {
697 msg->nm_protocol = protocol;
698 }
699
nlmsg_get_proto(struct nl_msg * msg)700 int nlmsg_get_proto(struct nl_msg *msg)
701 {
702 return msg->nm_protocol;
703 }
704
nlmsg_get_max_size(struct nl_msg * msg)705 size_t nlmsg_get_max_size(struct nl_msg *msg)
706 {
707 return msg->nm_size;
708 }
709
nlmsg_set_src(struct nl_msg * msg,struct sockaddr_nl * addr)710 void nlmsg_set_src(struct nl_msg *msg, struct sockaddr_nl *addr)
711 {
712 memcpy(&msg->nm_src, addr, sizeof(*addr));
713 }
714
nlmsg_get_src(struct nl_msg * msg)715 struct sockaddr_nl *nlmsg_get_src(struct nl_msg *msg)
716 {
717 return &msg->nm_src;
718 }
719
nlmsg_set_dst(struct nl_msg * msg,struct sockaddr_nl * addr)720 void nlmsg_set_dst(struct nl_msg *msg, struct sockaddr_nl *addr)
721 {
722 memcpy(&msg->nm_dst, addr, sizeof(*addr));
723 }
724
nlmsg_get_dst(struct nl_msg * msg)725 struct sockaddr_nl *nlmsg_get_dst(struct nl_msg *msg)
726 {
727 return &msg->nm_dst;
728 }
729
nlmsg_set_creds(struct nl_msg * msg,struct ucred * creds)730 void nlmsg_set_creds(struct nl_msg *msg, struct ucred *creds)
731 {
732 memcpy(&msg->nm_creds, creds, sizeof(*creds));
733 msg->nm_flags |= NL_MSG_CRED_PRESENT;
734 }
735
nlmsg_get_creds(struct nl_msg * msg)736 struct ucred *nlmsg_get_creds(struct nl_msg *msg)
737 {
738 if (msg->nm_flags & NL_MSG_CRED_PRESENT)
739 return &msg->nm_creds;
740 return NULL;
741 }
742
743 /** @} */
744
745 /**
746 * @name Netlink Message Type Translations
747 * @{
748 */
749
750 static struct trans_tbl nl_msgtypes[] = {
751 __ADD(NLMSG_NOOP,NOOP)
752 __ADD(NLMSG_ERROR,ERROR)
753 __ADD(NLMSG_DONE,DONE)
754 __ADD(NLMSG_OVERRUN,OVERRUN)
755 };
756
nl_nlmsgtype2str(int type,char * buf,size_t size)757 char *nl_nlmsgtype2str(int type, char *buf, size_t size)
758 {
759 return __type2str(type, buf, size, nl_msgtypes,
760 ARRAY_SIZE(nl_msgtypes));
761 }
762
nl_str2nlmsgtype(const char * name)763 int nl_str2nlmsgtype(const char *name)
764 {
765 return __str2type(name, nl_msgtypes, ARRAY_SIZE(nl_msgtypes));
766 }
767
768 /** @} */
769
770 /**
771 * @name Netlink Message Flags Translations
772 * @{
773 */
774
nl_nlmsg_flags2str(int flags,char * buf,size_t len)775 char *nl_nlmsg_flags2str(int flags, char *buf, size_t len)
776 {
777 memset(buf, 0, len);
778
779 #define PRINT_FLAG(f) \
780 if (flags & NLM_F_##f) { \
781 flags &= ~NLM_F_##f; \
782 strncat(buf, #f, len - strlen(buf) - 1); \
783 if (flags) \
784 strncat(buf, ",", len - strlen(buf) - 1); \
785 }
786
787 PRINT_FLAG(REQUEST);
788 PRINT_FLAG(MULTI);
789 PRINT_FLAG(ACK);
790 PRINT_FLAG(ECHO);
791 PRINT_FLAG(ROOT);
792 PRINT_FLAG(MATCH);
793 PRINT_FLAG(ATOMIC);
794 PRINT_FLAG(REPLACE);
795 PRINT_FLAG(EXCL);
796 PRINT_FLAG(CREATE);
797 PRINT_FLAG(APPEND);
798
799 if (flags) {
800 char s[32];
801 snprintf(s, sizeof(s), "0x%x", flags);
802 strncat(buf, s, len - strlen(buf) - 1);
803 }
804 #undef PRINT_FLAG
805
806 return buf;
807 }
808
809 /** @} */
810
811 /**
812 * @name Direct Parsing
813 * @{
814 */
815
816 /** @cond SKIP */
817 struct dp_xdata {
818 void (*cb)(struct nl_object *, void *);
819 void *arg;
820 };
821 /** @endcond */
822
parse_cb(struct nl_object * obj,struct nl_parser_param * p)823 static int parse_cb(struct nl_object *obj, struct nl_parser_param *p)
824 {
825 struct dp_xdata *x = p->pp_arg;
826
827 x->cb(obj, x->arg);
828 return 0;
829 }
830
nl_msg_parse(struct nl_msg * msg,void (* cb)(struct nl_object *,void *),void * arg)831 int nl_msg_parse(struct nl_msg *msg, void (*cb)(struct nl_object *, void *),
832 void *arg)
833 {
834 struct nl_cache_ops *ops;
835 struct nl_parser_param p = {
836 .pp_cb = parse_cb
837 };
838 struct dp_xdata x = {
839 .cb = cb,
840 .arg = arg,
841 };
842
843 ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
844 nlmsg_hdr(msg)->nlmsg_type);
845 if (ops == NULL)
846 return -NLE_MSGTYPE_NOSUPPORT;
847 p.pp_arg = &x;
848
849 return nl_cache_parse(ops, NULL, nlmsg_hdr(msg), &p);
850 }
851
852 /** @} */
853
854 /**
855 * @name Dumping
856 * @{
857 */
858
prefix_line(FILE * ofd,int prefix)859 static void prefix_line(FILE *ofd, int prefix)
860 {
861 int i;
862
863 for (i = 0; i < prefix; i++)
864 fprintf(ofd, " ");
865 }
866
dump_hex(FILE * ofd,char * start,int len,int prefix)867 static inline void dump_hex(FILE *ofd, char *start, int len, int prefix)
868 {
869 int i, a, c, limit;
870 char ascii[21] = {0};
871
872 limit = 18 - (prefix * 2);
873 prefix_line(ofd, prefix);
874 fprintf(ofd, " ");
875
876 for (i = 0, a = 0, c = 0; i < len; i++) {
877 int v = *(uint8_t *) (start + i);
878
879 fprintf(ofd, "%02x ", v);
880 ascii[a++] = isprint(v) ? v : '.';
881
882 if (c == limit-1) {
883 fprintf(ofd, "%s\n", ascii);
884 if (i < (len - 1)) {
885 prefix_line(ofd, prefix);
886 fprintf(ofd, " ");
887 }
888 a = c = 0;
889 memset(ascii, 0, sizeof(ascii));
890 } else
891 c++;
892 }
893
894 if (c != 0) {
895 for (i = 0; i < (limit - c); i++)
896 fprintf(ofd, " ");
897 fprintf(ofd, "%s\n", ascii);
898 }
899 }
900
print_hdr(FILE * ofd,struct nl_msg * msg)901 static void print_hdr(FILE *ofd, struct nl_msg *msg)
902 {
903 struct nlmsghdr *nlh = nlmsg_hdr(msg);
904 struct nl_cache_ops *ops;
905 struct nl_msgtype *mt;
906 char buf[128];
907
908 fprintf(ofd, " .nlmsg_len = %d\n", nlh->nlmsg_len);
909
910 ops = nl_cache_ops_associate(nlmsg_get_proto(msg), nlh->nlmsg_type);
911 if (ops) {
912 mt = nl_msgtype_lookup(ops, nlh->nlmsg_type);
913 if (!mt)
914 BUG();
915
916 snprintf(buf, sizeof(buf), "%s::%s", ops->co_name, mt->mt_name);
917 } else
918 nl_nlmsgtype2str(nlh->nlmsg_type, buf, sizeof(buf));
919
920 fprintf(ofd, " .nlmsg_type = %d <%s>\n", nlh->nlmsg_type, buf);
921 fprintf(ofd, " .nlmsg_flags = %d <%s>\n", nlh->nlmsg_flags,
922 nl_nlmsg_flags2str(nlh->nlmsg_flags, buf, sizeof(buf)));
923 fprintf(ofd, " .nlmsg_seq = %d\n", nlh->nlmsg_seq);
924 fprintf(ofd, " .nlmsg_pid = %d\n", nlh->nlmsg_pid);
925
926 }
927
dump_attrs(FILE * ofd,struct nlattr * attrs,int attrlen,int prefix)928 static void dump_attrs(FILE *ofd, struct nlattr *attrs, int attrlen,
929 int prefix)
930 {
931 int rem;
932 struct nlattr *nla;
933
934 nla_for_each_attr(nla, attrs, attrlen, rem) {
935 int padlen, alen = nla_len(nla);
936
937 prefix_line(ofd, prefix);
938 fprintf(ofd, " [ATTR %02d%s] %d octets\n", nla_type(nla),
939 nla->nla_type & NLA_F_NESTED ? " NESTED" : "",
940 alen);
941
942 if (nla->nla_type & NLA_F_NESTED)
943 dump_attrs(ofd, nla_data(nla), alen, prefix+1);
944 else
945 dump_hex(ofd, nla_data(nla), alen, prefix);
946
947 padlen = nla_padlen(alen);
948 if (padlen > 0) {
949 prefix_line(ofd, prefix);
950 fprintf(ofd, " [PADDING] %d octets\n",
951 padlen);
952 dump_hex(ofd, nla_data(nla) + alen,
953 padlen, prefix);
954 }
955 }
956
957 if (rem) {
958 prefix_line(ofd, prefix);
959 fprintf(ofd, " [LEFTOVER] %d octets\n", rem);
960 }
961 }
962
963 /**
964 * Dump message in human readable format to file descriptor
965 * @arg msg Message to print
966 * @arg ofd File descriptor.
967 */
nl_msg_dump(struct nl_msg * msg,FILE * ofd)968 void nl_msg_dump(struct nl_msg *msg, FILE *ofd)
969 {
970 struct nlmsghdr *hdr = nlmsg_hdr(msg);
971
972 fprintf(ofd,
973 "-------------------------- BEGIN NETLINK MESSAGE "
974 "---------------------------\n");
975
976 fprintf(ofd, " [HEADER] %Zu octets\n", sizeof(struct nlmsghdr));
977 print_hdr(ofd, msg);
978
979 if (hdr->nlmsg_type == NLMSG_ERROR &&
980 hdr->nlmsg_len >= nlmsg_msg_size(sizeof(struct nlmsgerr))) {
981 struct nl_msg *errmsg;
982 struct nlmsgerr *err = nlmsg_data(hdr);
983
984 fprintf(ofd, " [ERRORMSG] %Zu octets\n", sizeof(*err));
985 fprintf(ofd, " .error = %d \"%s\"\n", err->error,
986 strerror(-err->error));
987 fprintf(ofd, " [ORIGINAL MESSAGE] %Zu octets\n", sizeof(*hdr));
988
989 errmsg = nlmsg_inherit(&err->msg);
990 print_hdr(ofd, errmsg);
991 nlmsg_free(errmsg);
992 } else if (nlmsg_len(hdr) > 0) {
993 struct nl_cache_ops *ops;
994 int payloadlen = nlmsg_len(hdr);
995 int attrlen = 0;
996
997 ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
998 hdr->nlmsg_type);
999 if (ops) {
1000 attrlen = nlmsg_attrlen(hdr, ops->co_hdrsize);
1001 payloadlen -= attrlen;
1002 }
1003
1004 fprintf(ofd, " [PAYLOAD] %d octets\n", payloadlen);
1005 dump_hex(ofd, nlmsg_data(hdr), payloadlen, 0);
1006
1007 if (attrlen) {
1008 struct nlattr *attrs;
1009 int attrlen;
1010
1011 attrs = nlmsg_attrdata(hdr, ops->co_hdrsize);
1012 attrlen = nlmsg_attrlen(hdr, ops->co_hdrsize);
1013 dump_attrs(ofd, attrs, attrlen, 0);
1014 }
1015 }
1016
1017 fprintf(ofd,
1018 "--------------------------- END NETLINK MESSAGE "
1019 "---------------------------\n");
1020 }
1021
1022 /** @} */
1023
1024 /** @} */
1025