2 * lib/nl.c Core Netlink Interface
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
9 * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
16 * @par 1) Connecting the socket
18 * // Bind and connect the socket to a protocol, NETLINK_ROUTE in this example.
19 * nl_connect(sk, NETLINK_ROUTE);
22 * @par 2) Sending data
24 * // The most rudimentary method is to use nl_sendto() simply pushing
25 * // a piece of data to the other netlink peer. This method is not
27 * const char buf[] = { 0x01, 0x02, 0x03, 0x04 };
28 * nl_sendto(sk, buf, sizeof(buf));
30 * // A more comfortable interface is nl_send() taking a pointer to
31 * // a netlink message.
32 * struct nl_msg *msg = my_msg_builder();
33 * nl_send(sk, nlmsg_hdr(msg));
35 * // nl_sendmsg() provides additional control over the sendmsg() message
36 * // header in order to allow more specific addressing of multiple peers etc.
37 * struct msghdr hdr = { ... };
38 * nl_sendmsg(sk, nlmsg_hdr(msg), &hdr);
40 * // You're probably too lazy to fill out the netlink pid, sequence number
41 * // and message flags all the time. nl_send_auto_complete() automatically
42 * // extends your message header as needed with an appropriate sequence
43 * // number, the netlink pid stored in the netlink socket and the message
44 * // flags NLM_F_REQUEST and NLM_F_ACK (if not disabled in the socket)
45 * nl_send_auto_complete(sk, nlmsg_hdr(msg));
47 * // Simple protocols don't require the complex message construction interface
48 * // and may favour nl_send_simple() to easly send a bunch of payload
49 * // encapsulated in a netlink message header.
50 * nl_send_simple(sk, MY_MSG_TYPE, 0, buf, sizeof(buf));
53 * @par 3) Receiving data
55 * // nl_recv() receives a single message allocating a buffer for the message
56 * // content and gives back the pointer to you.
57 * struct sockaddr_nl peer;
59 * nl_recv(sk, &peer, &msg);
61 * // nl_recvmsgs() receives a bunch of messages until the callback system
62 * // orders it to state, usually after receving a compolete multi part
64 * nl_recvmsgs(sk, my_callback_configuration);
66 * // nl_recvmsgs_default() acts just like nl_recvmsg() but uses the callback
67 * // configuration stored in the socket.
68 * nl_recvmsgs_default(sk);
70 * // In case you want to wait for the ACK to be recieved that you requested
71 * // with your latest message, you can call nl_wait_for_ack()
72 * nl_wait_for_ack(sk);
77 * // Close the socket first to release kernel memory
84 #include <netlink-local.h>
85 #include <netlink/netlink.h>
86 #include <netlink/utils.h>
87 #include <netlink/handlers.h>
88 #include <netlink/msg.h>
89 #include <netlink/attr.h>
92 * @name Connection Management
97 * Create and connect netlink socket.
98 * @arg sk Netlink socket.
99 * @arg protocol Netlink protocol to use.
101 * Creates a netlink socket using the specified protocol, binds the socket
102 * and issues a connection attempt.
104 * @return 0 on success or a negative error code.
106 int nl_connect(struct nl_sock
*sk
, int protocol
)
113 flags
= SOCK_CLOEXEC
;
116 sk
->s_fd
= socket(AF_NETLINK
, SOCK_RAW
| flags
, protocol
);
118 err
= -nl_syserr2nlerr(errno
);
122 if (!(sk
->s_flags
& NL_SOCK_BUFSIZE_SET
)) {
123 err
= nl_socket_set_buffer_size(sk
, 0, 0);
128 err
= bind(sk
->s_fd
, (struct sockaddr
*) &sk
->s_local
,
129 sizeof(sk
->s_local
));
131 err
= -nl_syserr2nlerr(errno
);
135 addrlen
= sizeof(sk
->s_local
);
136 err
= getsockname(sk
->s_fd
, (struct sockaddr
*) &sk
->s_local
,
139 err
= -nl_syserr2nlerr(errno
);
143 if (addrlen
!= sizeof(sk
->s_local
)) {
148 if (sk
->s_local
.nl_family
!= AF_NETLINK
) {
149 err
= -NLE_AF_NOSUPPORT
;
153 sk
->s_proto
= protocol
;
164 * Close/Disconnect netlink socket.
165 * @arg sk Netlink socket.
167 void nl_close(struct nl_sock
*sk
)
185 * Send raw data over netlink socket.
186 * @arg sk Netlink socket.
187 * @arg buf Data buffer.
188 * @arg size Size of data buffer.
189 * @return Number of characters written on success or a negative error code.
191 int nl_sendto(struct nl_sock
*sk
, void *buf
, size_t size
)
195 ret
= sendto(sk
->s_fd
, buf
, size
, 0, (struct sockaddr
*)
196 &sk
->s_peer
, sizeof(sk
->s_peer
));
198 return -nl_syserr2nlerr(errno
);
204 * Send netlink message with control over sendmsg() message header.
205 * @arg sk Netlink socket.
206 * @arg msg Netlink message to be sent.
207 * @arg hdr Sendmsg() message header.
208 * @return Number of characters sent on sucess or a negative error code.
210 int nl_sendmsg(struct nl_sock
*sk
, struct nl_msg
*msg
, struct msghdr
*hdr
)
216 .iov_base
= (void *) nlmsg_hdr(msg
),
217 .iov_len
= nlmsg_hdr(msg
)->nlmsg_len
,
223 nlmsg_set_src(msg
, &sk
->s_local
);
226 if (cb
->cb_set
[NL_CB_MSG_OUT
])
227 if (nl_cb_call(cb
, NL_CB_MSG_OUT
, msg
) != NL_OK
)
230 if (sk
->s_debug_tx_cb
) {
231 nlmsg_set_proto(msg
, sk
->s_proto
);
232 sk
->s_debug_tx_cb(sk
->s_debug_tx_priv
, msg
);
235 ret
= sendmsg(sk
->s_fd
, hdr
, 0);
237 return -nl_syserr2nlerr(errno
);
244 * Send netlink message.
245 * @arg sk Netlink socket.
246 * @arg msg Netlink message to be sent.
248 * @return Number of characters sent on success or a negative error code.
250 int nl_send(struct nl_sock
*sk
, struct nl_msg
*msg
)
252 struct sockaddr_nl
*dst
;
255 struct msghdr hdr
= {
256 .msg_name
= (void *) &sk
->s_peer
,
257 .msg_namelen
= sizeof(struct sockaddr_nl
),
260 /* Overwrite destination if specified in the message itself, defaults
261 * to the peer address of the socket.
263 dst
= nlmsg_get_dst(msg
);
264 if (dst
->nl_family
== AF_NETLINK
)
267 /* Add credentials if present. */
268 creds
= nlmsg_get_creds(msg
);
270 char buf
[CMSG_SPACE(sizeof(struct ucred
))];
271 struct cmsghdr
*cmsg
;
273 hdr
.msg_control
= buf
;
274 hdr
.msg_controllen
= sizeof(buf
);
276 cmsg
= CMSG_FIRSTHDR(&hdr
);
277 cmsg
->cmsg_level
= SOL_SOCKET
;
278 cmsg
->cmsg_type
= SCM_CREDENTIALS
;
279 cmsg
->cmsg_len
= CMSG_LEN(sizeof(struct ucred
));
280 memcpy(CMSG_DATA(cmsg
), creds
, sizeof(struct ucred
));
283 return nl_sendmsg(sk
, msg
, &hdr
);
287 * Send netlink message and check & extend header values as needed.
288 * @arg sk Netlink socket.
289 * @arg msg Netlink message to be sent.
291 * Checks the netlink message \c nlh for completness and extends it
292 * as required before sending it out. Checked fields include pid,
293 * sequence nr, and flags.
296 * @return Number of characters sent or a negative error code.
298 int nl_send_auto_complete(struct nl_sock
*sk
, struct nl_msg
*msg
)
300 struct nlmsghdr
*nlh
;
301 struct nl_cb
*cb
= sk
->s_cb
;
303 nlh
= nlmsg_hdr(msg
);
304 if (nlh
->nlmsg_pid
== 0)
305 nlh
->nlmsg_pid
= sk
->s_local
.nl_pid
;
307 if (nlh
->nlmsg_seq
== 0)
308 nlh
->nlmsg_seq
= sk
->s_seq_next
++;
310 if (msg
->nm_protocol
== -1)
311 msg
->nm_protocol
= sk
->s_proto
;
313 nlh
->nlmsg_flags
|= NLM_F_REQUEST
;
315 if (!(sk
->s_flags
& NL_NO_AUTO_ACK
))
316 nlh
->nlmsg_flags
|= NLM_F_ACK
;
319 return cb
->cb_send_ow(sk
, msg
);
321 return nl_send(sk
, msg
);
325 * Send simple netlink message using nl_send_auto_complete()
326 * @arg sk Netlink socket.
327 * @arg type Netlink message type.
328 * @arg flags Netlink message flags.
329 * @arg buf Data buffer.
330 * @arg size Size of data buffer.
332 * Builds a netlink message with the specified type and flags and
333 * appends the specified data as payload to the message.
335 * @see nl_send_auto_complete()
336 * @return Number of characters sent on success or a negative error code.
338 int nl_send_simple(struct nl_sock
*sk
, int type
, int flags
, void *buf
,
344 msg
= nlmsg_alloc_simple(type
, flags
);
349 err
= nlmsg_append(msg
, buf
, size
, NLMSG_ALIGNTO
);
355 err
= nl_send_auto_complete(sk
, msg
);
370 * Receive data from netlink socket
371 * @arg sk Netlink socket.
372 * @arg nla Destination pointer for peer's netlink address.
373 * @arg buf Destination pointer for message content.
374 * @arg creds Destination pointer for credentials.
376 * Receives a netlink message, allocates a buffer in \c *buf and
377 * stores the message content. The peer's netlink address is stored
378 * in \c *nla. The caller is responsible for freeing the buffer allocated
379 * in \c *buf if a positive value is returned. Interrupted system calls
380 * are handled by repeating the read. The input buffer size is determined
381 * by peeking before the actual read is done.
383 * A non-blocking sockets causes the function to return immediately with
384 * a return value of 0 if no data is available.
386 * @return Number of octets read, 0 on EOF or a negative error code.
388 int nl_recv(struct nl_sock
*sk
, struct sockaddr_nl
*nla
,
389 unsigned char **buf
, struct ucred
**creds
)
393 static int page_size
= 0;
395 struct msghdr msg
= {
396 .msg_name
= (void *) nla
,
397 .msg_namelen
= sizeof(struct sockaddr_nl
),
404 struct cmsghdr
*cmsg
;
406 if (sk
->s_flags
& NL_MSG_PEEK
)
410 page_size
= getpagesize() * 4;
412 iov
.iov_len
= page_size
;
413 iov
.iov_base
= *buf
= calloc(1, iov
.iov_len
);
415 return -nl_syserr2nlerr(errno
);
417 if (sk
->s_flags
& NL_SOCK_PASSCRED
) {
418 msg
.msg_controllen
= CMSG_SPACE(sizeof(struct ucred
));
419 msg
.msg_control
= calloc(1, msg
.msg_controllen
);
423 n
= recvmsg(sk
->s_fd
, &msg
, flags
);
427 if (errno
== EINTR
) {
428 NL_DBG(3, "recvmsg() returned EINTR, retrying\n");
430 } else if (errno
== EAGAIN
) {
431 NL_DBG(3, "recvmsg() returned EAGAIN, aborting\n");
434 free(msg
.msg_control
);
437 return -nl_syserr2nlerr(errno
);
441 if (iov
.iov_len
< (size_t) n
||
442 msg
.msg_flags
& MSG_TRUNC
) {
443 /* Provided buffer is not long enough, enlarge it
446 iov
.iov_base
= *buf
= realloc(*buf
, iov
.iov_len
);
448 } else if (msg
.msg_flags
& MSG_CTRUNC
) {
449 msg
.msg_controllen
*= 2;
450 msg
.msg_control
= realloc(msg
.msg_control
, msg
.msg_controllen
);
452 } else if (flags
!= 0) {
453 /* Buffer is big enough, do the actual reading */
458 if (msg
.msg_namelen
!= sizeof(struct sockaddr_nl
)) {
459 free(msg
.msg_control
);
465 for (cmsg
= CMSG_FIRSTHDR(&msg
); cmsg
; cmsg
= CMSG_NXTHDR(&msg
, cmsg
)) {
466 if (cmsg
->cmsg_level
== SOL_SOCKET
&&
467 cmsg
->cmsg_type
== SCM_CREDENTIALS
) {
468 *creds
= calloc(1, sizeof(struct ucred
));
469 memcpy(*creds
, CMSG_DATA(cmsg
), sizeof(struct ucred
));
474 free(msg
.msg_control
);
478 free(msg
.msg_control
);
484 #define NL_CB_CALL(cb, type, msg) \
486 err = nl_cb_call(cb, type, msg); \
500 static int recvmsgs(struct nl_sock
*sk
, struct nl_cb
*cb
)
502 int n
, err
= 0, multipart
= 0;
503 unsigned char *buf
= NULL
;
504 struct nlmsghdr
*hdr
;
505 struct sockaddr_nl nla
= {0};
506 struct nl_msg
*msg
= NULL
;
507 struct ucred
*creds
= NULL
;
510 NL_DBG(3, "Attempting to read from %p\n", sk
);
512 n
= cb
->cb_recv_ow(sk
, &nla
, &buf
, &creds
);
514 n
= nl_recv(sk
, &nla
, &buf
, &creds
);
519 /* make clang analyzer happy */
520 assert(n
> 0 && buf
);
522 NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", sk
, n
);
524 hdr
= (struct nlmsghdr
*) buf
;
525 while (nlmsg_ok(hdr
, n
)) {
526 NL_DBG(3, "recgmsgs(%p): Processing valid message...\n", sk
);
529 msg
= nlmsg_convert(hdr
);
535 nlmsg_set_proto(msg
, sk
->s_proto
);
536 nlmsg_set_src(msg
, &nla
);
538 nlmsg_set_creds(msg
, creds
);
540 if (sk
->s_debug_rx_cb
)
541 sk
->s_debug_rx_cb(sk
->s_debug_rx_priv
, msg
);
543 /* Raw callback is the first, it gives the most control
544 * to the user and he can do his very own parsing. */
545 if (cb
->cb_set
[NL_CB_MSG_IN
])
546 NL_CB_CALL(cb
, NL_CB_MSG_IN
, msg
);
548 /* Sequence number checking. The check may be done by
549 * the user, otherwise a very simple check is applied
550 * enforcing strict ordering */
551 if (cb
->cb_set
[NL_CB_SEQ_CHECK
])
552 NL_CB_CALL(cb
, NL_CB_SEQ_CHECK
, msg
);
553 else if (hdr
->nlmsg_seq
!= sk
->s_seq_expect
) {
554 if (cb
->cb_set
[NL_CB_INVALID
])
555 NL_CB_CALL(cb
, NL_CB_INVALID
, msg
);
557 err
= -NLE_SEQ_MISMATCH
;
562 if (hdr
->nlmsg_type
== NLMSG_DONE
||
563 hdr
->nlmsg_type
== NLMSG_ERROR
||
564 hdr
->nlmsg_type
== NLMSG_NOOP
||
565 hdr
->nlmsg_type
== NLMSG_OVERRUN
) {
566 /* We can't check for !NLM_F_MULTI since some netlink
567 * users in the kernel are broken. */
569 NL_DBG(3, "recvmsgs(%p): Increased expected " \
570 "sequence number to %d\n",
571 sk
, sk
->s_seq_expect
);
574 if (hdr
->nlmsg_flags
& NLM_F_MULTI
)
577 /* Other side wishes to see an ack for this message */
578 if (hdr
->nlmsg_flags
& NLM_F_ACK
) {
579 if (cb
->cb_set
[NL_CB_SEND_ACK
])
580 NL_CB_CALL(cb
, NL_CB_SEND_ACK
, msg
);
582 /* FIXME: implement */
586 /* messages terminates a multpart message, this is
587 * usually the end of a message and therefore we slip
588 * out of the loop by default. the user may overrule
589 * this action by skipping this packet. */
590 if (hdr
->nlmsg_type
== NLMSG_DONE
) {
592 if (cb
->cb_set
[NL_CB_FINISH
])
593 NL_CB_CALL(cb
, NL_CB_FINISH
, msg
);
596 /* Message to be ignored, the default action is to
597 * skip this message if no callback is specified. The
598 * user may overrule this action by returning
600 else if (hdr
->nlmsg_type
== NLMSG_NOOP
) {
601 if (cb
->cb_set
[NL_CB_SKIPPED
])
602 NL_CB_CALL(cb
, NL_CB_SKIPPED
, msg
);
607 /* Data got lost, report back to user. The default action is to
608 * quit parsing. The user may overrule this action by retuning
609 * NL_SKIP or NL_PROCEED (dangerous) */
610 else if (hdr
->nlmsg_type
== NLMSG_OVERRUN
) {
611 if (cb
->cb_set
[NL_CB_OVERRUN
])
612 NL_CB_CALL(cb
, NL_CB_OVERRUN
, msg
);
614 err
= -NLE_MSG_OVERFLOW
;
619 /* Message carries a nlmsgerr */
620 else if (hdr
->nlmsg_type
== NLMSG_ERROR
) {
621 struct nlmsgerr
*e
= nlmsg_data(hdr
);
623 if (hdr
->nlmsg_len
< (unsigned) nlmsg_msg_size(sizeof(*e
))) {
624 /* Truncated error message, the default action
625 * is to stop parsing. The user may overrule
626 * this action by returning NL_SKIP or
627 * NL_PROCEED (dangerous) */
628 if (cb
->cb_set
[NL_CB_INVALID
])
629 NL_CB_CALL(cb
, NL_CB_INVALID
, msg
);
631 err
= -NLE_MSG_TRUNC
;
634 } else if (e
->error
) {
635 /* Error message reported back from kernel. */
637 err
= cb
->cb_err(&nla
, e
,
641 else if (err
== NL_SKIP
)
643 else if (err
== NL_STOP
) {
644 err
= -nl_syserr2nlerr(e
->error
);
648 err
= -nl_syserr2nlerr(e
->error
);
651 } else if (cb
->cb_set
[NL_CB_ACK
])
652 NL_CB_CALL(cb
, NL_CB_ACK
, msg
);
654 /* Valid message (not checking for MULTIPART bit to
655 * get along with broken kernels. NL_SKIP has no
657 if (cb
->cb_set
[NL_CB_VALID
])
658 NL_CB_CALL(cb
, NL_CB_VALID
, msg
);
661 hdr
= nlmsg_next(hdr
, &n
);
672 /* Multipart message not yet complete, continue reading */
673 goto continue_reading
;
686 * Receive a set of messages from a netlink socket.
687 * @arg sk Netlink socket.
688 * @arg cb set of callbacks to control behaviour.
690 * Repeatedly calls nl_recv() or the respective replacement if provided
691 * by the application (see nl_cb_overwrite_recv()) and parses the
692 * received data as netlink messages. Stops reading if one of the
693 * callbacks returns NL_STOP or nl_recv returns either 0 or a negative error code.
695 * A non-blocking sockets causes the function to return immediately if
696 * no data is available.
698 * @return 0 on success or a negative error code from nl_recv().
700 int nl_recvmsgs(struct nl_sock
*sk
, struct nl_cb
*cb
)
702 if (cb
->cb_recvmsgs_ow
)
703 return cb
->cb_recvmsgs_ow(sk
, cb
);
705 return recvmsgs(sk
, cb
);
709 static int ack_wait_handler(struct nl_msg
*msg
, void *arg
)
716 * @arg sk Netlink socket.
717 * @pre The netlink socket must be in blocking state.
719 * Waits until an ACK is received for the latest not yet acknowledged
722 int nl_wait_for_ack(struct nl_sock
*sk
)
727 cb
= nl_cb_clone(sk
->s_cb
);
731 nl_cb_set(cb
, NL_CB_ACK
, NL_CB_CUSTOM
, ack_wait_handler
, NULL
);
732 err
= nl_recvmsgs(sk
, cb
);