libnl  3.2.13
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-2012 Thomas Graf <tgraf@suug.ch>
10  */
11 
12 /**
13  * @ingroup core
14  * @defgroup msg Message Construction & Parsing
15  * Netlink Message Construction/Parsing Interface
16  *
17  * Related sections in the development guide:
18  * - @core_doc{_message_parsing_amp_construction,Message Parsing & Construction}
19  *
20  * @{
21  *
22  * Header
23  * ------
24  * ~~~~{.c}
25  * #include <netlink/msg.h>
26  * ~~~~
27  */
28 
29 #include <netlink-local.h>
30 #include <netlink/netlink.h>
31 #include <netlink/utils.h>
32 #include <netlink/cache.h>
33 #include <netlink/attr.h>
34 #include <linux/socket.h>
35 
36 static size_t default_msg_size;
37 
38 static void __init init_msg_size(void)
39 {
40  default_msg_size = getpagesize();
41 }
42 
43 /**
44  * @name Size Calculations
45  * @{
46  */
47 
48 /**
49  * Calculates size of netlink message based on payload length.
50  * @arg payload Length of payload
51  *
52  * @return size of netlink message without padding.
53  */
54 int nlmsg_size(int payload)
55 {
56  return NLMSG_HDRLEN + payload;
57 }
58 
59 static int nlmsg_msg_size(int payload)
60 {
61  return nlmsg_size(payload);
62 }
63 
64 /**
65  * Calculates size of netlink message including padding based on payload length
66  * @arg payload Length of payload
67  *
68  * This function is idential to nlmsg_size() + nlmsg_padlen().
69  *
70  * @return Size of netlink message including padding.
71  */
72 int nlmsg_total_size(int payload)
73 {
74  return NLMSG_ALIGN(nlmsg_msg_size(payload));
75 }
76 
77 /**
78  * Size of padding that needs to be added at end of message
79  * @arg payload Length of payload
80  *
81  * Calculates the number of bytes of padding which is required to be added to
82  * the end of the message to ensure that the next netlink message header begins
83  * properly aligned to NLMSG_ALIGNTO.
84  *
85  * @return Number of bytes of padding needed.
86  */
87 int nlmsg_padlen(int payload)
88 {
89  return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
90 }
91 
92 /** @} */
93 
94 /**
95  * @name Access to Message Payload
96  * @{
97  */
98 
99 /**
100  * Return pointer to message payload
101  * @arg nlh Netlink message header
102  *
103  * @return Pointer to start of message payload.
104  */
105 void *nlmsg_data(const struct nlmsghdr *nlh)
106 {
107  return (unsigned char *) nlh + NLMSG_HDRLEN;
108 }
109 
110 void *nlmsg_tail(const struct nlmsghdr *nlh)
111 {
112  return (unsigned char *) nlh + NLMSG_ALIGN(nlh->nlmsg_len);
113 }
114 
115 /**
116  * Return length of message payload
117  * @arg nlh Netlink message header
118  *
119  * @return Length of message payload in bytes.
120  */
121 int nlmsg_datalen(const struct nlmsghdr *nlh)
122 {
123  return nlh->nlmsg_len - NLMSG_HDRLEN;
124 }
125 
126 static int nlmsg_len(const struct nlmsghdr *nlh)
127 {
128  return nlmsg_datalen(nlh);
129 }
130 
131 /** @} */
132 
133 /**
134  * @name Attribute Access
135  * @{
136  */
137 
138 /**
139  * head of attributes data
140  * @arg nlh netlink message header
141  * @arg hdrlen length of family specific header
142  */
143 struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh, int hdrlen)
144 {
145  unsigned char *data = nlmsg_data(nlh);
146  return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
147 }
148 
149 /**
150  * length of attributes data
151  * @arg nlh netlink message header
152  * @arg hdrlen length of family specific header
153  */
154 int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
155 {
156  return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
157 }
158 
159 /** @} */
160 
161 /**
162  * @name Message Parsing
163  * @{
164  */
165 
166 int nlmsg_valid_hdr(const struct nlmsghdr *nlh, int hdrlen)
167 {
168  if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
169  return 0;
170 
171  return 1;
172 }
173 
174 /**
175  * check if the netlink message fits into the remaining bytes
176  * @arg nlh netlink message header
177  * @arg remaining number of bytes remaining in message stream
178  */
179 int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
180 {
181  return (remaining >= sizeof(struct nlmsghdr) &&
182  nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
183  nlh->nlmsg_len <= remaining);
184 }
185 
186 /**
187  * next netlink message in message stream
188  * @arg nlh netlink message header
189  * @arg remaining number of bytes remaining in message stream
190  *
191  * @returns the next netlink message in the message stream and
192  * decrements remaining by the size of the current message.
193  */
194 struct nlmsghdr *nlmsg_next(struct nlmsghdr *nlh, int *remaining)
195 {
196  int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
197 
198  *remaining -= totlen;
199 
200  return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
201 }
202 
203 /**
204  * parse attributes of a netlink message
205  * @arg nlh netlink message header
206  * @arg hdrlen length of family specific header
207  * @arg tb destination array with maxtype+1 elements
208  * @arg maxtype maximum attribute type to be expected
209  * @arg policy validation policy
210  *
211  * See nla_parse()
212  */
213 int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[],
214  int maxtype, struct nla_policy *policy)
215 {
216  if (!nlmsg_valid_hdr(nlh, hdrlen))
217  return -NLE_MSG_TOOSHORT;
218 
219  return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
220  nlmsg_attrlen(nlh, hdrlen), policy);
221 }
222 
223 /**
224  * nlmsg_find_attr - find a specific attribute in a netlink message
225  * @arg nlh netlink message header
226  * @arg hdrlen length of familiy specific header
227  * @arg attrtype type of attribute to look for
228  *
229  * Returns the first attribute which matches the specified type.
230  */
231 struct nlattr *nlmsg_find_attr(struct nlmsghdr *nlh, int hdrlen, int attrtype)
232 {
233  return nla_find(nlmsg_attrdata(nlh, hdrlen),
234  nlmsg_attrlen(nlh, hdrlen), attrtype);
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  */
244 int 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 
261 static struct nl_msg *__nlmsg_alloc(size_t len)
262 {
263  struct nl_msg *nm;
264 
265  if (len < sizeof(struct nlmsghdr))
266  len = sizeof(struct nlmsghdr);
267 
268  nm = calloc(1, sizeof(*nm));
269  if (!nm)
270  goto errout;
271 
272  nm->nm_refcnt = 1;
273 
274  nm->nm_nlh = calloc(1, len);
275  if (!nm->nm_nlh)
276  goto errout;
277 
278  memset(nm->nm_nlh, 0, sizeof(struct nlmsghdr));
279 
280  nm->nm_protocol = -1;
281  nm->nm_size = len;
282  nm->nm_nlh->nlmsg_len = nlmsg_total_size(0);
283 
284  NL_DBG(2, "msg %p: Allocated new message, maxlen=%zu\n", nm, len);
285 
286  return nm;
287 errout:
288  free(nm);
289  return NULL;
290 }
291 
292 /**
293  * Allocate a new netlink message with the default maximum payload size.
294  *
295  * Allocates a new netlink message without any further payload. The
296  * maximum payload size defaults to PAGESIZE or as otherwise specified
297  * with nlmsg_set_default_size().
298  *
299  * @return Newly allocated netlink message or NULL.
300  */
301 struct nl_msg *nlmsg_alloc(void)
302 {
303  return __nlmsg_alloc(default_msg_size);
304 }
305 
306 /**
307  * Allocate a new netlink message with maximum payload size specified.
308  */
309 struct nl_msg *nlmsg_alloc_size(size_t max)
310 {
311  return __nlmsg_alloc(max);
312 }
313 
314 /**
315  * Allocate a new netlink message and inherit netlink message header
316  * @arg hdr Netlink message header template
317  *
318  * Allocates a new netlink message and inherits the original message
319  * header. If \a hdr is not NULL it will be used as a template for
320  * the netlink message header, otherwise the header is left blank.
321  *
322  * @return Newly allocated netlink message or NULL
323  */
324 struct nl_msg *nlmsg_inherit(struct nlmsghdr *hdr)
325 {
326  struct nl_msg *nm;
327 
328  nm = nlmsg_alloc();
329  if (nm && hdr) {
330  struct nlmsghdr *new = nm->nm_nlh;
331 
332  new->nlmsg_type = hdr->nlmsg_type;
333  new->nlmsg_flags = hdr->nlmsg_flags;
334  new->nlmsg_seq = hdr->nlmsg_seq;
335  new->nlmsg_pid = hdr->nlmsg_pid;
336  }
337 
338  return nm;
339 }
340 
341 /**
342  * Allocate a new netlink message
343  * @arg nlmsgtype Netlink message type
344  * @arg flags Message flags.
345  *
346  * @return Newly allocated netlink message or NULL.
347  */
348 struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags)
349 {
350  struct nl_msg *msg;
351  struct nlmsghdr nlh = {
352  .nlmsg_type = nlmsgtype,
353  .nlmsg_flags = flags,
354  };
355 
356  msg = nlmsg_inherit(&nlh);
357  if (msg)
358  NL_DBG(2, "msg %p: Allocated new simple message\n", msg);
359 
360  return msg;
361 }
362 
363 /**
364  * Set the default maximum message payload size for allocated messages
365  * @arg max Size of payload in bytes.
366  */
367 void nlmsg_set_default_size(size_t max)
368 {
369  if (max < nlmsg_total_size(0))
370  max = nlmsg_total_size(0);
371 
372  default_msg_size = max;
373 }
374 
375 /**
376  * Convert a netlink message received from a netlink socket to a nl_msg
377  * @arg hdr Netlink message received from netlink socket.
378  *
379  * Allocates a new netlink message and copies all of the data pointed to
380  * by \a hdr into the new message object.
381  *
382  * @return Newly allocated netlink message or NULL.
383  */
384 struct nl_msg *nlmsg_convert(struct nlmsghdr *hdr)
385 {
386  struct nl_msg *nm;
387 
388  nm = __nlmsg_alloc(NLMSG_ALIGN(hdr->nlmsg_len));
389  if (!nm)
390  goto errout;
391 
392  memcpy(nm->nm_nlh, hdr, hdr->nlmsg_len);
393 
394  return nm;
395 errout:
396  nlmsg_free(nm);
397  return NULL;
398 }
399 
400 /**
401  * Reserve room for additional data in a netlink message
402  * @arg n netlink message
403  * @arg len length of additional data to reserve room for
404  * @arg pad number of bytes to align data to
405  *
406  * Reserves room for additional data at the tail of the an
407  * existing netlink message. Eventual padding required will
408  * be zeroed out.
409  *
410  * @return Pointer to start of additional data tailroom or NULL.
411  */
412 void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad)
413 {
414  void *buf = n->nm_nlh;
415  size_t nlmsg_len = n->nm_nlh->nlmsg_len;
416  size_t tlen;
417 
418  tlen = pad ? ((len + (pad - 1)) & ~(pad - 1)) : len;
419 
420  if ((tlen + nlmsg_len) > n->nm_size)
421  return NULL;
422 
423  buf += nlmsg_len;
424  n->nm_nlh->nlmsg_len += tlen;
425 
426  if (tlen > len)
427  memset(buf + len, 0, tlen - len);
428 
429  NL_DBG(2, "msg %p: Reserved %zu (%zu) bytes, pad=%d, nlmsg_len=%d\n",
430  n, tlen, len, pad, n->nm_nlh->nlmsg_len);
431 
432  return buf;
433 }
434 
435 /**
436  * Append data to tail of a netlink message
437  * @arg n netlink message
438  * @arg data data to add
439  * @arg len length of data
440  * @arg pad Number of bytes to align data to.
441  *
442  * Extends the netlink message as needed and appends the data of given
443  * length to the message.
444  *
445  * @return 0 on success or a negative error code
446  */
447 int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
448 {
449  void *tmp;
450 
451  tmp = nlmsg_reserve(n, len, pad);
452  if (tmp == NULL)
453  return -NLE_NOMEM;
454 
455  memcpy(tmp, data, len);
456  NL_DBG(2, "msg %p: Appended %zu bytes with padding %d\n", n, len, pad);
457 
458  return 0;
459 }
460 
461 /**
462  * Expand maximum payload size of a netlink message
463  * @arg n Netlink message.
464  * @arg newlen New maximum payload size.
465  *
466  * Reallocates the payload section of a netlink message and increases
467  * the maximum payload size of the message.
468  *
469  * @note Any pointers pointing to old payload block will be stale and
470  * need to be refetched. Therfore, do not expand while constructing
471  * nested attributes or while reserved data blocks are held.
472  *
473  * @return 0 on success or a negative error code.
474  */
475 int nlmsg_expand(struct nl_msg *n, size_t newlen)
476 {
477  void *tmp;
478 
479  if (newlen <= n->nm_size)
480  return -NLE_INVAL;
481 
482  tmp = realloc(n->nm_nlh, newlen);
483  if (tmp == NULL)
484  return -NLE_NOMEM;
485 
486  n->nm_nlh = tmp;
487  n->nm_size = newlen;
488 
489  return 0;
490 }
491 
492 /**
493  * Add a netlink message header to a netlink message
494  * @arg n netlink message
495  * @arg pid netlink process id or NL_AUTO_PID
496  * @arg seq sequence number of message or NL_AUTO_SEQ
497  * @arg type message type
498  * @arg payload length of message payload
499  * @arg flags message flags
500  *
501  * Adds or overwrites the netlink message header in an existing message
502  * object. If \a payload is greater-than zero additional room will be
503  * reserved, f.e. for family specific headers. It can be accesed via
504  * nlmsg_data().
505  *
506  * @return A pointer to the netlink message header or NULL.
507  */
508 struct nlmsghdr *nlmsg_put(struct nl_msg *n, uint32_t pid, uint32_t seq,
509  int type, int payload, int flags)
510 {
511  struct nlmsghdr *nlh;
512 
513  if (n->nm_nlh->nlmsg_len < NLMSG_HDRLEN)
514  BUG();
515 
516  nlh = (struct nlmsghdr *) n->nm_nlh;
517  nlh->nlmsg_type = type;
518  nlh->nlmsg_flags = flags;
519  nlh->nlmsg_pid = pid;
520  nlh->nlmsg_seq = seq;
521 
522  NL_DBG(2, "msg %p: Added netlink header type=%d, flags=%d, pid=%d, "
523  "seq=%d\n", n, type, flags, pid, seq);
524 
525  if (payload > 0 &&
526  nlmsg_reserve(n, payload, NLMSG_ALIGNTO) == NULL)
527  return NULL;
528 
529  return nlh;
530 }
531 
532 /**
533  * Return actual netlink message
534  * @arg n netlink message
535  *
536  * Returns the actual netlink message casted to the type of the netlink
537  * message header.
538  *
539  * @return A pointer to the netlink message.
540  */
541 struct nlmsghdr *nlmsg_hdr(struct nl_msg *n)
542 {
543  return n->nm_nlh;
544 }
545 
546 /**
547  * Acquire a reference on a netlink message
548  * @arg msg message to acquire reference from
549  */
550 void nlmsg_get(struct nl_msg *msg)
551 {
552  msg->nm_refcnt++;
553  NL_DBG(4, "New reference to message %p, total %d\n",
554  msg, msg->nm_refcnt);
555 }
556 
557 /**
558  * Release a reference from an netlink message
559  * @arg msg message to release reference from
560  *
561  * Frees memory after the last reference has been released.
562  */
563 void nlmsg_free(struct nl_msg *msg)
564 {
565  if (!msg)
566  return;
567 
568  msg->nm_refcnt--;
569  NL_DBG(4, "Returned message reference %p, %d remaining\n",
570  msg, msg->nm_refcnt);
571 
572  if (msg->nm_refcnt < 0)
573  BUG();
574 
575  if (msg->nm_refcnt <= 0) {
576  free(msg->nm_nlh);
577  free(msg);
578  NL_DBG(2, "msg %p: Freed\n", msg);
579  }
580 }
581 
582 /** @} */
583 
584 /**
585  * @name Attributes
586  * @{
587  */
588 
589 void nlmsg_set_proto(struct nl_msg *msg, int protocol)
590 {
591  msg->nm_protocol = protocol;
592 }
593 
594 int nlmsg_get_proto(struct nl_msg *msg)
595 {
596  return msg->nm_protocol;
597 }
598 
599 size_t nlmsg_get_max_size(struct nl_msg *msg)
600 {
601  return msg->nm_size;
602 }
603 
604 void nlmsg_set_src(struct nl_msg *msg, struct sockaddr_nl *addr)
605 {
606  memcpy(&msg->nm_src, addr, sizeof(*addr));
607 }
608 
609 struct sockaddr_nl *nlmsg_get_src(struct nl_msg *msg)
610 {
611  return &msg->nm_src;
612 }
613 
614 void nlmsg_set_dst(struct nl_msg *msg, struct sockaddr_nl *addr)
615 {
616  memcpy(&msg->nm_dst, addr, sizeof(*addr));
617 }
618 
619 struct sockaddr_nl *nlmsg_get_dst(struct nl_msg *msg)
620 {
621  return &msg->nm_dst;
622 }
623 
624 void nlmsg_set_creds(struct nl_msg *msg, struct ucred *creds)
625 {
626  memcpy(&msg->nm_creds, creds, sizeof(*creds));
627  msg->nm_flags |= NL_MSG_CRED_PRESENT;
628 }
629 
630 struct ucred *nlmsg_get_creds(struct nl_msg *msg)
631 {
632  if (msg->nm_flags & NL_MSG_CRED_PRESENT)
633  return &msg->nm_creds;
634  return NULL;
635 }
636 
637 /** @} */
638 
639 /**
640  * @name Netlink Message Type Translations
641  * @{
642  */
643 
644 static const struct trans_tbl nl_msgtypes[] = {
645  __ADD(NLMSG_NOOP,NOOP)
646  __ADD(NLMSG_ERROR,ERROR)
647  __ADD(NLMSG_DONE,DONE)
648  __ADD(NLMSG_OVERRUN,OVERRUN)
649 };
650 
651 char *nl_nlmsgtype2str(int type, char *buf, size_t size)
652 {
653  return __type2str(type, buf, size, nl_msgtypes,
654  ARRAY_SIZE(nl_msgtypes));
655 }
656 
657 int nl_str2nlmsgtype(const char *name)
658 {
659  return __str2type(name, nl_msgtypes, ARRAY_SIZE(nl_msgtypes));
660 }
661 
662 /** @} */
663 
664 /**
665  * @name Netlink Message Flags Translations
666  * @{
667  */
668 
669 char *nl_nlmsg_flags2str(int flags, char *buf, size_t len)
670 {
671  memset(buf, 0, len);
672 
673 #define PRINT_FLAG(f) \
674  if (flags & NLM_F_##f) { \
675  flags &= ~NLM_F_##f; \
676  strncat(buf, #f, len - strlen(buf) - 1); \
677  if (flags) \
678  strncat(buf, ",", len - strlen(buf) - 1); \
679  }
680 
681  PRINT_FLAG(REQUEST);
682  PRINT_FLAG(MULTI);
683  PRINT_FLAG(ACK);
684  PRINT_FLAG(ECHO);
685  PRINT_FLAG(ROOT);
686  PRINT_FLAG(MATCH);
687  PRINT_FLAG(ATOMIC);
688  PRINT_FLAG(REPLACE);
689  PRINT_FLAG(EXCL);
690  PRINT_FLAG(CREATE);
691  PRINT_FLAG(APPEND);
692 
693  if (flags) {
694  char s[32];
695  snprintf(s, sizeof(s), "0x%x", flags);
696  strncat(buf, s, len - strlen(buf) - 1);
697  }
698 #undef PRINT_FLAG
699 
700  return buf;
701 }
702 
703 /** @} */
704 
705 /**
706  * @name Direct Parsing
707  * @{
708  */
709 
710 /** @cond SKIP */
711 struct dp_xdata {
712  void (*cb)(struct nl_object *, void *);
713  void *arg;
714 };
715 /** @endcond */
716 
717 static int parse_cb(struct nl_object *obj, struct nl_parser_param *p)
718 {
719  struct dp_xdata *x = p->pp_arg;
720 
721  x->cb(obj, x->arg);
722  return 0;
723 }
724 
725 int nl_msg_parse(struct nl_msg *msg, void (*cb)(struct nl_object *, void *),
726  void *arg)
727 {
728  struct nl_cache_ops *ops;
729  struct nl_parser_param p = {
730  .pp_cb = parse_cb
731  };
732  struct dp_xdata x = {
733  .cb = cb,
734  .arg = arg,
735  };
736 
737  ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
738  nlmsg_hdr(msg)->nlmsg_type);
739  if (ops == NULL)
740  return -NLE_MSGTYPE_NOSUPPORT;
741  p.pp_arg = &x;
742 
743  return nl_cache_parse(ops, NULL, nlmsg_hdr(msg), &p);
744 }
745 
746 /** @} */
747 
748 /**
749  * @name Dumping
750  * @{
751  */
752 
753 static void prefix_line(FILE *ofd, int prefix)
754 {
755  int i;
756 
757  for (i = 0; i < prefix; i++)
758  fprintf(ofd, " ");
759 }
760 
761 static inline void dump_hex(FILE *ofd, char *start, int len, int prefix)
762 {
763  int i, a, c, limit;
764  char ascii[21] = {0};
765 
766  limit = 18 - (prefix * 2);
767  prefix_line(ofd, prefix);
768  fprintf(ofd, " ");
769 
770  for (i = 0, a = 0, c = 0; i < len; i++) {
771  int v = *(uint8_t *) (start + i);
772 
773  fprintf(ofd, "%02x ", v);
774  ascii[a++] = isprint(v) ? v : '.';
775 
776  if (c == limit-1) {
777  fprintf(ofd, "%s\n", ascii);
778  if (i < (len - 1)) {
779  prefix_line(ofd, prefix);
780  fprintf(ofd, " ");
781  }
782  a = c = 0;
783  memset(ascii, 0, sizeof(ascii));
784  } else
785  c++;
786  }
787 
788  if (c != 0) {
789  for (i = 0; i < (limit - c); i++)
790  fprintf(ofd, " ");
791  fprintf(ofd, "%s\n", ascii);
792  }
793 }
794 
795 static void print_hdr(FILE *ofd, struct nl_msg *msg)
796 {
797  struct nlmsghdr *nlh = nlmsg_hdr(msg);
798  struct nl_cache_ops *ops;
799  struct nl_msgtype *mt;
800  char buf[128];
801 
802  fprintf(ofd, " .nlmsg_len = %d\n", nlh->nlmsg_len);
803 
804  ops = nl_cache_ops_associate(nlmsg_get_proto(msg), nlh->nlmsg_type);
805  if (ops) {
806  mt = nl_msgtype_lookup(ops, nlh->nlmsg_type);
807  if (!mt)
808  BUG();
809 
810  snprintf(buf, sizeof(buf), "%s::%s", ops->co_name, mt->mt_name);
811  } else
812  nl_nlmsgtype2str(nlh->nlmsg_type, buf, sizeof(buf));
813 
814  fprintf(ofd, " .nlmsg_type = %d <%s>\n", nlh->nlmsg_type, buf);
815  fprintf(ofd, " .nlmsg_flags = %d <%s>\n", nlh->nlmsg_flags,
816  nl_nlmsg_flags2str(nlh->nlmsg_flags, buf, sizeof(buf)));
817  fprintf(ofd, " .nlmsg_seq = %d\n", nlh->nlmsg_seq);
818  fprintf(ofd, " .nlmsg_pid = %d\n", nlh->nlmsg_pid);
819 
820 }
821 
822 static void dump_attrs(FILE *ofd, struct nlattr *attrs, int attrlen,
823  int prefix)
824 {
825  int rem;
826  struct nlattr *nla;
827 
828  nla_for_each_attr(nla, attrs, attrlen, rem) {
829  int padlen, alen = nla_len(nla);
830 
831  prefix_line(ofd, prefix);
832  fprintf(ofd, " [ATTR %02d%s] %d octets\n", nla_type(nla),
833  nla->nla_type & NLA_F_NESTED ? " NESTED" : "",
834  alen);
835 
836  if (nla->nla_type & NLA_F_NESTED)
837  dump_attrs(ofd, nla_data(nla), alen, prefix+1);
838  else
839  dump_hex(ofd, nla_data(nla), alen, prefix);
840 
841  padlen = nla_padlen(alen);
842  if (padlen > 0) {
843  prefix_line(ofd, prefix);
844  fprintf(ofd, " [PADDING] %d octets\n",
845  padlen);
846  dump_hex(ofd, nla_data(nla) + alen,
847  padlen, prefix);
848  }
849  }
850 
851  if (rem) {
852  prefix_line(ofd, prefix);
853  fprintf(ofd, " [LEFTOVER] %d octets\n", rem);
854  }
855 }
856 
857 /**
858  * Dump message in human readable format to file descriptor
859  * @arg msg Message to print
860  * @arg ofd File descriptor.
861  */
862 void nl_msg_dump(struct nl_msg *msg, FILE *ofd)
863 {
864  struct nlmsghdr *hdr = nlmsg_hdr(msg);
865 
866  fprintf(ofd,
867  "-------------------------- BEGIN NETLINK MESSAGE "
868  "---------------------------\n");
869 
870  fprintf(ofd, " [HEADER] %zu octets\n", sizeof(struct nlmsghdr));
871  print_hdr(ofd, msg);
872 
873  if (hdr->nlmsg_type == NLMSG_ERROR &&
874  hdr->nlmsg_len >= nlmsg_msg_size(sizeof(struct nlmsgerr))) {
875  struct nl_msg *errmsg;
876  struct nlmsgerr *err = nlmsg_data(hdr);
877 
878  fprintf(ofd, " [ERRORMSG] %zu octets\n", sizeof(*err));
879  fprintf(ofd, " .error = %d \"%s\"\n", err->error,
880  strerror(-err->error));
881  fprintf(ofd, " [ORIGINAL MESSAGE] %zu octets\n", sizeof(*hdr));
882 
883  errmsg = nlmsg_inherit(&err->msg);
884  print_hdr(ofd, errmsg);
885  nlmsg_free(errmsg);
886  } else if (nlmsg_len(hdr) > 0) {
887  struct nl_cache_ops *ops;
888  int payloadlen = nlmsg_len(hdr);
889  int attrlen = 0;
890 
891  ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
892  hdr->nlmsg_type);
893  if (ops) {
894  attrlen = nlmsg_attrlen(hdr, ops->co_hdrsize);
895  payloadlen -= attrlen;
896  }
897 
898  fprintf(ofd, " [PAYLOAD] %d octets\n", payloadlen);
899  dump_hex(ofd, nlmsg_data(hdr), payloadlen, 0);
900 
901  if (attrlen) {
902  struct nlattr *attrs;
903  int attrlen;
904 
905  attrs = nlmsg_attrdata(hdr, ops->co_hdrsize);
906  attrlen = nlmsg_attrlen(hdr, ops->co_hdrsize);
907  dump_attrs(ofd, attrs, attrlen, 0);
908  }
909  }
910 
911  fprintf(ofd,
912  "--------------------------- END NETLINK MESSAGE "
913  "---------------------------\n");
914 }
915 
916 /** @} */
917 
918 /** @} */