]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-netlink/rtnl-message.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2013 Tom Gundersen <teg@jklm.no>
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 #include <netinet/in.h>
22 #include <linux/if_addrlabel.h>
26 #include "sd-netlink.h"
28 #include "format-util.h"
30 #include "netlink-internal.h"
31 #include "netlink-types.h"
32 #include "netlink-util.h"
34 #include "socket-util.h"
37 int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message
*m
, unsigned char prefixlen
) {
40 assert_return(m
, -EINVAL
);
41 assert_return(m
->hdr
, -EINVAL
);
42 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
44 rtm
= NLMSG_DATA(m
->hdr
);
46 if ((rtm
->rtm_family
== AF_INET
&& prefixlen
> 32) ||
47 (rtm
->rtm_family
== AF_INET6
&& prefixlen
> 128))
50 rtm
->rtm_dst_len
= prefixlen
;
55 int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message
*m
, unsigned char prefixlen
) {
58 assert_return(m
, -EINVAL
);
59 assert_return(m
->hdr
, -EINVAL
);
60 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
62 rtm
= NLMSG_DATA(m
->hdr
);
64 if ((rtm
->rtm_family
== AF_INET
&& prefixlen
> 32) ||
65 (rtm
->rtm_family
== AF_INET6
&& prefixlen
> 128))
68 rtm
->rtm_src_len
= prefixlen
;
73 int sd_rtnl_message_route_set_scope(sd_netlink_message
*m
, unsigned char scope
) {
76 assert_return(m
, -EINVAL
);
77 assert_return(m
->hdr
, -EINVAL
);
78 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
80 rtm
= NLMSG_DATA(m
->hdr
);
82 rtm
->rtm_scope
= scope
;
87 int sd_rtnl_message_route_set_flags(sd_netlink_message
*m
, unsigned flags
) {
90 assert_return(m
, -EINVAL
);
91 assert_return(m
->hdr
, -EINVAL
);
92 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
94 rtm
= NLMSG_DATA(m
->hdr
);
96 rtm
->rtm_flags
= flags
;
101 int sd_rtnl_message_route_get_flags(sd_netlink_message
*m
, unsigned *flags
) {
104 assert_return(m
, -EINVAL
);
105 assert_return(m
->hdr
, -EINVAL
);
106 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
107 assert_return(flags
, -EINVAL
);
109 rtm
= NLMSG_DATA(m
->hdr
);
111 *flags
= rtm
->rtm_flags
;
116 int sd_rtnl_message_route_set_table(sd_netlink_message
*m
, unsigned char table
) {
119 assert_return(m
, -EINVAL
);
120 assert_return(m
->hdr
, -EINVAL
);
121 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
123 rtm
= NLMSG_DATA(m
->hdr
);
125 rtm
->rtm_table
= table
;
130 int sd_rtnl_message_route_get_family(sd_netlink_message
*m
, int *family
) {
133 assert_return(m
, -EINVAL
);
134 assert_return(m
->hdr
, -EINVAL
);
135 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
136 assert_return(family
, -EINVAL
);
138 rtm
= NLMSG_DATA(m
->hdr
);
140 *family
= rtm
->rtm_family
;
145 int sd_rtnl_message_route_set_family(sd_netlink_message
*m
, int family
) {
148 assert_return(m
, -EINVAL
);
149 assert_return(m
->hdr
, -EINVAL
);
150 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
152 rtm
= NLMSG_DATA(m
->hdr
);
154 rtm
->rtm_family
= family
;
159 int sd_rtnl_message_route_get_type(sd_netlink_message
*m
, unsigned char *type
) {
162 assert_return(m
, -EINVAL
);
163 assert_return(m
->hdr
, -EINVAL
);
164 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
165 assert_return(type
, -EINVAL
);
167 rtm
= NLMSG_DATA(m
->hdr
);
169 *type
= rtm
->rtm_type
;
174 int sd_rtnl_message_route_set_type(sd_netlink_message
*m
, unsigned char type
) {
177 assert_return(m
, -EINVAL
);
178 assert_return(m
->hdr
, -EINVAL
);
179 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
181 rtm
= NLMSG_DATA(m
->hdr
);
183 rtm
->rtm_type
= type
;
188 int sd_rtnl_message_route_get_protocol(sd_netlink_message
*m
, unsigned char *protocol
) {
191 assert_return(m
, -EINVAL
);
192 assert_return(m
->hdr
, -EINVAL
);
193 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
194 assert_return(protocol
, -EINVAL
);
196 rtm
= NLMSG_DATA(m
->hdr
);
198 *protocol
= rtm
->rtm_protocol
;
203 int sd_rtnl_message_route_get_scope(sd_netlink_message
*m
, unsigned char *scope
) {
206 assert_return(m
, -EINVAL
);
207 assert_return(m
->hdr
, -EINVAL
);
208 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
209 assert_return(scope
, -EINVAL
);
211 rtm
= NLMSG_DATA(m
->hdr
);
213 *scope
= rtm
->rtm_scope
;
218 int sd_rtnl_message_route_get_tos(sd_netlink_message
*m
, unsigned char *tos
) {
221 assert_return(m
, -EINVAL
);
222 assert_return(m
->hdr
, -EINVAL
);
223 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
224 assert_return(tos
, -EINVAL
);
226 rtm
= NLMSG_DATA(m
->hdr
);
233 int sd_rtnl_message_route_get_table(sd_netlink_message
*m
, unsigned char *table
) {
236 assert_return(m
, -EINVAL
);
237 assert_return(m
->hdr
, -EINVAL
);
238 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
239 assert_return(table
, -EINVAL
);
241 rtm
= NLMSG_DATA(m
->hdr
);
243 *table
= rtm
->rtm_table
;
248 int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message
*m
, unsigned char *dst_len
) {
251 assert_return(m
, -EINVAL
);
252 assert_return(m
->hdr
, -EINVAL
);
253 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
254 assert_return(dst_len
, -EINVAL
);
256 rtm
= NLMSG_DATA(m
->hdr
);
258 *dst_len
= rtm
->rtm_dst_len
;
263 int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message
*m
, unsigned char *src_len
) {
266 assert_return(m
, -EINVAL
);
267 assert_return(m
->hdr
, -EINVAL
);
268 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
269 assert_return(src_len
, -EINVAL
);
271 rtm
= NLMSG_DATA(m
->hdr
);
273 *src_len
= rtm
->rtm_src_len
;
278 int sd_rtnl_message_new_route(sd_netlink
*rtnl
, sd_netlink_message
**ret
,
279 uint16_t nlmsg_type
, int rtm_family
,
280 unsigned char rtm_protocol
) {
284 assert_return(rtnl_message_type_is_route(nlmsg_type
), -EINVAL
);
285 assert_return((nlmsg_type
== RTM_GETROUTE
&& rtm_family
== AF_UNSPEC
) ||
286 IN_SET(rtm_family
, AF_INET
, AF_INET6
), -EINVAL
);
287 assert_return(ret
, -EINVAL
);
289 r
= message_new(rtnl
, ret
, nlmsg_type
);
293 if (nlmsg_type
== RTM_NEWROUTE
)
294 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_APPEND
;
296 rtm
= NLMSG_DATA((*ret
)->hdr
);
298 rtm
->rtm_family
= rtm_family
;
299 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
300 rtm
->rtm_type
= RTN_UNICAST
;
301 rtm
->rtm_table
= RT_TABLE_MAIN
;
302 rtm
->rtm_protocol
= rtm_protocol
;
307 int sd_rtnl_message_neigh_set_flags(sd_netlink_message
*m
, uint8_t flags
) {
310 assert_return(m
, -EINVAL
);
311 assert_return(m
->hdr
, -EINVAL
);
312 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
314 ndm
= NLMSG_DATA(m
->hdr
);
315 ndm
->ndm_flags
|= flags
;
320 int sd_rtnl_message_neigh_set_state(sd_netlink_message
*m
, uint16_t state
) {
323 assert_return(m
, -EINVAL
);
324 assert_return(m
->hdr
, -EINVAL
);
325 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
327 ndm
= NLMSG_DATA(m
->hdr
);
328 ndm
->ndm_state
|= state
;
333 int sd_rtnl_message_neigh_get_flags(sd_netlink_message
*m
, uint8_t *flags
) {
336 assert_return(m
, -EINVAL
);
337 assert_return(m
->hdr
, -EINVAL
);
338 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
340 ndm
= NLMSG_DATA(m
->hdr
);
341 *flags
= ndm
->ndm_flags
;
346 int sd_rtnl_message_neigh_get_state(sd_netlink_message
*m
, uint16_t *state
) {
349 assert_return(m
, -EINVAL
);
350 assert_return(m
->hdr
, -EINVAL
);
351 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
353 ndm
= NLMSG_DATA(m
->hdr
);
354 *state
= ndm
->ndm_state
;
359 int sd_rtnl_message_neigh_get_family(sd_netlink_message
*m
, int *family
) {
362 assert_return(m
, -EINVAL
);
363 assert_return(m
->hdr
, -EINVAL
);
364 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
365 assert_return(family
, -EINVAL
);
367 ndm
= NLMSG_DATA(m
->hdr
);
369 *family
= ndm
->ndm_family
;
374 int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message
*m
, int *index
) {
377 assert_return(m
, -EINVAL
);
378 assert_return(m
->hdr
, -EINVAL
);
379 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
380 assert_return(index
, -EINVAL
);
382 ndm
= NLMSG_DATA(m
->hdr
);
384 *index
= ndm
->ndm_ifindex
;
389 int sd_rtnl_message_new_neigh(sd_netlink
*rtnl
, sd_netlink_message
**ret
, uint16_t nlmsg_type
, int index
, int ndm_family
) {
393 assert_return(rtnl_message_type_is_neigh(nlmsg_type
), -EINVAL
);
394 assert_return(IN_SET(ndm_family
, AF_INET
, AF_INET6
, PF_BRIDGE
), -EINVAL
);
395 assert_return(ret
, -EINVAL
);
397 r
= message_new(rtnl
, ret
, nlmsg_type
);
401 if (nlmsg_type
== RTM_NEWNEIGH
)
402 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_APPEND
;
404 ndm
= NLMSG_DATA((*ret
)->hdr
);
406 ndm
->ndm_family
= ndm_family
;
407 ndm
->ndm_ifindex
= index
;
412 int sd_rtnl_message_link_set_flags(sd_netlink_message
*m
, unsigned flags
, unsigned change
) {
413 struct ifinfomsg
*ifi
;
415 assert_return(m
, -EINVAL
);
416 assert_return(m
->hdr
, -EINVAL
);
417 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
418 assert_return(change
, -EINVAL
);
420 ifi
= NLMSG_DATA(m
->hdr
);
422 ifi
->ifi_flags
= flags
;
423 ifi
->ifi_change
= change
;
428 int sd_rtnl_message_link_set_type(sd_netlink_message
*m
, unsigned type
) {
429 struct ifinfomsg
*ifi
;
431 assert_return(m
, -EINVAL
);
432 assert_return(m
->hdr
, -EINVAL
);
433 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
435 ifi
= NLMSG_DATA(m
->hdr
);
437 ifi
->ifi_type
= type
;
442 int sd_rtnl_message_link_set_family(sd_netlink_message
*m
, unsigned family
) {
443 struct ifinfomsg
*ifi
;
445 assert_return(m
, -EINVAL
);
446 assert_return(m
->hdr
, -EINVAL
);
447 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
449 ifi
= NLMSG_DATA(m
->hdr
);
451 ifi
->ifi_family
= family
;
456 int sd_rtnl_message_new_link(sd_netlink
*rtnl
, sd_netlink_message
**ret
,
457 uint16_t nlmsg_type
, int index
) {
458 struct ifinfomsg
*ifi
;
461 assert_return(rtnl_message_type_is_link(nlmsg_type
), -EINVAL
);
462 assert_return(ret
, -EINVAL
);
464 r
= message_new(rtnl
, ret
, nlmsg_type
);
468 if (nlmsg_type
== RTM_NEWLINK
)
469 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_EXCL
;
471 ifi
= NLMSG_DATA((*ret
)->hdr
);
473 ifi
->ifi_family
= AF_UNSPEC
;
474 ifi
->ifi_index
= index
;
479 int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message
*m
, unsigned char prefixlen
) {
480 struct ifaddrmsg
*ifa
;
482 assert_return(m
, -EINVAL
);
483 assert_return(m
->hdr
, -EINVAL
);
484 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
486 ifa
= NLMSG_DATA(m
->hdr
);
488 if ((ifa
->ifa_family
== AF_INET
&& prefixlen
> 32) ||
489 (ifa
->ifa_family
== AF_INET6
&& prefixlen
> 128))
492 ifa
->ifa_prefixlen
= prefixlen
;
497 int sd_rtnl_message_addr_set_flags(sd_netlink_message
*m
, unsigned char flags
) {
498 struct ifaddrmsg
*ifa
;
500 assert_return(m
, -EINVAL
);
501 assert_return(m
->hdr
, -EINVAL
);
502 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
504 ifa
= NLMSG_DATA(m
->hdr
);
506 ifa
->ifa_flags
= flags
;
511 int sd_rtnl_message_addr_set_scope(sd_netlink_message
*m
, unsigned char scope
) {
512 struct ifaddrmsg
*ifa
;
514 assert_return(m
, -EINVAL
);
515 assert_return(m
->hdr
, -EINVAL
);
516 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
518 ifa
= NLMSG_DATA(m
->hdr
);
520 ifa
->ifa_scope
= scope
;
525 int sd_rtnl_message_addr_get_family(sd_netlink_message
*m
, int *family
) {
526 struct ifaddrmsg
*ifa
;
528 assert_return(m
, -EINVAL
);
529 assert_return(m
->hdr
, -EINVAL
);
530 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
531 assert_return(family
, -EINVAL
);
533 ifa
= NLMSG_DATA(m
->hdr
);
535 *family
= ifa
->ifa_family
;
540 int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message
*m
, unsigned char *prefixlen
) {
541 struct ifaddrmsg
*ifa
;
543 assert_return(m
, -EINVAL
);
544 assert_return(m
->hdr
, -EINVAL
);
545 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
546 assert_return(prefixlen
, -EINVAL
);
548 ifa
= NLMSG_DATA(m
->hdr
);
550 *prefixlen
= ifa
->ifa_prefixlen
;
555 int sd_rtnl_message_addr_get_scope(sd_netlink_message
*m
, unsigned char *scope
) {
556 struct ifaddrmsg
*ifa
;
558 assert_return(m
, -EINVAL
);
559 assert_return(m
->hdr
, -EINVAL
);
560 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
561 assert_return(scope
, -EINVAL
);
563 ifa
= NLMSG_DATA(m
->hdr
);
565 *scope
= ifa
->ifa_scope
;
570 int sd_rtnl_message_addr_get_flags(sd_netlink_message
*m
, unsigned char *flags
) {
571 struct ifaddrmsg
*ifa
;
573 assert_return(m
, -EINVAL
);
574 assert_return(m
->hdr
, -EINVAL
);
575 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
576 assert_return(flags
, -EINVAL
);
578 ifa
= NLMSG_DATA(m
->hdr
);
580 *flags
= ifa
->ifa_flags
;
585 int sd_rtnl_message_addr_get_ifindex(sd_netlink_message
*m
, int *ifindex
) {
586 struct ifaddrmsg
*ifa
;
588 assert_return(m
, -EINVAL
);
589 assert_return(m
->hdr
, -EINVAL
);
590 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
591 assert_return(ifindex
, -EINVAL
);
593 ifa
= NLMSG_DATA(m
->hdr
);
595 *ifindex
= ifa
->ifa_index
;
600 int sd_rtnl_message_new_addr(sd_netlink
*rtnl
, sd_netlink_message
**ret
,
601 uint16_t nlmsg_type
, int index
,
603 struct ifaddrmsg
*ifa
;
606 assert_return(rtnl_message_type_is_addr(nlmsg_type
), -EINVAL
);
607 assert_return((nlmsg_type
== RTM_GETADDR
&& index
== 0) ||
609 assert_return((nlmsg_type
== RTM_GETADDR
&& family
== AF_UNSPEC
) ||
610 IN_SET(family
, AF_INET
, AF_INET6
), -EINVAL
);
611 assert_return(ret
, -EINVAL
);
613 r
= message_new(rtnl
, ret
, nlmsg_type
);
617 if (nlmsg_type
== RTM_GETADDR
)
618 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_DUMP
;
620 ifa
= NLMSG_DATA((*ret
)->hdr
);
622 ifa
->ifa_index
= index
;
623 ifa
->ifa_family
= family
;
624 if (family
== AF_INET
)
625 ifa
->ifa_prefixlen
= 32;
626 else if (family
== AF_INET6
)
627 ifa
->ifa_prefixlen
= 128;
632 int sd_rtnl_message_new_addr_update(sd_netlink
*rtnl
, sd_netlink_message
**ret
,
633 int index
, int family
) {
636 r
= sd_rtnl_message_new_addr(rtnl
, ret
, RTM_NEWADDR
, index
, family
);
640 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_REPLACE
;
645 int sd_rtnl_message_link_get_ifindex(sd_netlink_message
*m
, int *ifindex
) {
646 struct ifinfomsg
*ifi
;
648 assert_return(m
, -EINVAL
);
649 assert_return(m
->hdr
, -EINVAL
);
650 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
651 assert_return(ifindex
, -EINVAL
);
653 ifi
= NLMSG_DATA(m
->hdr
);
655 *ifindex
= ifi
->ifi_index
;
660 int sd_rtnl_message_link_get_flags(sd_netlink_message
*m
, unsigned *flags
) {
661 struct ifinfomsg
*ifi
;
663 assert_return(m
, -EINVAL
);
664 assert_return(m
->hdr
, -EINVAL
);
665 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
666 assert_return(flags
, -EINVAL
);
668 ifi
= NLMSG_DATA(m
->hdr
);
670 *flags
= ifi
->ifi_flags
;
675 int sd_rtnl_message_link_get_type(sd_netlink_message
*m
, unsigned short *type
) {
676 struct ifinfomsg
*ifi
;
678 assert_return(m
, -EINVAL
);
679 assert_return(m
->hdr
, -EINVAL
);
680 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
681 assert_return(type
, -EINVAL
);
683 ifi
= NLMSG_DATA(m
->hdr
);
685 *type
= ifi
->ifi_type
;
690 int sd_rtnl_message_get_family(sd_netlink_message
*m
, int *family
) {
691 assert_return(m
, -EINVAL
);
692 assert_return(family
, -EINVAL
);
696 if (rtnl_message_type_is_link(m
->hdr
->nlmsg_type
)) {
697 struct ifinfomsg
*ifi
;
699 ifi
= NLMSG_DATA(m
->hdr
);
701 *family
= ifi
->ifi_family
;
704 } else if (rtnl_message_type_is_route(m
->hdr
->nlmsg_type
)) {
707 rtm
= NLMSG_DATA(m
->hdr
);
709 *family
= rtm
->rtm_family
;
712 } else if (rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
)) {
715 ndm
= NLMSG_DATA(m
->hdr
);
717 *family
= ndm
->ndm_family
;
720 } else if (rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
)) {
721 struct ifaddrmsg
*ifa
;
723 ifa
= NLMSG_DATA(m
->hdr
);
725 *family
= ifa
->ifa_family
;
728 } else if (rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
)) {
731 rtm
= NLMSG_DATA(m
->hdr
);
733 *family
= rtm
->rtm_family
;
741 int sd_rtnl_message_new_addrlabel(sd_netlink
*rtnl
, sd_netlink_message
**ret
, uint16_t nlmsg_type
, int ifindex
, int ifal_family
) {
742 struct ifaddrlblmsg
*addrlabel
;
745 assert_return(rtnl_message_type_is_addrlabel(nlmsg_type
), -EINVAL
);
746 assert_return(ret
, -EINVAL
);
748 r
= message_new(rtnl
, ret
, nlmsg_type
);
752 if (nlmsg_type
== RTM_NEWADDRLABEL
)
753 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_EXCL
;
755 addrlabel
= NLMSG_DATA((*ret
)->hdr
);
757 addrlabel
->ifal_family
= ifal_family
;
758 addrlabel
->ifal_index
= ifindex
;
763 int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message
*m
, unsigned char prefixlen
) {
764 struct ifaddrlblmsg
*addrlabel
;
766 assert_return(m
, -EINVAL
);
767 assert_return(m
->hdr
, -EINVAL
);
768 assert_return(rtnl_message_type_is_addrlabel(m
->hdr
->nlmsg_type
), -EINVAL
);
770 addrlabel
= NLMSG_DATA(m
->hdr
);
775 addrlabel
->ifal_prefixlen
= prefixlen
;
780 int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message
*m
, unsigned char *prefixlen
) {
781 struct ifaddrlblmsg
*addrlabel
;
783 assert_return(m
, -EINVAL
);
784 assert_return(m
->hdr
, -EINVAL
);
785 assert_return(rtnl_message_type_is_addrlabel(m
->hdr
->nlmsg_type
), -EINVAL
);
787 addrlabel
= NLMSG_DATA(m
->hdr
);
789 *prefixlen
= addrlabel
->ifal_prefixlen
;
794 int sd_rtnl_message_new_routing_policy_rule(sd_netlink
*rtnl
, sd_netlink_message
**ret
, uint16_t nlmsg_type
, int ifal_family
) {
798 assert_return(rtnl_message_type_is_routing_policy_rule(nlmsg_type
), -EINVAL
);
799 assert_return(ret
, -EINVAL
);
801 r
= message_new(rtnl
, ret
, nlmsg_type
);
805 if (nlmsg_type
== RTM_NEWRULE
)
806 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_EXCL
;
808 rtm
= NLMSG_DATA((*ret
)->hdr
);
809 rtm
->rtm_family
= ifal_family
;
810 rtm
->rtm_protocol
= RTPROT_BOOT
;
811 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
812 rtm
->rtm_type
= RTN_UNICAST
;
817 int sd_rtnl_message_routing_policy_rule_set_tos(sd_netlink_message
*m
, unsigned char tos
) {
818 struct rtmsg
*routing_policy_rule
;
820 assert_return(m
, -EINVAL
);
821 assert_return(m
->hdr
, -EINVAL
);
822 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
824 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
826 routing_policy_rule
->rtm_tos
= tos
;
831 int sd_rtnl_message_routing_policy_rule_get_tos(sd_netlink_message
*m
, unsigned char *tos
) {
832 struct rtmsg
*routing_policy_rule
;
834 assert_return(m
, -EINVAL
);
835 assert_return(m
->hdr
, -EINVAL
);
836 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
838 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
840 *tos
= routing_policy_rule
->rtm_tos
;
845 int sd_rtnl_message_routing_policy_rule_set_table(sd_netlink_message
*m
, unsigned char table
) {
846 struct rtmsg
*routing_policy_rule
;
848 assert_return(m
, -EINVAL
);
849 assert_return(m
->hdr
, -EINVAL
);
850 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
852 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
854 routing_policy_rule
->rtm_table
= table
;
859 int sd_rtnl_message_routing_policy_rule_get_table(sd_netlink_message
*m
, unsigned char *table
) {
860 struct rtmsg
*routing_policy_rule
;
862 assert_return(m
, -EINVAL
);
863 assert_return(m
->hdr
, -EINVAL
);
864 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
866 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
868 *table
= routing_policy_rule
->rtm_table
;
873 int sd_rtnl_message_routing_policy_rule_set_rtm_type(sd_netlink_message
*m
, unsigned char type
) {
874 struct rtmsg
*routing_policy_rule
;
876 assert_return(m
, -EINVAL
);
877 assert_return(m
->hdr
, -EINVAL
);
878 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
880 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
882 routing_policy_rule
->rtm_type
= type
;
887 int sd_rtnl_message_routing_policy_rule_get_rtm_type(sd_netlink_message
*m
, unsigned char *type
) {
888 struct rtmsg
*routing_policy_rule
;
890 assert_return(m
, -EINVAL
);
891 assert_return(m
->hdr
, -EINVAL
);
892 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
894 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
896 *type
= routing_policy_rule
->rtm_type
;
901 int sd_rtnl_message_routing_policy_rule_set_rtm_dst_prefixlen(sd_netlink_message
*m
, unsigned char len
) {
902 struct rtmsg
*routing_policy_rule
;
904 assert_return(m
, -EINVAL
);
905 assert_return(m
->hdr
, -EINVAL
);
906 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
908 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
910 routing_policy_rule
->rtm_dst_len
= len
;
915 int sd_rtnl_message_routing_policy_rule_get_rtm_dst_prefixlen(sd_netlink_message
*m
, unsigned char *len
) {
916 struct rtmsg
*routing_policy_rule
;
918 assert_return(m
, -EINVAL
);
919 assert_return(m
->hdr
, -EINVAL
);
920 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
922 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
924 *len
= routing_policy_rule
->rtm_dst_len
;
929 int sd_rtnl_message_routing_policy_rule_set_rtm_src_prefixlen(sd_netlink_message
*m
, unsigned char len
) {
930 struct rtmsg
*routing_policy_rule
;
932 assert_return(m
, -EINVAL
);
933 assert_return(m
->hdr
, -EINVAL
);
934 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
936 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
938 routing_policy_rule
->rtm_src_len
= len
;
943 int sd_rtnl_message_routing_policy_rule_get_rtm_src_prefixlen(sd_netlink_message
*m
, unsigned char *len
) {
944 struct rtmsg
*routing_policy_rule
;
946 assert_return(m
, -EINVAL
);
947 assert_return(m
->hdr
, -EINVAL
);
948 assert_return(rtnl_message_type_is_routing_policy_rule(m
->hdr
->nlmsg_type
), -EINVAL
);
950 routing_policy_rule
= NLMSG_DATA(m
->hdr
);
952 *len
= routing_policy_rule
->rtm_src_len
;