1 /*
2 * lib/nl.c Core Netlink 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 * @defgroup core Core
14 *
15 * @details
16 * @par 1) Connecting the socket
17 * @code
18 * // Bind and connect the socket to a protocol, NETLINK_ROUTE in this example.
19 * nl_connect(sk, NETLINK_ROUTE);
20 * @endcode
21 *
22 * @par 2) Sending data
23 * @code
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
26 * // recommended.
27 * const char buf[] = { 0x01, 0x02, 0x03, 0x04 };
28 * nl_sendto(sk, buf, sizeof(buf));
29 *
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));
34 *
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);
39 *
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));
46 *
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));
51 * @endcode
52 *
53 * @par 3) Receiving data
54 * @code
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;
58 * unsigned char *msg;
59 * nl_recv(sk, &peer, &msg);
60 *
61 * // nl_recvmsgs() receives a bunch of messages until the callback system
62 * // orders it to state, usually after receving a compolete multi part
63 * // message series.
64 * nl_recvmsgs(sk, my_callback_configuration);
65 *
66 * // nl_recvmsgs_default() acts just like nl_recvmsg() but uses the callback
67 * // configuration stored in the socket.
68 * nl_recvmsgs_default(sk);
69 *
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);
73 * @endcode
74 *
75 * @par 4) Closing
76 * @code
77 * // Close the socket first to release kernel memory
78 * nl_close(sk);
79 * @endcode
80 *
81 * @{
82 */
83
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>
90
91 /**
92 * @name Connection Management
93 * @{
94 */
95
96 /**
97 * Create and connect netlink socket.
98 * @arg sk Netlink socket.
99 * @arg protocol Netlink protocol to use.
100 *
101 * Creates a netlink socket using the specified protocol, binds the socket
102 * and issues a connection attempt.
103 *
104 * @return 0 on success or a negative error code.
105 */
nl_connect(struct nl_sock * sk,int protocol)106 int nl_connect(struct nl_sock *sk, int protocol)
107 {
108 int err;
109 socklen_t addrlen;
110
111 sk->s_fd = socket(AF_NETLINK, SOCK_RAW, protocol);
112 if (sk->s_fd < 0) {
113 err = -nl_syserr2nlerr(errno);
114 goto errout;
115 }
116
117 if (!(sk->s_flags & NL_SOCK_BUFSIZE_SET)) {
118 err = nl_socket_set_buffer_size(sk, 0, 0);
119 if (err < 0)
120 goto errout;
121 }
122
123 err = bind(sk->s_fd, (struct sockaddr*) &sk->s_local,
124 sizeof(sk->s_local));
125 if (err < 0) {
126 err = -nl_syserr2nlerr(errno);
127 goto errout;
128 }
129
130 addrlen = sizeof(sk->s_local);
131 err = getsockname(sk->s_fd, (struct sockaddr *) &sk->s_local,
132 &addrlen);
133 if (err < 0) {
134 err = -nl_syserr2nlerr(errno);
135 goto errout;
136 }
137
138 if (addrlen != sizeof(sk->s_local)) {
139 err = -NLE_NOADDR;
140 goto errout;
141 }
142
143 if (sk->s_local.nl_family != AF_NETLINK) {
144 err = -NLE_AF_NOSUPPORT;
145 goto errout;
146 }
147
148 sk->s_proto = protocol;
149
150 return 0;
151 errout:
152 close(sk->s_fd);
153 sk->s_fd = -1;
154
155 return err;
156 }
157
158 /**
159 * Close/Disconnect netlink socket.
160 * @arg sk Netlink socket.
161 */
nl_close(struct nl_sock * sk)162 void nl_close(struct nl_sock *sk)
163 {
164 if (sk->s_fd >= 0) {
165 close(sk->s_fd);
166 sk->s_fd = -1;
167 }
168
169 sk->s_proto = 0;
170 }
171
172 /** @} */
173
174 /**
175 * @name Send
176 * @{
177 */
178
179 /**
180 * Send raw data over netlink socket.
181 * @arg sk Netlink socket.
182 * @arg buf Data buffer.
183 * @arg size Size of data buffer.
184 * @return Number of characters written on success or a negative error code.
185 */
nl_sendto(struct nl_sock * sk,void * buf,size_t size)186 int nl_sendto(struct nl_sock *sk, void *buf, size_t size)
187 {
188 int ret;
189
190 ret = sendto(sk->s_fd, buf, size, 0, (struct sockaddr *)
191 &sk->s_peer, sizeof(sk->s_peer));
192 if (ret < 0)
193 return -nl_syserr2nlerr(errno);
194
195 return ret;
196 }
197
198 /**
199 * Send netlink message with control over sendmsg() message header.
200 * @arg sk Netlink socket.
201 * @arg msg Netlink message to be sent.
202 * @arg hdr Sendmsg() message header.
203 * @return Number of characters sent on sucess or a negative error code.
204 */
nl_sendmsg(struct nl_sock * sk,struct nl_msg * msg,struct msghdr * hdr)205 int nl_sendmsg(struct nl_sock *sk, struct nl_msg *msg, struct msghdr *hdr)
206 {
207 struct nl_cb *cb;
208 int ret;
209
210 nlmsg_set_src(msg, &sk->s_local);
211
212 cb = sk->s_cb;
213 if (cb->cb_set[NL_CB_MSG_OUT])
214 if (nl_cb_call(cb, NL_CB_MSG_OUT, msg) != NL_OK)
215 return 0;
216
217 ret = sendmsg(sk->s_fd, hdr, 0);
218 if (ret < 0)
219 return -nl_syserr2nlerr(errno);
220
221 NL_DBG(4, "sent %d bytes\n", ret);
222 return ret;
223 }
224
225
226 /**
227 * Send netlink message.
228 * @arg sk Netlink socket.
229 * @arg msg Netlink message to be sent.
230 * @arg iov iovec to be sent.
231 * @arg iovlen number of struct iovec to be sent.
232 * @see nl_sendmsg()
233 * @return Number of characters sent on success or a negative error code.
234 */
nl_send_iovec(struct nl_sock * sk,struct nl_msg * msg,struct iovec * iov,unsigned iovlen)235 int nl_send_iovec(struct nl_sock *sk, struct nl_msg *msg, struct iovec *iov, unsigned iovlen)
236 {
237 struct sockaddr_nl *dst;
238 struct ucred *creds;
239 struct msghdr hdr = {
240 .msg_name = (void *) &sk->s_peer,
241 .msg_namelen = sizeof(struct sockaddr_nl),
242 .msg_iov = iov,
243 .msg_iovlen = iovlen,
244 };
245
246 /* Overwrite destination if specified in the message itself, defaults
247 * to the peer address of the socket.
248 */
249 dst = nlmsg_get_dst(msg);
250 if (dst->nl_family == AF_NETLINK)
251 hdr.msg_name = dst;
252
253 /* Add credentials if present. */
254 creds = nlmsg_get_creds(msg);
255 if (creds != NULL) {
256 char buf[CMSG_SPACE(sizeof(struct ucred))];
257 struct cmsghdr *cmsg;
258
259 hdr.msg_control = buf;
260 hdr.msg_controllen = sizeof(buf);
261
262 cmsg = CMSG_FIRSTHDR(&hdr);
263 cmsg->cmsg_level = SOL_SOCKET;
264 cmsg->cmsg_type = SCM_CREDENTIALS;
265 cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
266 memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred));
267 }
268
269 return nl_sendmsg(sk, msg, &hdr);
270 }
271
272
273
274 /**
275 * Send netlink message.
276 * @arg sk Netlink socket.
277 * @arg msg Netlink message to be sent.
278 * @see nl_sendmsg()
279 * @return Number of characters sent on success or a negative error code.
280 */
nl_send(struct nl_sock * sk,struct nl_msg * msg)281 int nl_send(struct nl_sock *sk, struct nl_msg *msg)
282 {
283 struct iovec iov = {
284 .iov_base = (void *) nlmsg_hdr(msg),
285 .iov_len = nlmsg_hdr(msg)->nlmsg_len,
286 };
287
288 return nl_send_iovec(sk, msg, &iov, 1);
289 }
290
nl_auto_complete(struct nl_sock * sk,struct nl_msg * msg)291 void nl_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
292 {
293 struct nlmsghdr *nlh;
294
295 nlh = nlmsg_hdr(msg);
296 if (nlh->nlmsg_pid == 0)
297 nlh->nlmsg_pid = sk->s_local.nl_pid;
298
299 if (nlh->nlmsg_seq == 0)
300 nlh->nlmsg_seq = sk->s_seq_next++;
301
302 if (msg->nm_protocol == -1)
303 msg->nm_protocol = sk->s_proto;
304
305 nlh->nlmsg_flags |= NLM_F_REQUEST;
306
307 if (!(sk->s_flags & NL_NO_AUTO_ACK))
308 nlh->nlmsg_flags |= NLM_F_ACK;
309 }
310
311 /**
312 * Send netlink message and check & extend header values as needed.
313 * @arg sk Netlink socket.
314 * @arg msg Netlink message to be sent.
315 *
316 * Checks the netlink message \c nlh for completness and extends it
317 * as required before sending it out. Checked fields include pid,
318 * sequence nr, and flags.
319 *
320 * @see nl_send()
321 * @return Number of characters sent or a negative error code.
322 */
nl_send_auto_complete(struct nl_sock * sk,struct nl_msg * msg)323 int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
324 {
325 struct nl_cb *cb = sk->s_cb;
326
327 nl_auto_complete(sk, msg);
328
329 if (cb->cb_send_ow)
330 return cb->cb_send_ow(sk, msg);
331 else
332 return nl_send(sk, msg);
333 }
334
335 /**
336 * Send simple netlink message using nl_send_auto_complete()
337 * @arg sk Netlink socket.
338 * @arg type Netlink message type.
339 * @arg flags Netlink message flags.
340 * @arg buf Data buffer.
341 * @arg size Size of data buffer.
342 *
343 * Builds a netlink message with the specified type and flags and
344 * appends the specified data as payload to the message.
345 *
346 * @see nl_send_auto_complete()
347 * @return Number of characters sent on success or a negative error code.
348 */
nl_send_simple(struct nl_sock * sk,int type,int flags,void * buf,size_t size)349 int nl_send_simple(struct nl_sock *sk, int type, int flags, void *buf,
350 size_t size)
351 {
352 int err;
353 struct nl_msg *msg;
354
355 msg = nlmsg_alloc_simple(type, flags);
356 if (!msg)
357 return -NLE_NOMEM;
358
359 if (buf && size) {
360 err = nlmsg_append(msg, buf, size, NLMSG_ALIGNTO);
361 if (err < 0)
362 goto errout;
363 }
364
365
366 err = nl_send_auto_complete(sk, msg);
367 errout:
368 nlmsg_free(msg);
369
370 return err;
371 }
372
373 /** @} */
374
375 /**
376 * @name Receive
377 * @{
378 */
379
380 /**
381 * Receive data from netlink socket
382 * @arg sk Netlink socket.
383 * @arg nla Destination pointer for peer's netlink address.
384 * @arg buf Destination pointer for message content.
385 * @arg creds Destination pointer for credentials.
386 *
387 * Receives a netlink message, allocates a buffer in \c *buf and
388 * stores the message content. The peer's netlink address is stored
389 * in \c *nla. The caller is responsible for freeing the buffer allocated
390 * in \c *buf if a positive value is returned. Interruped system calls
391 * are handled by repeating the read. The input buffer size is determined
392 * by peeking before the actual read is done.
393 *
394 * A non-blocking sockets causes the function to return immediately with
395 * a return value of 0 if no data is available.
396 *
397 * @return Number of octets read, 0 on EOF or a negative error code.
398 */
nl_recv(struct nl_sock * sk,struct sockaddr_nl * nla,unsigned char ** buf,struct ucred ** creds)399 int nl_recv(struct nl_sock *sk, struct sockaddr_nl *nla,
400 unsigned char **buf, struct ucred **creds)
401 {
402 int n;
403 int flags = 0;
404 static int page_size = 0;
405 struct iovec iov;
406 struct msghdr msg = {
407 .msg_name = (void *) nla,
408 .msg_namelen = sizeof(struct sockaddr_nl),
409 .msg_iov = &iov,
410 .msg_iovlen = 1,
411 .msg_control = NULL,
412 .msg_controllen = 0,
413 .msg_flags = 0,
414 };
415 struct cmsghdr *cmsg;
416
417 if (sk->s_flags & NL_MSG_PEEK)
418 flags |= MSG_PEEK;
419
420 if (page_size == 0)
421 page_size = getpagesize();
422
423 iov.iov_len = page_size;
424 iov.iov_base = *buf = malloc(iov.iov_len);
425
426 if (sk->s_flags & NL_SOCK_PASSCRED) {
427 msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
428 msg.msg_control = calloc(1, msg.msg_controllen);
429 }
430 retry:
431
432 n = recvmsg(sk->s_fd, &msg, flags);
433 if (!n)
434 goto abort;
435 else if (n < 0) {
436 if (errno == EINTR) {
437 NL_DBG(3, "recvmsg() returned EINTR, retrying\n");
438 goto retry;
439 } else if (errno == EAGAIN) {
440 NL_DBG(3, "recvmsg() returned EAGAIN, aborting\n");
441 goto abort;
442 } else {
443 free(msg.msg_control);
444 free(*buf);
445 return -nl_syserr2nlerr(errno);
446 }
447 }
448
449 if (iov.iov_len < n ||
450 msg.msg_flags & MSG_TRUNC) {
451 /* Provided buffer is not long enough, enlarge it
452 * and try again. */
453 iov.iov_len *= 2;
454 iov.iov_base = *buf = realloc(*buf, iov.iov_len);
455 goto retry;
456 } else if (msg.msg_flags & MSG_CTRUNC) {
457 msg.msg_controllen *= 2;
458 msg.msg_control = realloc(msg.msg_control, msg.msg_controllen);
459 goto retry;
460 } else if (flags != 0) {
461 /* Buffer is big enough, do the actual reading */
462 flags = 0;
463 goto retry;
464 }
465
466 if (msg.msg_namelen != sizeof(struct sockaddr_nl)) {
467 free(msg.msg_control);
468 free(*buf);
469 return -NLE_NOADDR;
470 }
471
472 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
473 if (cmsg->cmsg_level == SOL_SOCKET &&
474 cmsg->cmsg_type == SCM_CREDENTIALS) {
475 *creds = calloc(1, sizeof(struct ucred));
476 memcpy(*creds, CMSG_DATA(cmsg), sizeof(struct ucred));
477 break;
478 }
479 }
480
481 free(msg.msg_control);
482 return n;
483
484 abort:
485 free(msg.msg_control);
486 free(*buf);
487 return 0;
488 }
489
490 #define NL_CB_CALL(cb, type, msg) \
491 do { \
492 err = nl_cb_call(cb, type, msg); \
493 switch (err) { \
494 case NL_OK: \
495 err = 0; \
496 break; \
497 case NL_SKIP: \
498 goto skip; \
499 case NL_STOP: \
500 goto stop; \
501 default: \
502 goto out; \
503 } \
504 } while (0)
505
recvmsgs(struct nl_sock * sk,struct nl_cb * cb)506 static int recvmsgs(struct nl_sock *sk, struct nl_cb *cb)
507 {
508 int n, err = 0, multipart = 0;
509 unsigned char *buf = NULL;
510 struct nlmsghdr *hdr;
511 struct sockaddr_nl nla = {0};
512 struct nl_msg *msg = NULL;
513 struct ucred *creds = NULL;
514
515 continue_reading:
516 NL_DBG(3, "Attempting to read from %p\n", sk);
517 if (cb->cb_recv_ow)
518 n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
519 else
520 n = nl_recv(sk, &nla, &buf, &creds);
521
522 if (n <= 0)
523 return n;
524
525 NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", sk, n);
526
527 hdr = (struct nlmsghdr *) buf;
528 while (nlmsg_ok(hdr, n)) {
529 NL_DBG(3, "recgmsgs(%p): Processing valid message...\n", sk);
530
531 nlmsg_free(msg);
532 msg = nlmsg_convert(hdr);
533 if (!msg) {
534 err = -NLE_NOMEM;
535 goto out;
536 }
537
538 nlmsg_set_proto(msg, sk->s_proto);
539 nlmsg_set_src(msg, &nla);
540 if (creds)
541 nlmsg_set_creds(msg, creds);
542
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);
547
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);
556 else {
557 err = -NLE_SEQ_MISMATCH;
558 goto out;
559 }
560 }
561
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. */
568 sk->s_seq_expect++;
569 NL_DBG(3, "recvmsgs(%p): Increased expected " \
570 "sequence number to %d\n",
571 sk, sk->s_seq_expect);
572 }
573
574 if (hdr->nlmsg_flags & NLM_F_MULTI)
575 multipart = 1;
576
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);
581 else {
582 /* FIXME: implement */
583 }
584 }
585
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) {
591 multipart = 0;
592 if (cb->cb_set[NL_CB_FINISH])
593 NL_CB_CALL(cb, NL_CB_FINISH, msg);
594 }
595
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
599 * NL_PROCEED. */
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);
603 else
604 goto skip;
605 }
606
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);
613 else {
614 err = -NLE_MSG_OVERFLOW;
615 goto out;
616 }
617 }
618
619 /* Message carries a nlmsgerr */
620 else if (hdr->nlmsg_type == NLMSG_ERROR) {
621 struct nlmsgerr *e = nlmsg_data(hdr);
622
623 if (hdr->nlmsg_len < 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);
630 else {
631 err = -NLE_MSG_TRUNC;
632 goto out;
633 }
634 } else if (e->error) {
635 /* Error message reported back from kernel. */
636 if (cb->cb_err) {
637 err = cb->cb_err(&nla, e,
638 cb->cb_err_arg);
639 if (err < 0)
640 goto out;
641 else if (err == NL_SKIP)
642 goto skip;
643 else if (err == NL_STOP) {
644 err = -nl_syserr2nlerr(e->error);
645 goto out;
646 }
647 } else {
648 err = -nl_syserr2nlerr(e->error);
649 goto out;
650 }
651 } else if (cb->cb_set[NL_CB_ACK])
652 NL_CB_CALL(cb, NL_CB_ACK, msg);
653 } else {
654 /* Valid message (not checking for MULTIPART bit to
655 * get along with broken kernels. NL_SKIP has no
656 * effect on this. */
657 if (cb->cb_set[NL_CB_VALID])
658 NL_CB_CALL(cb, NL_CB_VALID, msg);
659 }
660 skip:
661 err = 0;
662 hdr = nlmsg_next(hdr, &n);
663 }
664
665 nlmsg_free(msg);
666 free(buf);
667 free(creds);
668 buf = NULL;
669 msg = NULL;
670 creds = NULL;
671
672 if (multipart) {
673 /* Multipart message not yet complete, continue reading */
674 goto continue_reading;
675 }
676 stop:
677 err = 0;
678 out:
679 nlmsg_free(msg);
680 free(buf);
681 free(creds);
682
683 return err;
684 }
685
686 /**
687 * Receive a set of messages from a netlink socket.
688 * @arg sk Netlink socket.
689 * @arg cb set of callbacks to control behaviour.
690 *
691 * Repeatedly calls nl_recv() or the respective replacement if provided
692 * by the application (see nl_cb_overwrite_recv()) and parses the
693 * received data as netlink messages. Stops reading if one of the
694 * callbacks returns NL_STOP or nl_recv returns either 0 or a negative error code.
695 *
696 * A non-blocking sockets causes the function to return immediately if
697 * no data is available.
698 *
699 * @return 0 on success or a negative error code from nl_recv().
700 */
nl_recvmsgs(struct nl_sock * sk,struct nl_cb * cb)701 int nl_recvmsgs(struct nl_sock *sk, struct nl_cb *cb)
702 {
703 if (cb->cb_recvmsgs_ow)
704 return cb->cb_recvmsgs_ow(sk, cb);
705 else
706 return recvmsgs(sk, cb);
707 }
708
709 /**
710 * Receive a set of message from a netlink socket using handlers in nl_sock.
711 * @arg sk Netlink socket.
712 *
713 * Calls nl_recvmsgs() with the handlers configured in the netlink socket.
714 */
nl_recvmsgs_default(struct nl_sock * sk)715 int nl_recvmsgs_default(struct nl_sock *sk)
716 {
717 return nl_recvmsgs(sk, sk->s_cb);
718
719 }
720
ack_wait_handler(struct nl_msg * msg,void * arg)721 static int ack_wait_handler(struct nl_msg *msg, void *arg)
722 {
723 return NL_STOP;
724 }
725
726 /**
727 * Wait for ACK.
728 * @arg sk Netlink socket.
729 * @pre The netlink socket must be in blocking state.
730 *
731 * Waits until an ACK is received for the latest not yet acknowledged
732 * netlink message.
733 */
nl_wait_for_ack(struct nl_sock * sk)734 int nl_wait_for_ack(struct nl_sock *sk)
735 {
736 int err;
737 struct nl_cb *cb;
738
739 cb = nl_cb_clone(sk->s_cb);
740 if (cb == NULL)
741 return -NLE_NOMEM;
742
743 nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL);
744 err = nl_recvmsgs(sk, cb);
745 nl_cb_put(cb);
746
747 return err;
748 }
749
750 /** @} */
751
752 /** @} */
753