]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-netlink/rtnl-message.c
2 This file is part of systemd.
4 Copyright 2013 Tom Gundersen <teg@jklm.no>
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 #include <netinet/in.h>
21 #include <linux/if_addrlabel.h>
25 #include "sd-netlink.h"
27 #include "format-util.h"
29 #include "netlink-internal.h"
30 #include "netlink-types.h"
31 #include "netlink-util.h"
33 #include "socket-util.h"
36 int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message
*m
, unsigned char prefixlen
) {
39 assert_return(m
, -EINVAL
);
40 assert_return(m
->hdr
, -EINVAL
);
41 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
43 rtm
= NLMSG_DATA(m
->hdr
);
45 if ((rtm
->rtm_family
== AF_INET
&& prefixlen
> 32) ||
46 (rtm
->rtm_family
== AF_INET6
&& prefixlen
> 128))
49 rtm
->rtm_dst_len
= prefixlen
;
54 int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message
*m
, unsigned char prefixlen
) {
57 assert_return(m
, -EINVAL
);
58 assert_return(m
->hdr
, -EINVAL
);
59 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
61 rtm
= NLMSG_DATA(m
->hdr
);
63 if ((rtm
->rtm_family
== AF_INET
&& prefixlen
> 32) ||
64 (rtm
->rtm_family
== AF_INET6
&& prefixlen
> 128))
67 rtm
->rtm_src_len
= prefixlen
;
72 int sd_rtnl_message_route_set_scope(sd_netlink_message
*m
, unsigned char scope
) {
75 assert_return(m
, -EINVAL
);
76 assert_return(m
->hdr
, -EINVAL
);
77 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
79 rtm
= NLMSG_DATA(m
->hdr
);
81 rtm
->rtm_scope
= scope
;
86 int sd_rtnl_message_route_set_flags(sd_netlink_message
*m
, unsigned flags
) {
89 assert_return(m
, -EINVAL
);
90 assert_return(m
->hdr
, -EINVAL
);
91 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
93 rtm
= NLMSG_DATA(m
->hdr
);
95 rtm
->rtm_flags
= flags
;
100 int sd_rtnl_message_route_get_flags(sd_netlink_message
*m
, unsigned *flags
) {
103 assert_return(m
, -EINVAL
);
104 assert_return(m
->hdr
, -EINVAL
);
105 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
106 assert_return(flags
, -EINVAL
);
108 rtm
= NLMSG_DATA(m
->hdr
);
110 *flags
= rtm
->rtm_flags
;
115 int sd_rtnl_message_route_set_table(sd_netlink_message
*m
, unsigned char table
) {
118 assert_return(m
, -EINVAL
);
119 assert_return(m
->hdr
, -EINVAL
);
120 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
122 rtm
= NLMSG_DATA(m
->hdr
);
124 rtm
->rtm_table
= table
;
129 int sd_rtnl_message_route_get_family(sd_netlink_message
*m
, int *family
) {
132 assert_return(m
, -EINVAL
);
133 assert_return(m
->hdr
, -EINVAL
);
134 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
135 assert_return(family
, -EINVAL
);
137 rtm
= NLMSG_DATA(m
->hdr
);
139 *family
= rtm
->rtm_family
;
144 int sd_rtnl_message_route_set_family(sd_netlink_message
*m
, int family
) {
147 assert_return(m
, -EINVAL
);
148 assert_return(m
->hdr
, -EINVAL
);
149 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
151 rtm
= NLMSG_DATA(m
->hdr
);
153 rtm
->rtm_family
= family
;
158 int sd_rtnl_message_route_get_protocol(sd_netlink_message
*m
, unsigned char *protocol
) {
161 assert_return(m
, -EINVAL
);
162 assert_return(m
->hdr
, -EINVAL
);
163 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
164 assert_return(protocol
, -EINVAL
);
166 rtm
= NLMSG_DATA(m
->hdr
);
168 *protocol
= rtm
->rtm_protocol
;
173 int sd_rtnl_message_route_get_scope(sd_netlink_message
*m
, unsigned char *scope
) {
176 assert_return(m
, -EINVAL
);
177 assert_return(m
->hdr
, -EINVAL
);
178 assert_return(rtnl_message_type_is_route(m
->hdr
->nlmsg_type
), -EINVAL
);
179 assert_return(scope
, -EINVAL
);
181 rtm
= NLMSG_DATA(m
->hdr
);
183 *scope
= rtm
->rtm_scope
;
188 int sd_rtnl_message_route_get_tos(sd_netlink_message
*m
, unsigned char *tos
) {
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(tos
, -EINVAL
);
196 rtm
= NLMSG_DATA(m
->hdr
);
203 int sd_rtnl_message_route_get_table(sd_netlink_message
*m
, unsigned char *table
) {
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(table
, -EINVAL
);
211 rtm
= NLMSG_DATA(m
->hdr
);
213 *table
= rtm
->rtm_table
;
218 int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message
*m
, unsigned char *dst_len
) {
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(dst_len
, -EINVAL
);
226 rtm
= NLMSG_DATA(m
->hdr
);
228 *dst_len
= rtm
->rtm_dst_len
;
233 int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message
*m
, unsigned char *src_len
) {
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(src_len
, -EINVAL
);
241 rtm
= NLMSG_DATA(m
->hdr
);
243 *src_len
= rtm
->rtm_src_len
;
248 int sd_rtnl_message_new_route(sd_netlink
*rtnl
, sd_netlink_message
**ret
,
249 uint16_t nlmsg_type
, int rtm_family
,
250 unsigned char rtm_protocol
) {
254 assert_return(rtnl_message_type_is_route(nlmsg_type
), -EINVAL
);
255 assert_return((nlmsg_type
== RTM_GETROUTE
&& rtm_family
== AF_UNSPEC
) ||
256 rtm_family
== AF_INET
|| rtm_family
== AF_INET6
, -EINVAL
);
257 assert_return(ret
, -EINVAL
);
259 r
= message_new(rtnl
, ret
, nlmsg_type
);
263 if (nlmsg_type
== RTM_NEWROUTE
)
264 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_APPEND
;
266 rtm
= NLMSG_DATA((*ret
)->hdr
);
268 rtm
->rtm_family
= rtm_family
;
269 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
270 rtm
->rtm_type
= RTN_UNICAST
;
271 rtm
->rtm_table
= RT_TABLE_MAIN
;
272 rtm
->rtm_protocol
= rtm_protocol
;
277 int sd_rtnl_message_neigh_set_flags(sd_netlink_message
*m
, uint8_t flags
) {
280 assert_return(m
, -EINVAL
);
281 assert_return(m
->hdr
, -EINVAL
);
282 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
284 ndm
= NLMSG_DATA(m
->hdr
);
285 ndm
->ndm_flags
|= flags
;
290 int sd_rtnl_message_neigh_set_state(sd_netlink_message
*m
, uint16_t state
) {
293 assert_return(m
, -EINVAL
);
294 assert_return(m
->hdr
, -EINVAL
);
295 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
297 ndm
= NLMSG_DATA(m
->hdr
);
298 ndm
->ndm_state
|= state
;
303 int sd_rtnl_message_neigh_get_flags(sd_netlink_message
*m
, uint8_t *flags
) {
306 assert_return(m
, -EINVAL
);
307 assert_return(m
->hdr
, -EINVAL
);
308 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
310 ndm
= NLMSG_DATA(m
->hdr
);
311 *flags
= ndm
->ndm_flags
;
316 int sd_rtnl_message_neigh_get_state(sd_netlink_message
*m
, uint16_t *state
) {
319 assert_return(m
, -EINVAL
);
320 assert_return(m
->hdr
, -EINVAL
);
321 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
323 ndm
= NLMSG_DATA(m
->hdr
);
324 *state
= ndm
->ndm_state
;
329 int sd_rtnl_message_neigh_get_family(sd_netlink_message
*m
, int *family
) {
332 assert_return(m
, -EINVAL
);
333 assert_return(m
->hdr
, -EINVAL
);
334 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
335 assert_return(family
, -EINVAL
);
337 ndm
= NLMSG_DATA(m
->hdr
);
339 *family
= ndm
->ndm_family
;
344 int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message
*m
, int *index
) {
347 assert_return(m
, -EINVAL
);
348 assert_return(m
->hdr
, -EINVAL
);
349 assert_return(rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
), -EINVAL
);
350 assert_return(index
, -EINVAL
);
352 ndm
= NLMSG_DATA(m
->hdr
);
354 *index
= ndm
->ndm_ifindex
;
359 int sd_rtnl_message_new_neigh(sd_netlink
*rtnl
, sd_netlink_message
**ret
, uint16_t nlmsg_type
, int index
, int ndm_family
) {
363 assert_return(rtnl_message_type_is_neigh(nlmsg_type
), -EINVAL
);
364 assert_return(ndm_family
== AF_INET
||
365 ndm_family
== AF_INET6
||
366 ndm_family
== PF_BRIDGE
, -EINVAL
);
367 assert_return(ret
, -EINVAL
);
369 r
= message_new(rtnl
, ret
, nlmsg_type
);
373 if (nlmsg_type
== RTM_NEWNEIGH
)
374 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_APPEND
;
376 ndm
= NLMSG_DATA((*ret
)->hdr
);
378 ndm
->ndm_family
= ndm_family
;
379 ndm
->ndm_ifindex
= index
;
384 int sd_rtnl_message_link_set_flags(sd_netlink_message
*m
, unsigned flags
, unsigned change
) {
385 struct ifinfomsg
*ifi
;
387 assert_return(m
, -EINVAL
);
388 assert_return(m
->hdr
, -EINVAL
);
389 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
390 assert_return(change
, -EINVAL
);
392 ifi
= NLMSG_DATA(m
->hdr
);
394 ifi
->ifi_flags
= flags
;
395 ifi
->ifi_change
= change
;
400 int sd_rtnl_message_link_set_type(sd_netlink_message
*m
, unsigned type
) {
401 struct ifinfomsg
*ifi
;
403 assert_return(m
, -EINVAL
);
404 assert_return(m
->hdr
, -EINVAL
);
405 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
407 ifi
= NLMSG_DATA(m
->hdr
);
409 ifi
->ifi_type
= type
;
414 int sd_rtnl_message_link_set_family(sd_netlink_message
*m
, unsigned family
) {
415 struct ifinfomsg
*ifi
;
417 assert_return(m
, -EINVAL
);
418 assert_return(m
->hdr
, -EINVAL
);
419 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
421 ifi
= NLMSG_DATA(m
->hdr
);
423 ifi
->ifi_family
= family
;
428 int sd_rtnl_message_new_link(sd_netlink
*rtnl
, sd_netlink_message
**ret
,
429 uint16_t nlmsg_type
, int index
) {
430 struct ifinfomsg
*ifi
;
433 assert_return(rtnl_message_type_is_link(nlmsg_type
), -EINVAL
);
434 assert_return(ret
, -EINVAL
);
436 r
= message_new(rtnl
, ret
, nlmsg_type
);
440 if (nlmsg_type
== RTM_NEWLINK
)
441 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_EXCL
;
443 ifi
= NLMSG_DATA((*ret
)->hdr
);
445 ifi
->ifi_family
= AF_UNSPEC
;
446 ifi
->ifi_index
= index
;
451 int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message
*m
, unsigned char prefixlen
) {
452 struct ifaddrmsg
*ifa
;
454 assert_return(m
, -EINVAL
);
455 assert_return(m
->hdr
, -EINVAL
);
456 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
458 ifa
= NLMSG_DATA(m
->hdr
);
460 if ((ifa
->ifa_family
== AF_INET
&& prefixlen
> 32) ||
461 (ifa
->ifa_family
== AF_INET6
&& prefixlen
> 128))
464 ifa
->ifa_prefixlen
= prefixlen
;
469 int sd_rtnl_message_addr_set_flags(sd_netlink_message
*m
, unsigned char flags
) {
470 struct ifaddrmsg
*ifa
;
472 assert_return(m
, -EINVAL
);
473 assert_return(m
->hdr
, -EINVAL
);
474 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
476 ifa
= NLMSG_DATA(m
->hdr
);
478 ifa
->ifa_flags
= flags
;
483 int sd_rtnl_message_addr_set_scope(sd_netlink_message
*m
, unsigned char scope
) {
484 struct ifaddrmsg
*ifa
;
486 assert_return(m
, -EINVAL
);
487 assert_return(m
->hdr
, -EINVAL
);
488 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
490 ifa
= NLMSG_DATA(m
->hdr
);
492 ifa
->ifa_scope
= scope
;
497 int sd_rtnl_message_addr_get_family(sd_netlink_message
*m
, int *family
) {
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
);
503 assert_return(family
, -EINVAL
);
505 ifa
= NLMSG_DATA(m
->hdr
);
507 *family
= ifa
->ifa_family
;
512 int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message
*m
, unsigned char *prefixlen
) {
513 struct ifaddrmsg
*ifa
;
515 assert_return(m
, -EINVAL
);
516 assert_return(m
->hdr
, -EINVAL
);
517 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
518 assert_return(prefixlen
, -EINVAL
);
520 ifa
= NLMSG_DATA(m
->hdr
);
522 *prefixlen
= ifa
->ifa_prefixlen
;
527 int sd_rtnl_message_addr_get_scope(sd_netlink_message
*m
, unsigned char *scope
) {
528 struct ifaddrmsg
*ifa
;
530 assert_return(m
, -EINVAL
);
531 assert_return(m
->hdr
, -EINVAL
);
532 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
533 assert_return(scope
, -EINVAL
);
535 ifa
= NLMSG_DATA(m
->hdr
);
537 *scope
= ifa
->ifa_scope
;
542 int sd_rtnl_message_addr_get_flags(sd_netlink_message
*m
, unsigned char *flags
) {
543 struct ifaddrmsg
*ifa
;
545 assert_return(m
, -EINVAL
);
546 assert_return(m
->hdr
, -EINVAL
);
547 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
548 assert_return(flags
, -EINVAL
);
550 ifa
= NLMSG_DATA(m
->hdr
);
552 *flags
= ifa
->ifa_flags
;
557 int sd_rtnl_message_addr_get_ifindex(sd_netlink_message
*m
, int *ifindex
) {
558 struct ifaddrmsg
*ifa
;
560 assert_return(m
, -EINVAL
);
561 assert_return(m
->hdr
, -EINVAL
);
562 assert_return(rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
), -EINVAL
);
563 assert_return(ifindex
, -EINVAL
);
565 ifa
= NLMSG_DATA(m
->hdr
);
567 *ifindex
= ifa
->ifa_index
;
572 int sd_rtnl_message_new_addr(sd_netlink
*rtnl
, sd_netlink_message
**ret
,
573 uint16_t nlmsg_type
, int index
,
575 struct ifaddrmsg
*ifa
;
578 assert_return(rtnl_message_type_is_addr(nlmsg_type
), -EINVAL
);
579 assert_return((nlmsg_type
== RTM_GETADDR
&& index
== 0) ||
581 assert_return((nlmsg_type
== RTM_GETADDR
&& family
== AF_UNSPEC
) ||
582 family
== AF_INET
|| family
== AF_INET6
, -EINVAL
);
583 assert_return(ret
, -EINVAL
);
585 r
= message_new(rtnl
, ret
, nlmsg_type
);
589 if (nlmsg_type
== RTM_GETADDR
)
590 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_DUMP
;
592 ifa
= NLMSG_DATA((*ret
)->hdr
);
594 ifa
->ifa_index
= index
;
595 ifa
->ifa_family
= family
;
596 if (family
== AF_INET
)
597 ifa
->ifa_prefixlen
= 32;
598 else if (family
== AF_INET6
)
599 ifa
->ifa_prefixlen
= 128;
604 int sd_rtnl_message_new_addr_update(sd_netlink
*rtnl
, sd_netlink_message
**ret
,
605 int index
, int family
) {
608 r
= sd_rtnl_message_new_addr(rtnl
, ret
, RTM_NEWADDR
, index
, family
);
612 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_REPLACE
;
617 int sd_rtnl_message_link_get_ifindex(sd_netlink_message
*m
, int *ifindex
) {
618 struct ifinfomsg
*ifi
;
620 assert_return(m
, -EINVAL
);
621 assert_return(m
->hdr
, -EINVAL
);
622 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
623 assert_return(ifindex
, -EINVAL
);
625 ifi
= NLMSG_DATA(m
->hdr
);
627 *ifindex
= ifi
->ifi_index
;
632 int sd_rtnl_message_link_get_flags(sd_netlink_message
*m
, unsigned *flags
) {
633 struct ifinfomsg
*ifi
;
635 assert_return(m
, -EINVAL
);
636 assert_return(m
->hdr
, -EINVAL
);
637 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
638 assert_return(flags
, -EINVAL
);
640 ifi
= NLMSG_DATA(m
->hdr
);
642 *flags
= ifi
->ifi_flags
;
647 int sd_rtnl_message_link_get_type(sd_netlink_message
*m
, unsigned short *type
) {
648 struct ifinfomsg
*ifi
;
650 assert_return(m
, -EINVAL
);
651 assert_return(m
->hdr
, -EINVAL
);
652 assert_return(rtnl_message_type_is_link(m
->hdr
->nlmsg_type
), -EINVAL
);
653 assert_return(type
, -EINVAL
);
655 ifi
= NLMSG_DATA(m
->hdr
);
657 *type
= ifi
->ifi_type
;
662 int sd_rtnl_message_get_family(sd_netlink_message
*m
, int *family
) {
663 assert_return(m
, -EINVAL
);
664 assert_return(family
, -EINVAL
);
668 if (rtnl_message_type_is_link(m
->hdr
->nlmsg_type
)) {
669 struct ifinfomsg
*ifi
;
671 ifi
= NLMSG_DATA(m
->hdr
);
673 *family
= ifi
->ifi_family
;
676 } else if (rtnl_message_type_is_route(m
->hdr
->nlmsg_type
)) {
679 rtm
= NLMSG_DATA(m
->hdr
);
681 *family
= rtm
->rtm_family
;
684 } else if (rtnl_message_type_is_neigh(m
->hdr
->nlmsg_type
)) {
687 ndm
= NLMSG_DATA(m
->hdr
);
689 *family
= ndm
->ndm_family
;
692 } else if (rtnl_message_type_is_addr(m
->hdr
->nlmsg_type
)) {
693 struct ifaddrmsg
*ifa
;
695 ifa
= NLMSG_DATA(m
->hdr
);
697 *family
= ifa
->ifa_family
;
705 int sd_rtnl_message_new_addrlabel(sd_netlink
*rtnl
, sd_netlink_message
**ret
, uint16_t nlmsg_type
, int ifindex
, int ifal_family
) {
706 struct ifaddrlblmsg
*addrlabel
;
709 assert_return(rtnl_message_type_is_addrlabel(nlmsg_type
), -EINVAL
);
710 assert_return(ret
, -EINVAL
);
712 r
= message_new(rtnl
, ret
, nlmsg_type
);
716 if (nlmsg_type
== RTM_NEWADDRLABEL
)
717 (*ret
)->hdr
->nlmsg_flags
|= NLM_F_CREATE
| NLM_F_EXCL
;
719 addrlabel
= NLMSG_DATA((*ret
)->hdr
);
721 addrlabel
->ifal_family
= ifal_family
;
722 addrlabel
->ifal_index
= ifindex
;
727 int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message
*m
, unsigned char prefixlen
) {
728 struct ifaddrlblmsg
*addrlabel
;
730 assert_return(m
, -EINVAL
);
731 assert_return(m
->hdr
, -EINVAL
);
732 assert_return(rtnl_message_type_is_addrlabel(m
->hdr
->nlmsg_type
), -EINVAL
);
734 addrlabel
= NLMSG_DATA(m
->hdr
);
739 addrlabel
->ifal_prefixlen
= prefixlen
;
744 int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message
*m
, unsigned char *prefixlen
) {
745 struct ifaddrlblmsg
*addrlabel
;
747 assert_return(m
, -EINVAL
);
748 assert_return(m
->hdr
, -EINVAL
);
749 assert_return(rtnl_message_type_is_addrlabel(m
->hdr
->nlmsg_type
), -EINVAL
);
751 addrlabel
= NLMSG_DATA(m
->hdr
);
753 *prefixlen
= addrlabel
->ifal_prefixlen
;