libnl  1.1
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-2006 Thomas Graf <tgraf@suug.ch>
10  */
11 
12 /**
13  * @ingroup nl
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 
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  */
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  */
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  */
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  */
218 void *nlmsg_data(const struct nlmsghdr *nlh)
219 {
220  return (unsigned char *) nlh + NLMSG_HDRLEN;
221 }
222 
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  */
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  */
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  */
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 
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  */
285 int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
286 {
287  return (remaining >= 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  */
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  */
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 nl_errno(EINVAL);
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  */
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  */
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 nl_errno(EINVAL);
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 
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_nlh = calloc(1, len);
376  if (!nm->nm_nlh)
377  goto errout;
378 
379  nm->nm_protocol = -1;
380  nm->nm_size = len;
381  nm->nm_nlh->nlmsg_len = nlmsg_total_size(0);
382 
383  NL_DBG(2, "msg %p: Allocated new message, maxlen=%zu\n", nm, len);
384 
385  return nm;
386 errout:
387  free(nm);
388  nl_errno(ENOMEM);
389  return NULL;
390 }
391 
392 /**
393  * Allocate a new netlink message with the default maximum payload size.
394  *
395  * Allocates a new netlink message without any further payload. The
396  * maximum payload size defaults to PAGESIZE or as otherwise specified
397  * with nlmsg_set_default_size().
398  *
399  * @return Newly allocated netlink message or NULL.
400  */
401 struct nl_msg *nlmsg_alloc(void)
402 {
403  return __nlmsg_alloc(default_msg_size);
404 }
405 
406 /**
407  * Allocate a new netlink message with maximum payload size specified.
408  */
409 struct nl_msg *nlmsg_alloc_size(size_t max)
410 {
411  return __nlmsg_alloc(max);
412 }
413 
414 /**
415  * Allocate a new netlink message and inherit netlink message header
416  * @arg hdr Netlink message header template
417  *
418  * Allocates a new netlink message and inherits the original message
419  * header. If \a hdr is not NULL it will be used as a template for
420  * the netlink message header, otherwise the header is left blank.
421  *
422  * @return Newly allocated netlink message or NULL
423  */
424 struct nl_msg *nlmsg_inherit(struct nlmsghdr *hdr)
425 {
426  struct nl_msg *nm;
427 
428  nm = nlmsg_alloc();
429  if (nm && hdr) {
430  struct nlmsghdr *new = nm->nm_nlh;
431 
432  new->nlmsg_type = hdr->nlmsg_type;
433  new->nlmsg_flags = hdr->nlmsg_flags;
434  new->nlmsg_seq = hdr->nlmsg_seq;
435  new->nlmsg_pid = hdr->nlmsg_pid;
436  }
437 
438  return nm;
439 }
440 
441 /**
442  * Allocate a new netlink message
443  * @arg nlmsgtype Netlink message type
444  * @arg flags Message flags.
445  *
446  * @return Newly allocated netlink message or NULL.
447  */
448 struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags)
449 {
450  struct nl_msg *msg;
451  struct nlmsghdr nlh = {
452  .nlmsg_type = nlmsgtype,
453  .nlmsg_flags = flags,
454  };
455 
456  msg = nlmsg_inherit(&nlh);
457  if (msg)
458  NL_DBG(2, "msg %p: Allocated new simple message\n", msg);
459 
460  return msg;
461 }
462 
463 /**
464  * Set the default maximum message payload size for allocated messages
465  * @arg max Size of payload in bytes.
466  */
467 void nlmsg_set_default_size(size_t max)
468 {
469  if (max < nlmsg_total_size(0))
470  max = nlmsg_total_size(0);
471 
472  default_msg_size = max;
473 }
474 
475 /**
476  * Convert a netlink message received from a netlink socket to a nl_msg
477  * @arg hdr Netlink message received from netlink socket.
478  *
479  * Allocates a new netlink message and copies all of the data pointed to
480  * by \a hdr into the new message object.
481  *
482  * @return Newly allocated netlink message or NULL.
483  */
484 struct nl_msg *nlmsg_convert(struct nlmsghdr *hdr)
485 {
486  struct nl_msg *nm;
487 
488  nm = __nlmsg_alloc(NLMSG_ALIGN(hdr->nlmsg_len));
489  if (!nm)
490  goto errout;
491 
492  memcpy(nm->nm_nlh, hdr, hdr->nlmsg_len);
493 
494  return nm;
495 errout:
496  nlmsg_free(nm);
497  return NULL;
498 }
499 
500 /**
501  * Reserve room for additional data in a netlink message
502  * @arg n netlink message
503  * @arg len length of additional data to reserve room for
504  * @arg pad number of bytes to align data to
505  *
506  * Reserves room for additional data at the tail of the an
507  * existing netlink message. Eventual padding required will
508  * be zeroed out.
509  *
510  * @return Pointer to start of additional data tailroom or NULL.
511  */
512 void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad)
513 {
514  void *buf = n->nm_nlh;
515  size_t nlmsg_len = n->nm_nlh->nlmsg_len;
516  size_t tlen;
517 
518  if (len > n->nm_size)
519  return NULL;
520 
521  tlen = pad ? ((len + (pad - 1)) & ~(pad - 1)) : len;
522 
523  if ((tlen + nlmsg_len) > n->nm_size) {
524  nl_errno(ENOBUFS);
525  return NULL;
526  }
527 
528  buf += nlmsg_len;
529  n->nm_nlh->nlmsg_len += tlen;
530 
531  if (tlen > len)
532  memset(buf + len, 0, tlen - len);
533 
534  NL_DBG(2, "msg %p: Reserved %zu bytes, pad=%d, nlmsg_len=%d\n",
535  n, len, pad, n->nm_nlh->nlmsg_len);
536 
537  return buf;
538 }
539 
540 /**
541  * Append data to tail of a netlink message
542  * @arg n netlink message
543  * @arg data data to add
544  * @arg len length of data
545  * @arg pad Number of bytes to align data to.
546  *
547  * Extends the netlink message as needed and appends the data of given
548  * length to the message.
549  *
550  * @return 0 on success or a negative error code
551  */
552 int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
553 {
554  void *tmp;
555 
556  tmp = nlmsg_reserve(n, len, pad);
557  if (tmp == NULL)
558  return nl_errno(ENOMEM);
559 
560  memcpy(tmp, data, len);
561  NL_DBG(2, "msg %p: Appended %zu bytes with padding %d\n", n, len, pad);
562 
563  return 0;
564 }
565 
566 /**
567  * Expand maximum payload size of a netlink message
568  * @arg n Netlink message.
569  * @arg newlen New maximum payload size.
570  *
571  * Reallocates the payload section of a netlink message and increases
572  * the maximum payload size of the message.
573  *
574  * @note Any pointers pointing to old payload block will be stale and
575  * need to be refetched. Therfore, do not expand while constructing
576  * nested attributes or while reserved data blocks are held.
577  *
578  * @return 0 on success or a negative error code.
579  */
580 int nlmsg_expand(struct nl_msg *n, size_t newlen)
581 {
582  void *tmp;
583 
584  if (newlen <= n->nm_size)
585  return nl_errno(EINVAL);
586 
587  tmp = realloc(n->nm_nlh, newlen);
588  if (tmp == NULL)
589  return nl_errno(ENOMEM);
590 
591  n->nm_nlh = tmp;
592  n->nm_size = newlen;
593 
594  return 0;
595 }
596 
597 /**
598  * Add a netlink message header to a netlink message
599  * @arg n netlink message
600  * @arg pid netlink process id or NL_AUTO_PID
601  * @arg seq sequence number of message or NL_AUTO_SEQ
602  * @arg type message type
603  * @arg payload length of message payload
604  * @arg flags message flags
605  *
606  * Adds or overwrites the netlink message header in an existing message
607  * object. If \a payload is greater-than zero additional room will be
608  * reserved, f.e. for family specific headers. It can be accesed via
609  * nlmsg_data().
610  *
611  * @return A pointer to the netlink message header or NULL.
612  */
613 struct nlmsghdr *nlmsg_put(struct nl_msg *n, uint32_t pid, uint32_t seq,
614  int type, int payload, int flags)
615 {
616  struct nlmsghdr *nlh;
617 
618  if (n->nm_nlh->nlmsg_len < NLMSG_HDRLEN)
619  BUG();
620 
621  nlh = (struct nlmsghdr *) n->nm_nlh;
622  nlh->nlmsg_type = type;
623  nlh->nlmsg_flags = flags;
624  nlh->nlmsg_pid = pid;
625  nlh->nlmsg_seq = seq;
626 
627  NL_DBG(2, "msg %p: Added netlink header type=%d, flags=%d, pid=%d, "
628  "seq=%d\n", n, type, flags, pid, seq);
629 
630  if (payload > 0 &&
631  nlmsg_reserve(n, payload, NLMSG_ALIGNTO) == NULL)
632  return NULL;
633 
634  return nlh;
635 }
636 
637 /**
638  * Return actual netlink message
639  * @arg n netlink message
640  *
641  * Returns the actual netlink message casted to the type of the netlink
642  * message header.
643  *
644  * @return A pointer to the netlink message.
645  */
646 struct nlmsghdr *nlmsg_hdr(struct nl_msg *n)
647 {
648  return n->nm_nlh;
649 }
650 
651 /**
652  * Free a netlink message
653  * @arg n netlink message
654  *
655  * Destroys a netlink message and frees up all used memory.
656  *
657  * @pre The message must be unused.
658  */
659 void nlmsg_free(struct nl_msg *n)
660 {
661  if (!n)
662  return;
663 
664  free(n->nm_nlh);
665  free(n);
666  NL_DBG(2, "msg %p: Freed\n", n);
667 }
668 
669 /** @} */
670 
671 /**
672  * @name Attributes
673  * @{
674  */
675 
676 void nlmsg_set_proto(struct nl_msg *msg, int protocol)
677 {
678  msg->nm_protocol = protocol;
679 }
680 
681 int nlmsg_get_proto(struct nl_msg *msg)
682 {
683  return msg->nm_protocol;
684 }
685 
686 size_t nlmsg_get_max_size(struct nl_msg *msg)
687 {
688  return msg->nm_size;
689 }
690 
691 void nlmsg_set_src(struct nl_msg *msg, struct sockaddr_nl *addr)
692 {
693  memcpy(&msg->nm_src, addr, sizeof(*addr));
694 }
695 
696 struct sockaddr_nl *nlmsg_get_src(struct nl_msg *msg)
697 {
698  return &msg->nm_src;
699 }
700 
701 void nlmsg_set_dst(struct nl_msg *msg, struct sockaddr_nl *addr)
702 {
703  memcpy(&msg->nm_dst, addr, sizeof(*addr));
704 }
705 
706 struct sockaddr_nl *nlmsg_get_dst(struct nl_msg *msg)
707 {
708  return &msg->nm_dst;
709 }
710 
711 void nlmsg_set_creds(struct nl_msg *msg, struct ucred *creds)
712 {
713  memcpy(&msg->nm_creds, creds, sizeof(*creds));
714  msg->nm_flags |= NL_MSG_CRED_PRESENT;
715 }
716 
717 struct ucred *nlmsg_get_creds(struct nl_msg *msg)
718 {
719  if (msg->nm_flags & NL_MSG_CRED_PRESENT)
720  return &msg->nm_creds;
721  return NULL;
722 }
723 
724 /** @} */
725 
726 /**
727  * @name Netlink Message Type Translations
728  * @{
729  */
730 
731 static struct trans_tbl nl_msgtypes[] = {
732  __ADD(NLMSG_NOOP,NOOP)
733  __ADD(NLMSG_ERROR,ERROR)
734  __ADD(NLMSG_DONE,DONE)
735  __ADD(NLMSG_OVERRUN,OVERRUN)
736 };
737 
738 char *nl_nlmsgtype2str(int type, char *buf, size_t size)
739 {
740  return __type2str(type, buf, size, nl_msgtypes,
741  ARRAY_SIZE(nl_msgtypes));
742 }
743 
744 int nl_str2nlmsgtype(const char *name)
745 {
746  return __str2type(name, nl_msgtypes, ARRAY_SIZE(nl_msgtypes));
747 }
748 
749 /** @} */
750 
751 /**
752  * @name Netlink Message Flags Translations
753  * @{
754  */
755 
756 char *nl_nlmsg_flags2str(int flags, char *buf, size_t len)
757 {
758  memset(buf, 0, len);
759 
760 #define PRINT_FLAG(f) \
761  if (flags & NLM_F_##f) { \
762  flags &= ~NLM_F_##f; \
763  strncat(buf, #f, len - strlen(buf) - 1); \
764  if (flags) \
765  strncat(buf, ",", len - strlen(buf) - 1); \
766  }
767 
768  PRINT_FLAG(REQUEST);
769  PRINT_FLAG(MULTI);
770  PRINT_FLAG(ACK);
771  PRINT_FLAG(ECHO);
772  PRINT_FLAG(ROOT);
773  PRINT_FLAG(MATCH);
774  PRINT_FLAG(ATOMIC);
775  PRINT_FLAG(REPLACE);
776  PRINT_FLAG(EXCL);
777  PRINT_FLAG(CREATE);
778  PRINT_FLAG(APPEND);
779 
780  if (flags) {
781  char s[32];
782  snprintf(s, sizeof(s), "0x%x", flags);
783  strncat(buf, s, len - strlen(buf) - 1);
784  }
785 #undef PRINT_FLAG
786 
787  return buf;
788 }
789 
790 /** @} */
791 
792 /**
793  * @name Direct Parsing
794  * @{
795  */
796 
797 /** @cond SKIP */
798 struct dp_xdata {
799  void (*cb)(struct nl_object *, void *);
800  void *arg;
801 };
802 /** @endcond */
803 
804 static int parse_cb(struct nl_object *obj, struct nl_parser_param *p)
805 {
806  struct dp_xdata *x = p->pp_arg;
807 
808  x->cb(obj, x->arg);
809  return 0;
810 }
811 
812 int nl_msg_parse(struct nl_msg *msg, void (*cb)(struct nl_object *, void *),
813  void *arg)
814 {
815  struct nl_cache_ops *ops;
816  struct nl_parser_param p = {
817  .pp_cb = parse_cb
818  };
819  struct dp_xdata x = {
820  .cb = cb,
821  .arg = arg,
822  };
823 
824  ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
825  nlmsg_hdr(msg)->nlmsg_type);
826  if (ops == NULL)
827  return nl_error(ENOENT, "Unknown message type %d",
828  nlmsg_hdr(msg)->nlmsg_type);
829  p.pp_arg = &x;
830 
831  return nl_cache_parse(ops, NULL, nlmsg_hdr(msg), &p);
832 }
833 
834 /** @} */
835 
836 /**
837  * @name Dumping
838  * @{
839  */
840 
841 static void prefix_line(FILE *ofd, int prefix)
842 {
843  int i;
844 
845  for (i = 0; i < prefix; i++)
846  fprintf(ofd, " ");
847 }
848 
849 static inline void dump_hex(FILE *ofd, char *start, int len, int prefix)
850 {
851  int i, a, c, limit;
852  char ascii[21] = {0};
853 
854  limit = 18 - (prefix * 2);
855  prefix_line(ofd, prefix);
856  fprintf(ofd, " ");
857 
858  for (i = 0, a = 0, c = 0; i < len; i++) {
859  int v = *(uint8_t *) (start + i);
860 
861  fprintf(ofd, "%02x ", v);
862  ascii[a++] = isprint(v) ? v : '.';
863 
864  if (c == limit-1) {
865  fprintf(ofd, "%s\n", ascii);
866  if (i < (len - 1)) {
867  prefix_line(ofd, prefix);
868  fprintf(ofd, " ");
869  }
870  a = c = 0;
871  memset(ascii, 0, sizeof(ascii));
872  } else
873  c++;
874  }
875 
876  if (c != 0) {
877  for (i = 0; i < (limit - c); i++)
878  fprintf(ofd, " ");
879  fprintf(ofd, "%s\n", ascii);
880  }
881 }
882 
883 static void print_hdr(FILE *ofd, struct nl_msg *msg)
884 {
885  struct nlmsghdr *nlh = nlmsg_hdr(msg);
886  struct nl_cache_ops *ops;
887  struct nl_msgtype *mt;
888  char buf[128];
889 
890  fprintf(ofd, " .nlmsg_len = %d\n", nlh->nlmsg_len);
891 
892  ops = nl_cache_ops_associate(nlmsg_get_proto(msg), nlh->nlmsg_type);
893  if (ops) {
894  mt = nl_msgtype_lookup(ops, nlh->nlmsg_type);
895  if (!mt)
896  BUG();
897 
898  snprintf(buf, sizeof(buf), "%s::%s", ops->co_name, mt->mt_name);
899  } else
900  nl_nlmsgtype2str(nlh->nlmsg_type, buf, sizeof(buf));
901 
902  fprintf(ofd, " .nlmsg_type = %d <%s>\n", nlh->nlmsg_type, buf);
903  fprintf(ofd, " .nlmsg_flags = %d <%s>\n", nlh->nlmsg_flags,
904  nl_nlmsg_flags2str(nlh->nlmsg_flags, buf, sizeof(buf)));
905  fprintf(ofd, " .nlmsg_seq = %d\n", nlh->nlmsg_seq);
906  fprintf(ofd, " .nlmsg_pid = %d\n", nlh->nlmsg_pid);
907 
908 }
909 
910 static void dump_attrs(FILE *ofd, struct nlattr *attrs, int attrlen,
911  int prefix)
912 {
913  int rem;
914  struct nlattr *nla;
915 
916  nla_for_each_attr(nla, attrs, attrlen, rem) {
917  int padlen, alen = nla_len(nla);
918 
919  prefix_line(ofd, prefix);
920  fprintf(ofd, " [ATTR %02d%s] %d octets\n", nla_type(nla),
921  nla->nla_type & NLA_F_NESTED ? " NESTED" : "",
922  alen);
923 
924  if (nla->nla_type & NLA_F_NESTED)
925  dump_attrs(ofd, nla_data(nla), alen, prefix+1);
926  else
927  dump_hex(ofd, nla_data(nla), alen, prefix);
928 
929  padlen = nla_padlen(alen);
930  if (padlen > 0) {
931  prefix_line(ofd, prefix);
932  fprintf(ofd, " [PADDING] %d octets\n",
933  padlen);
934  dump_hex(ofd, nla_data(nla) + alen,
935  padlen, prefix);
936  }
937  }
938 
939  if (rem) {
940  prefix_line(ofd, prefix);
941  fprintf(ofd, " [LEFTOVER] %d octets\n", rem);
942  }
943 }
944 
945 /**
946  * Dump message in human readable format to file descriptor
947  * @arg msg Message to print
948  * @arg ofd File descriptor.
949  */
950 void nl_msg_dump(struct nl_msg *msg, FILE *ofd)
951 {
952  struct nlmsghdr *hdr = nlmsg_hdr(msg);
953 
954  fprintf(ofd,
955  "-------------------------- BEGIN NETLINK MESSAGE "
956  "---------------------------\n");
957 
958  fprintf(ofd, " [HEADER] %Zu octets\n", sizeof(struct nlmsghdr));
959  print_hdr(ofd, msg);
960 
961  if (hdr->nlmsg_type == NLMSG_ERROR &&
962  hdr->nlmsg_len >= nlmsg_msg_size(sizeof(struct nlmsgerr))) {
963  struct nl_msg *errmsg;
964  struct nlmsgerr *err = nlmsg_data(hdr);
965 
966  fprintf(ofd, " [ERRORMSG] %Zu octets\n", sizeof(*err));
967  fprintf(ofd, " .error = %d \"%s\"\n", err->error,
968  strerror(-err->error));
969  fprintf(ofd, " [ORIGINAL MESSAGE] %Zu octets\n", sizeof(*hdr));
970 
971  errmsg = nlmsg_inherit(&err->msg);
972  print_hdr(ofd, errmsg);
973  nlmsg_free(errmsg);
974  } else if (nlmsg_len(hdr) > 0) {
975  struct nl_cache_ops *ops;
976  int payloadlen = nlmsg_len(hdr);
977  int attrlen = 0;
978 
979  ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
980  hdr->nlmsg_type);
981  if (ops) {
982  attrlen = nlmsg_attrlen(hdr, ops->co_hdrsize);
983  payloadlen -= attrlen;
984  }
985 
986  fprintf(ofd, " [PAYLOAD] %d octets\n", payloadlen);
987  dump_hex(ofd, nlmsg_data(hdr), payloadlen, 0);
988 
989  if (attrlen) {
990  struct nlattr *attrs;
991  int attrlen;
992 
993  attrs = nlmsg_attrdata(hdr, ops->co_hdrsize);
994  attrlen = nlmsg_attrlen(hdr, ops->co_hdrsize);
995  dump_attrs(ofd, attrs, attrlen, 0);
996  }
997  }
998 
999  fprintf(ofd,
1000  "--------------------------- END NETLINK MESSAGE "
1001  "---------------------------\n");
1002 }
1003 
1004 /** @} */
1005 
1006 /** @} */