libnl 3.5.0

socket.c
1 /* SPDX-License-Identifier: LGPL-2.1-only */
2 /*
3 * lib/socket.c Netlink Socket
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation version 2.1
8 * of the License.
9 *
10 * Copyright (c) 2003-2012 Thomas Graf <tgraf@suug.ch>
11 */
12
13 /**
14 * @ingroup core_types
15 * @defgroup socket Socket
16 *
17 * Representation of a netlink socket
18 *
19 * Related sections in the development guide:
20 * - @core_doc{core_sockets, Netlink Sockets}
21 *
22 * @{
23 *
24 * Header
25 * ------
26 * ~~~~{.c}
27 * #include <netlink/socket.h>
28 * ~~~~
29 */
30
31 #include "defs.h"
32
33 #include "sys/socket.h"
34
35 #include <netlink-private/netlink.h>
36 #include <netlink-private/socket.h>
37 #include <netlink-private/utils.h>
38 #include <netlink/netlink.h>
39 #include <netlink/utils.h>
40 #include <netlink/handlers.h>
41 #include <netlink/msg.h>
42 #include <netlink/attr.h>
43
44 static int default_cb = NL_CB_DEFAULT;
45
46 static void __init init_default_cb(void)
47 {
48 char *nlcb;
49
50 if ((nlcb = getenv("NLCB"))) {
51 if (!strcasecmp(nlcb, "default"))
52 default_cb = NL_CB_DEFAULT;
53 else if (!strcasecmp(nlcb, "verbose"))
54 default_cb = NL_CB_VERBOSE;
55 else if (!strcasecmp(nlcb, "debug"))
56 default_cb = NL_CB_DEBUG;
57 else {
58 fprintf(stderr, "Unknown value for NLCB, valid values: "
59 "{default | verbose | debug}\n");
60 }
61 }
62 }
63
64 static uint32_t used_ports_map[32];
65 static NL_RW_LOCK(port_map_lock);
66
67 static uint32_t generate_local_port(void)
68 {
69 int i, j, n, m;
70 static uint16_t idx_state = 0;
71 uint32_t pid = getpid() & 0x3FFFFF;
72
73 nl_write_lock(&port_map_lock);
74
75 if (idx_state == 0) {
76 uint32_t t = time(NULL);
77
78 /* from time to time (on average each 2^15 calls), the idx_state will
79 * be zero again. No problem, just "seed" anew with time(). */
80 idx_state = t ^ (t >> 16) ^ 0x3047;
81 } else
82 idx_state = idx_state + 20011; /* add prime number */
83
84 i = idx_state >> 5;
85 n = idx_state;
86 for (j = 0; j < 32; j++) {
87 /* walk the index somewhat randomized, with always leaving the block
88 * #0 as last. The reason is that libnl-1 will start at block #0,
89 * so just leave the first 32 ports preferably for libnl-1 owned sockets
90 * (this is relevant only if the applications ends up using both versions
91 * of the library and doesn't hurt otherwise). */
92 if (j == 31)
93 i = 0;
94 else
95 i = (((i-1) + 7) % 31) + 1;
96
97 if (used_ports_map[i] == 0xFFFFFFFF)
98 continue;
99
100 for (m = 0; m < 32; m++) {
101 n = (n + 13) % 32;
102 if (1UL & (used_ports_map[i] >> n))
103 continue;
104
105 used_ports_map[i] |= (1UL << n);
106 n += (i * 32);
107
108 /* PID_MAX_LIMIT is currently at 2^22, leaving 10 bit
109 * to, i.e. 1024 unique ports per application. */
110
111 nl_write_unlock(&port_map_lock);
112
113 /* ensure we don't return zero. */
114 pid = pid + (((uint32_t)n) << 22);
115 return pid ? pid : 1024;
116 }
117 }
118
119 nl_write_unlock(&port_map_lock);
120 return 0;
121 }
122
123 static void release_local_port(uint32_t port)
124 {
125 int nr;
126 uint32_t mask;
127
128 BUG_ON(port == 0);
129
130 nr = port >> 22;
131 mask = 1UL << (nr % 32);
132 nr /= 32;
133
134 nl_write_lock(&port_map_lock);
135 BUG_ON((used_ports_map[nr] & mask) != mask);
136 used_ports_map[nr] &= ~mask;
137 nl_write_unlock(&port_map_lock);
138 }
139
140 /** \cond skip */
141 void _nl_socket_used_ports_release_all(const uint32_t *used_ports)
142 {
143 int i;
144
145 for (i = 0; i < 32; i++) {
146 if (used_ports[i] != 0) {
147 nl_write_lock(&port_map_lock);
148 for (; i < 32; i++) {
149 BUG_ON((used_ports_map[i] & used_ports[i]) != used_ports[i]);
150 used_ports_map[i] &= ~(used_ports[i]);
151 }
152 nl_write_unlock(&port_map_lock);
153 return;
154 }
155 }
156 }
157
158 void _nl_socket_used_ports_set(uint32_t *used_ports, uint32_t port)
159 {
160 int nr;
161 int32_t mask;
162
163 nr = port >> 22;
164 mask = 1UL << (nr % 32);
165 nr /= 32;
166
167 /*
168 BUG_ON(port == 0 || (getpid() & 0x3FFFFF) != (port & 0x3FFFFF));
169 BUG_ON(used_ports[nr] & mask);
170 */
171
172 used_ports[nr] |= mask;
173 }
174 /** \endcond */
175
176 /**
177 * @name Allocation
178 * @{
179 */
180
181 static struct nl_sock *__alloc_socket(struct nl_cb *cb)
182 {
183 struct nl_sock *sk;
184
185 sk = calloc(1, sizeof(*sk));
186 if (!sk)
187 return NULL;
188
189 sk->s_fd = -1;
190 sk->s_cb = nl_cb_get(cb);
191 sk->s_local.nl_family = AF_NETLINK;
192 sk->s_peer.nl_family = AF_NETLINK;
193 sk->s_seq_expect = sk->s_seq_next = time(NULL);
194
195 /* the port is 0 (unspecified), meaning NL_OWN_PORT */
196 sk->s_flags = NL_OWN_PORT;
197
198 return sk;
199 }
200
201 /**
202 * Allocate new netlink socket
203 *
204 * @return Newly allocated netlink socket or NULL.
205 */
206 struct nl_sock *nl_socket_alloc(void)
207 {
208 struct nl_cb *cb;
209 struct nl_sock *sk;
210
211 cb = nl_cb_alloc(default_cb);
212 if (!cb)
213 return NULL;
214
215 /* will increment cb reference count on success */
216 sk = __alloc_socket(cb);
217
218 nl_cb_put(cb);
219
220 return sk;
221 }
222
223 /**
224 * Allocate new socket with custom callbacks
225 * @arg cb Callback handler
226 *
227 * The reference to the callback handler is taken into account
228 * automatically, it is released again upon calling nl_socket_free().
229 *
230 *@return Newly allocted socket handle or NULL.
231 */
232 struct nl_sock *nl_socket_alloc_cb(struct nl_cb *cb)
233 {
234 if (cb == NULL)
235 BUG();
236
237 return __alloc_socket(cb);
238 }
239
240 /**
241 * Free a netlink socket.
242 * @arg sk Netlink socket.
243 */
244 void nl_socket_free(struct nl_sock *sk)
245 {
246 if (!sk)
247 return;
248
249 if (sk->s_fd >= 0)
250 close(sk->s_fd);
251
252 if (!(sk->s_flags & NL_OWN_PORT))
253 release_local_port(sk->s_local.nl_pid);
254
255 nl_cb_put(sk->s_cb);
256 free(sk);
257 }
258
259 /** @} */
260
261 /**
262 * @name Sequence Numbers
263 * @{
264 */
265
266 static int noop_seq_check(struct nl_msg *msg, void *arg)
267 {
268 return NL_OK;
269 }
270
271
272 /**
273 * Disable sequence number checking.
274 * @arg sk Netlink socket.
275 *
276 * Disables checking of sequence numbers on the netlink socket This is
277 * required to allow messages to be processed which were not requested by
278 * a preceding request message, e.g. netlink events.
279 *
280 * @note This function modifies the NL_CB_SEQ_CHECK configuration in
281 * the callback handle associated with the socket.
282 */
283 void nl_socket_disable_seq_check(struct nl_sock *sk)
284 {
285 nl_cb_set(sk->s_cb, NL_CB_SEQ_CHECK,
286 NL_CB_CUSTOM, noop_seq_check, NULL);
287 }
288
289 /**
290 * Use next sequence number
291 * @arg sk Netlink socket.
292 *
293 * Uses the next available sequence number and increases the counter
294 * by one for subsequent calls.
295 *
296 * @return Unique serial sequence number
297 */
298 unsigned int nl_socket_use_seq(struct nl_sock *sk)
299 {
300 return sk->s_seq_next++;
301 }
302
303 /**
304 * Disable automatic request for ACK
305 * @arg sk Netlink socket.
306 *
307 * The default behaviour of a socket is to request an ACK for
308 * each message sent to allow for the caller to synchronize to
309 * the completion of the netlink operation. This function
310 * disables this behaviour and will result in requests being
311 * sent which will not have the NLM_F_ACK flag set automatically.
312 * However, it is still possible for the caller to set the
313 * NLM_F_ACK flag explicitely.
314 */
315 void nl_socket_disable_auto_ack(struct nl_sock *sk)
316 {
317 sk->s_flags |= NL_NO_AUTO_ACK;
318 }
319
320 /**
321 * Enable automatic request for ACK (default)
322 * @arg sk Netlink socket.
323 * @see nl_socket_disable_auto_ack
324 */
325 void nl_socket_enable_auto_ack(struct nl_sock *sk)
326 {
327 sk->s_flags &= ~NL_NO_AUTO_ACK;
328 }
329
330 /** @} */
331
332 /** \cond skip */
333 int _nl_socket_is_local_port_unspecified(struct nl_sock *sk)
334 {
335 return (sk->s_local.nl_pid == 0);
336 }
337
338 uint32_t _nl_socket_set_local_port_no_release(struct nl_sock *sk, int generate_other)
339 {
340 uint32_t port;
341
342 /* reset the port to generate_local_port(), but do not release
343 * the previously generated port. */
344
345 if (generate_other)
346 port = generate_local_port();
347 else
348 port = 0;
349 sk->s_local.nl_pid = port;
350 if (port == 0) {
351 /* failed to find an unsed port. Restore the socket to have an
352 * unspecified port. */
353 sk->s_flags |= NL_OWN_PORT;
354 } else
355 sk->s_flags &= ~NL_OWN_PORT;
356 return port;
357 }
358 /** \endcond */
359
360 /**
361 * @name Source Idenficiation
362 * @{
363 */
364
365 uint32_t nl_socket_get_local_port(const struct nl_sock *sk)
366 {
367 if (sk->s_local.nl_pid == 0) {
368 struct nl_sock *sk_mutable = (struct nl_sock *) sk;
369
370 /* modify the const argument sk. This is justified, because
371 * nobody ever saw the local_port from externally. So, we
372 * initilize it on first use.
373 *
374 * Note that this also means that you cannot call this function
375 * from multiple threads without synchronization. But nl_sock
376 * is not automatically threadsafe anyway, so the user is not
377 * allowed to do that.
378 */
379 sk_mutable->s_local.nl_pid = generate_local_port();
380 if (sk_mutable->s_local.nl_pid == 0) {
381 /* could not generate a local port. Assign UINT32_MAX to preserve
382 * backward compatibility. A user who cares can clear that anyway
383 * with nl_socket_set_local_port(). */
384 sk_mutable->s_local.nl_pid = UINT32_MAX;
385 sk_mutable->s_flags |= NL_OWN_PORT;
386 } else
387 sk_mutable->s_flags &= ~NL_OWN_PORT;
388 }
389 return sk->s_local.nl_pid;
390 }
391
392 /**
393 * Set local port of socket
394 * @arg sk Netlink socket.
395 * @arg port Local port identifier
396 *
397 * Assigns a local port identifier to the socket.
398 *
399 * If port is 0, the port is reset to 'unspecified' as it is after newly
400 * calling nl_socket_alloc().
401 * Unspecified means, that the port will be generated automatically later
402 * on first use (either on nl_socket_get_local_port() or nl_connect()).
403 */
404 void nl_socket_set_local_port(struct nl_sock *sk, uint32_t port)
405 {
406 if (!(sk->s_flags & NL_OWN_PORT))
407 release_local_port(sk->s_local.nl_pid);
408 sk->s_flags |= NL_OWN_PORT;
409 sk->s_local.nl_pid = port;
410 }
411
412 /** @} */
413
414 /**
415 * @name Group Subscriptions
416 * @{
417 */
418
419 /**
420 * Join groups
421 * @arg sk Netlink socket
422 * @arg group Group identifier
423 *
424 * Joins the specified groups using the modern socket option which
425 * is available since kernel version 2.6.14. It allows joining an
426 * almost arbitary number of groups without limitation. The list
427 * of groups has to be terminated by 0 (%NFNLGRP_NONE).
428 *
429 * Make sure to use the correct group definitions as the older
430 * bitmask definitions for nl_join_groups() are likely to still
431 * be present for backward compatibility reasons.
432 *
433 * @return 0 on sucess or a negative error code.
434 */
435 int nl_socket_add_memberships(struct nl_sock *sk, int group, ...)
436 {
437 int err;
438 va_list ap;
439
440 if (sk->s_fd == -1)
441 return -NLE_BAD_SOCK;
442
443 va_start(ap, group);
444
445 while (group != 0) {
446 if (group < 0) {
447 va_end(ap);
448 return -NLE_INVAL;
449 }
450
451 err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP,
452 &group, sizeof(group));
453 if (err < 0) {
454 va_end(ap);
455 NL_DBG(4, "nl_socket_add_memberships(%p): setsockopt() failed with %d (%s)\n",
456 sk, errno, nl_strerror_l(errno));
457 return -nl_syserr2nlerr(errno);
458 }
459
460 group = va_arg(ap, int);
461 }
462
463 va_end(ap);
464
465 return 0;
466 }
467
468 int nl_socket_add_membership(struct nl_sock *sk, int group)
469 {
470 return nl_socket_add_memberships(sk, group, 0);
471 }
472
473 /**
474 * Leave groups
475 * @arg sk Netlink socket
476 * @arg group Group identifier
477 *
478 * Leaves the specified groups using the modern socket option
479 * which is available since kernel version 2.6.14. The list of groups
480 * has to terminated by 0 (%NFNLGRP_NONE).
481 *
482 * @see nl_socket_add_membership
483 * @return 0 on success or a negative error code.
484 */
485 int nl_socket_drop_memberships(struct nl_sock *sk, int group, ...)
486 {
487 int err;
488 va_list ap;
489
490 if (sk->s_fd == -1)
491 return -NLE_BAD_SOCK;
492
493 va_start(ap, group);
494
495 while (group != 0) {
496 if (group < 0) {
497 va_end(ap);
498 return -NLE_INVAL;
499 }
500
501 err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_DROP_MEMBERSHIP,
502 &group, sizeof(group));
503 if (err < 0) {
504 va_end(ap);
505 NL_DBG(4, "nl_socket_drop_memberships(%p): setsockopt() failed with %d (%s)\n",
506 sk, errno, nl_strerror_l(errno));
507 return -nl_syserr2nlerr(errno);
508 }
509
510 group = va_arg(ap, int);
511 }
512
513 va_end(ap);
514
515 return 0;
516 }
517
518 int nl_socket_drop_membership(struct nl_sock *sk, int group)
519 {
520 return nl_socket_drop_memberships(sk, group, 0);
521 }
522
523
524 /**
525 * Join multicast groups (deprecated)
526 * @arg sk Netlink socket.
527 * @arg groups Bitmask of groups to join.
528 *
529 * This function defines the old way of joining multicast group which
530 * has to be done prior to calling nl_connect(). It works on any kernel
531 * version but is very limited as only 32 groups can be joined.
532 */
533 void nl_join_groups(struct nl_sock *sk, int groups)
534 {
535 sk->s_local.nl_groups |= groups;
536 }
537
538
539 /** @} */
540
541 /**
542 * @name Peer Identfication
543 * @{
544 */
545
546 uint32_t nl_socket_get_peer_port(const struct nl_sock *sk)
547 {
548 return sk->s_peer.nl_pid;
549 }
550
551 void nl_socket_set_peer_port(struct nl_sock *sk, uint32_t port)
552 {
553 sk->s_peer.nl_pid = port;
554 }
555
556 uint32_t nl_socket_get_peer_groups(const struct nl_sock *sk)
557 {
558 return sk->s_peer.nl_groups;
559 }
560
561 void nl_socket_set_peer_groups(struct nl_sock *sk, uint32_t groups)
562 {
563 sk->s_peer.nl_groups = groups;
564 }
565
566
567
568 /** @} */
569
570 /**
571 * @name File Descriptor
572 * @{
573 */
574
575 /**
576 * Return the file descriptor of the backing socket
577 * @arg sk Netlink socket
578 *
579 * Only valid after calling nl_connect() to create and bind the respective
580 * socket.
581 *
582 * @return File descriptor or -1 if not available.
583 */
584 int nl_socket_get_fd(const struct nl_sock *sk)
585 {
586 return sk->s_fd;
587 }
588
589 /**
590 * Set the socket file descriptor externally which initializes the
591 * socket similar to nl_connect().
592 *
593 * @arg sk Netlink socket (required)
594 * @arg protocol The socket protocol (optional). Linux 2.6.32 supports
595 * the socket option SO_PROTOCOL. In this case, you can set
596 * protocol to a negative value and let it autodetect.
597 * If you set it to a non-negative value, the detected protocol
598 * must match the one provided.
599 * To support older kernels, you must specify the protocol.
600 * @arg fd Socket file descriptor to use (required)
601 *
602 * Set the socket file descriptor. @fd must be valid and bind'ed.
603 *
604 * This is an alternative to nl_connect(). nl_connect() creates, binds and
605 * sets the socket. With this function you can set the socket to an externally
606 * created file descriptor.
607 *
608 * @see nl_connect()
609 *
610 * @return 0 on success or a negative error code. On error, @fd is not closed but
611 * possibly unusable.
612 *
613 * @retval -NLE_BAD_SOCK Netlink socket is already connected
614 * @retval -NLE_INVAL Socket is of unexpected type
615 */
616 int nl_socket_set_fd(struct nl_sock *sk, int protocol, int fd)
617 {
618 int err = 0;
619 socklen_t addrlen;
620 struct sockaddr_nl local = { 0 };
621 int so_type = -1, so_protocol = -1;
622
623 if (sk->s_fd != -1)
624 return -NLE_BAD_SOCK;
625 if (fd < 0)
626 return -NLE_INVAL;
627
628 addrlen = sizeof(local);
629 err = getsockname(fd, (struct sockaddr *) &local,
630 &addrlen);
631 if (err < 0) {
632 NL_DBG(4, "nl_socket_set_fd(%p,%d): getsockname() failed with %d (%s)\n",
633 sk, fd, errno, nl_strerror_l(errno));
634 return -nl_syserr2nlerr(errno);
635 }
636 if (addrlen != sizeof(local))
637 return -NLE_INVAL;
638 if (local.nl_family != AF_NETLINK) {
639 NL_DBG(4, "nl_socket_set_fd(%p,%d): getsockname() returned family %d instead of %d (AF_NETLINK)\n",
640 sk, fd, local.nl_family, AF_NETLINK);
641 return -NLE_INVAL;
642 }
643
644 addrlen = sizeof(so_type);
645 err = getsockopt(fd, SOL_SOCKET, SO_TYPE, &so_type, &addrlen);
646 if (err < 0) {
647 NL_DBG(4, "nl_socket_set_fd(%p,%d): getsockopt() for SO_TYPE failed with %d (%s)\n",
648 sk, fd, errno, nl_strerror_l(errno));
649 return -nl_syserr2nlerr(errno);
650 }
651 if (addrlen != sizeof(so_type))
652 return -NLE_INVAL;
653 if (so_type != SOCK_RAW) {
654 NL_DBG(4, "nl_socket_set_fd(%p,%d): getsockopt() returned SO_TYPE %d instead of %d (SOCK_RAW)\n",
655 sk, fd, so_type, SOCK_RAW);
656 return -NLE_INVAL;
657 }
658
659 #if SO_PROTOCOL
660 addrlen = sizeof(so_protocol);
661 err = getsockopt(fd, SOL_SOCKET, SO_PROTOCOL, &so_protocol, &addrlen);
662 if (err < 0) {
663 if (errno == ENOPROTOOPT)
664 goto no_so_protocol;
665 NL_DBG(4, "nl_socket_set_fd(%p,%d): getsockopt() for SO_PROTOCOL failed with %d (%s)\n",
666 sk, fd, errno, nl_strerror_l(errno));
667 return -nl_syserr2nlerr(errno);
668 }
669 if (addrlen != sizeof(so_protocol))
670 return -NLE_INVAL;
671 if (protocol >= 0 && protocol != so_protocol) {
672 NL_DBG(4, "nl_socket_set_fd(%p,%d): getsockopt() for SO_PROTOCOL returned %d instead of %d\n",
673 sk, fd, so_protocol, protocol);
674 return -NLE_INVAL;
675 }
676
677 if (0)
678 #endif
679 {
680 no_so_protocol:
681 if (protocol < 0) {
682 NL_DBG(4, "nl_socket_set_fd(%p,%d): unknown protocol and unable to detect it via SO_PROTOCOL socket option\n",
683 sk, fd);
684 return -NLE_INVAL;
685 }
686 so_protocol = protocol;
687 }
688
689 nl_socket_set_local_port (sk, local.nl_pid);
690 sk->s_local = local;
691 sk->s_fd = fd;
692 sk->s_proto = so_protocol;
693
694 return 0;
695 }
696
697 /**
698 * Set file descriptor of socket to non-blocking state
699 * @arg sk Netlink socket.
700 *
701 * @return 0 on success or a negative error code.
702 */
703 int nl_socket_set_nonblocking(const struct nl_sock *sk)
704 {
705 if (sk->s_fd == -1)
706 return -NLE_BAD_SOCK;
707
708 if (fcntl(sk->s_fd, F_SETFL, O_NONBLOCK) < 0) {
709 NL_DBG(4, "nl_socket_set_nonblocking(%p): fcntl() failed with %d (%s)\n",
710 sk, errno, nl_strerror_l(errno));
711 return -nl_syserr2nlerr(errno);
712 }
713
714 return 0;
715 }
716
717 /**
718 * Enable use of MSG_PEEK when reading from socket
719 * @arg sk Netlink socket.
720 *
721 * See also NL_CAPABILITY_NL_RECVMSGS_PEEK_BY_DEFAULT capability
722 */
723 void nl_socket_enable_msg_peek(struct nl_sock *sk)
724 {
725 sk->s_flags |= (NL_MSG_PEEK | NL_MSG_PEEK_EXPLICIT);
726 }
727
728 /**
729 * Disable use of MSG_PEEK when reading from socket
730 * @arg sk Netlink socket.
731 *
732 * See also NL_CAPABILITY_NL_RECVMSGS_PEEK_BY_DEFAULT capability
733 */
734 void nl_socket_disable_msg_peek(struct nl_sock *sk)
735 {
736 sk->s_flags |= NL_MSG_PEEK_EXPLICIT;
737 sk->s_flags &= ~NL_MSG_PEEK;
738 }
739
740 /** @} */
741
742 /**
743 * @name Callback Handler
744 * @{
745 */
746
747 struct nl_cb *nl_socket_get_cb(const struct nl_sock *sk)
748 {
749 return nl_cb_get(sk->s_cb);
750 }
751
752 void nl_socket_set_cb(struct nl_sock *sk, struct nl_cb *cb)
753 {
754 if (cb == NULL)
755 BUG();
756
757 nl_cb_put(sk->s_cb);
758 sk->s_cb = nl_cb_get(cb);
759 }
760
761 /**
762 * Modify the callback handler associated with the socket
763 * @arg sk Netlink socket.
764 * @arg type which type callback to set
765 * @arg kind kind of callback
766 * @arg func callback function
767 * @arg arg argument to be passed to callback function
768 *
769 * @see nl_cb_set
770 */
771 int nl_socket_modify_cb(struct nl_sock *sk, enum nl_cb_type type,
772 enum nl_cb_kind kind, nl_recvmsg_msg_cb_t func,
773 void *arg)
774 {
775 return nl_cb_set(sk->s_cb, type, kind, func, arg);
776 }
777
778 /**
779 * Modify the error callback handler associated with the socket
780 * @arg sk Netlink socket.
781 * @arg kind kind of callback
782 * @arg func callback function
783 * @arg arg argument to be passed to callback function
784 *
785 * @see nl_cb_err
786 */
787 int nl_socket_modify_err_cb(struct nl_sock *sk, enum nl_cb_kind kind,
788 nl_recvmsg_err_cb_t func, void *arg)
789 {
790 return nl_cb_err(sk->s_cb, kind, func, arg);
791 }
792
793 /** @} */
794
795 /**
796 * @name Utilities
797 * @{
798 */
799
800 /**
801 * Set socket buffer size of netlink socket.
802 * @arg sk Netlink socket.
803 * @arg rxbuf New receive socket buffer size in bytes.
804 * @arg txbuf New transmit socket buffer size in bytes.
805 *
806 * Sets the socket buffer size of a netlink socket to the specified
807 * values \c rxbuf and \c txbuf. Providing a value of \c 0 assumes a
808 * good default value.
809 *
810 * @note It is not required to call this function prior to nl_connect().
811 * @return 0 on sucess or a negative error code.
812 */
813 int nl_socket_set_buffer_size(struct nl_sock *sk, int rxbuf, int txbuf)
814 {
815 int err;
816
817 if (rxbuf <= 0)
818 rxbuf = 32768;
819
820 if (txbuf <= 0)
821 txbuf = 32768;
822
823 if (sk->s_fd == -1)
824 return -NLE_BAD_SOCK;
825
826 err = setsockopt(sk->s_fd, SOL_SOCKET, SO_SNDBUF,
827 &txbuf, sizeof(txbuf));
828 if (err < 0) {
829 NL_DBG(4, "nl_socket_set_buffer_size(%p): setsockopt() failed with %d (%s)\n",
830 sk, errno, nl_strerror_l(errno));
831 return -nl_syserr2nlerr(errno);
832 }
833
834 err = setsockopt(sk->s_fd, SOL_SOCKET, SO_RCVBUF,
835 &rxbuf, sizeof(rxbuf));
836 if (err < 0) {
837 NL_DBG(4, "nl_socket_set_buffer_size(%p): setsockopt() failed with %d (%s)\n",
838 sk, errno, nl_strerror_l(errno));
839 return -nl_syserr2nlerr(errno);
840 }
841
842 return 0;
843 }
844
845 /**
846 * Set default message buffer size of netlink socket.
847 * @arg sk Netlink socket.
848 * @arg bufsize Default message buffer size in bytes.
849 *
850 * Sets the default message buffer size to the specified length in bytes.
851 * The default message buffer size limits the maximum message size the
852 * socket will be able to receive. It is generally recommneded to specify
853 * a buffer size no less than the size of a memory page.
854 *
855 * Setting the @bufsize to zero means to use a default of 4 times getpagesize().
856 *
857 * When MSG_PEEK is enabled, the buffer size is used for the initial choice
858 * of the buffer while peeking. It still makes sense to choose an optimal value
859 * to avoid realloc().
860 *
861 * When MSG_PEEK is disabled, the buffer size is important because a too small
862 * size will lead to failure of receiving the message via nl_recvmsgs().
863 *
864 * By default, MSG_PEEK is enabled unless the user calls either nl_socket_disable_msg_peek()/
865 * nl_socket_enable_msg_peek() or sets the message buffer size to a positive value.
866 * See capability NL_CAPABILITY_NL_RECVMSGS_PEEK_BY_DEFAULT for that.
867 *
868 * @return 0 on success or a negative error code.
869 */
870 int nl_socket_set_msg_buf_size(struct nl_sock *sk, size_t bufsize)
871 {
872 sk->s_bufsize = bufsize;
873
874 return 0;
875 }
876
877 /**
878 * Get default message buffer size of netlink socket.
879 * @arg sk Netlink socket.
880 *
881 * @return Size of default message buffer.
882 */
883 size_t nl_socket_get_msg_buf_size(struct nl_sock *sk)
884 {
885 return sk->s_bufsize;
886 }
887
888 /**
889 * Enable/disable credential passing on netlink socket.
890 * @arg sk Netlink socket.
891 * @arg state New state (0 - disabled, 1 - enabled)
892 *
893 * @return 0 on success or a negative error code
894 */
895 int nl_socket_set_passcred(struct nl_sock *sk, int state)
896 {
897 int err;
898
899 if (sk->s_fd == -1)
900 return -NLE_BAD_SOCK;
901
902 err = setsockopt(sk->s_fd, SOL_SOCKET, SO_PASSCRED,
903 &state, sizeof(state));
904 if (err < 0) {
905 NL_DBG(4, "nl_socket_set_passcred(%p): setsockopt() failed with %d (%s)\n",
906 sk, errno, nl_strerror_l(errno));
907 return -nl_syserr2nlerr(errno);
908 }
909
910 if (state)
911 sk->s_flags |= NL_SOCK_PASSCRED;
912 else
913 sk->s_flags &= ~NL_SOCK_PASSCRED;
914
915 return 0;
916 }
917
918 /**
919 * Enable/disable receival of additional packet information
920 * @arg sk Netlink socket.
921 * @arg state New state (0 - disabled, 1 - enabled)
922 *
923 * @return 0 on success or a negative error code
924 */
925 int nl_socket_recv_pktinfo(struct nl_sock *sk, int state)
926 {
927 int err;
928
929 if (sk->s_fd == -1)
930 return -NLE_BAD_SOCK;
931
932 err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_PKTINFO,
933 &state, sizeof(state));
934 if (err < 0) {
935 NL_DBG(4, "nl_socket_recv_pktinfo(%p): setsockopt() failed with %d (%s)\n",
936 sk, errno, nl_strerror_l(errno));
937 return -nl_syserr2nlerr(errno);
938 }
939
940 return 0;
941 }
942
943 /** @} */
944
945 /** @} */
nl_socket_enable_auto_ack
void nl_socket_enable_auto_ack(struct nl_sock *sk)
Enable automatic request for ACK (default)
Definition: socket.c:325
nl_socket_set_passcred
int nl_socket_set_passcred(struct nl_sock *sk, int state)
Enable/disable credential passing on netlink socket.
Definition: socket.c:895
nl_socket_drop_memberships
int nl_socket_drop_memberships(struct nl_sock *sk, int group,...)
Leave groups.
Definition: socket.c:485
NL_CB_CUSTOM
Customized handler specified by the user.
Definition: handlers.h:83
nl_socket_get_fd
int nl_socket_get_fd(const struct nl_sock *sk)
Return the file descriptor of the backing socket.
Definition: socket.c:584
nl_socket_disable_auto_ack
void nl_socket_disable_auto_ack(struct nl_sock *sk)
Disable automatic request for ACK.
Definition: socket.c:315
nl_socket_enable_msg_peek
void nl_socket_enable_msg_peek(struct nl_sock *sk)
Enable use of MSG_PEEK when reading from socket.
Definition: socket.c:723
nl_socket_set_local_port
void nl_socket_set_local_port(struct nl_sock *sk, uint32_t port)
Set local port of socket.
Definition: socket.c:404
nl_socket_modify_err_cb
int nl_socket_modify_err_cb(struct nl_sock *sk, enum nl_cb_kind kind, nl_recvmsg_err_cb_t func, void *arg)
Modify the error callback handler associated with the socket.
Definition: socket.c:787
nl_cb_kind
nl_cb_kind
Callback kinds.
Definition: handlers.h:75
nl_cb_set
int nl_cb_set(struct nl_cb *cb, enum nl_cb_type type, enum nl_cb_kind kind, nl_recvmsg_msg_cb_t func, void *arg)
Set up a callback.
Definition: handlers.c:294
nl_socket_alloc
struct nl_sock * nl_socket_alloc(void)
Allocate new netlink socket.
Definition: socket.c:206
nl_socket_modify_cb
int nl_socket_modify_cb(struct nl_sock *sk, enum nl_cb_type type, enum nl_cb_kind kind, nl_recvmsg_msg_cb_t func, void *arg)
Modify the callback handler associated with the socket.
Definition: socket.c:771
nl_socket_alloc_cb
struct nl_sock * nl_socket_alloc_cb(struct nl_cb *cb)
Allocate new socket with custom callbacks.
Definition: socket.c:232
nl_socket_disable_seq_check
void nl_socket_disable_seq_check(struct nl_sock *sk)
Disable sequence number checking.
Definition: socket.c:283
nl_socket_set_nonblocking
int nl_socket_set_nonblocking(const struct nl_sock *sk)
Set file descriptor of socket to non-blocking state.
Definition: socket.c:703
nl_recvmsg_err_cb_t
int(* nl_recvmsg_err_cb_t)(struct sockaddr_nl *nla, struct nlmsgerr *nlerr, void *arg)
nl_recvmsgs() callback for error message processing customization
Definition: handlers.h:53
nl_socket_free
void nl_socket_free(struct nl_sock *sk)
Free a netlink socket.
Definition: socket.c:244
nl_socket_use_seq
unsigned int nl_socket_use_seq(struct nl_sock *sk)
Use next sequence number.
Definition: socket.c:298
NL_CB_DEBUG
Debug handlers for debugging.
Definition: handlers.h:81
nl_socket_disable_msg_peek
void nl_socket_disable_msg_peek(struct nl_sock *sk)
Disable use of MSG_PEEK when reading from socket.
Definition: socket.c:734
nl_recvmsg_msg_cb_t
int(* nl_recvmsg_msg_cb_t)(struct nl_msg *msg, void *arg)
nl_recvmsgs() callback for message processing customization
Definition: handlers.h:44
NL_CB_SEQ_CHECK
Called instead of internal sequence number checking.
Definition: handlers.h:111
nl_socket_set_fd
int nl_socket_set_fd(struct nl_sock *sk, int protocol, int fd)
Set the socket file descriptor externally which initializes the socket similar to nl_connect().
Definition: socket.c:616
NL_OK
Proceed with wathever would come next.
Definition: handlers.h:64
nl_socket_set_msg_buf_size
int nl_socket_set_msg_buf_size(struct nl_sock *sk, size_t bufsize)
Set default message buffer size of netlink socket.
Definition: socket.c:870
nl_cb_type
nl_cb_type
Callback types.
Definition: handlers.h:93
nl_cb_alloc
struct nl_cb * nl_cb_alloc(enum nl_cb_kind kind)
Allocate a new callback handle.
Definition: handlers.c:202
nl_socket_set_buffer_size
int nl_socket_set_buffer_size(struct nl_sock *sk, int rxbuf, int txbuf)
Set socket buffer size of netlink socket.
Definition: socket.c:813
nl_join_groups
void nl_join_groups(struct nl_sock *sk, int groups)
Join multicast groups (deprecated)
Definition: socket.c:533
nl_socket_add_memberships
int nl_socket_add_memberships(struct nl_sock *sk, int group,...)
Join groups.
Definition: socket.c:435
NL_CB_DEFAULT
Default handlers (quiet)
Definition: handlers.h:77
nl_socket_recv_pktinfo
int nl_socket_recv_pktinfo(struct nl_sock *sk, int state)
Enable/disable receival of additional packet information.
Definition: socket.c:925
nl_socket_get_msg_buf_size
size_t nl_socket_get_msg_buf_size(struct nl_sock *sk)
Get default message buffer size of netlink socket.
Definition: socket.c:883
nl_cb_err
int nl_cb_err(struct nl_cb *cb, enum nl_cb_kind kind, nl_recvmsg_err_cb_t func, void *arg)
Set up an error callback.
Definition: handlers.c:344
NL_CB_VERBOSE
Verbose default handlers (error messages printed)
Definition: handlers.h:79