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