]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/libsystemd/sd-netlink/netlink-message.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
basic/include: replace _Static_assert() with static_assert()
[thirdparty/systemd.git] / src / libsystemd / sd-netlink / netlink-message.c
... / ...
CommitLineData
1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3#include <netinet/in.h>
4
5#include "sd-netlink.h"
6
7#include "alloc-util.h"
8#include "ether-addr-util.h"
9#include "log.h"
10#include "memory-util.h"
11#include "netlink-internal.h"
12#include "netlink-types.h"
13#include "netlink-util.h"
14#include "socket-util.h"
15#include "string-util.h"
16#include "strv.h"
17
18#define GET_CONTAINER(m, i) ((struct rtattr*)((uint8_t*)(m)->hdr + (m)->containers[i].offset))
19
20int message_new_empty(sd_netlink *nl, sd_netlink_message **ret) {
21 sd_netlink_message *m;
22
23 assert(nl);
24 assert(ret);
25
26 /* Note that 'nl' is currently unused, if we start using it internally we must take care to
27 * avoid problems due to mutual references between buses and their queued messages. See sd-bus. */
28
29 m = new(sd_netlink_message, 1);
30 if (!m)
31 return -ENOMEM;
32
33 *m = (sd_netlink_message) {
34 .n_ref = 1,
35 .protocol = nl->protocol,
36 .sealed = false,
37 };
38
39 *ret = m;
40 return 0;
41}
42
43int message_new_full(
44 sd_netlink *nl,
45 uint16_t nlmsg_type,
46 uint16_t nlmsg_flags,
47 const NLAPolicySet *policy_set,
48 size_t header_size,
49 sd_netlink_message **ret) {
50
51 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
52 size_t size;
53 int r;
54
55 assert(nl);
56 assert(policy_set);
57 assert(ret);
58
59 size = NLMSG_SPACE(header_size);
60 assert(size >= sizeof(struct nlmsghdr));
61
62 r = message_new_empty(nl, &m);
63 if (r < 0)
64 return r;
65
66 m->containers[0].policy_set = policy_set;
67
68 m->hdr = malloc0(size);
69 if (!m->hdr)
70 return -ENOMEM;
71
72 m->hdr->nlmsg_flags = nlmsg_flags;
73 m->hdr->nlmsg_len = size;
74 m->hdr->nlmsg_type = nlmsg_type;
75
76 *ret = TAKE_PTR(m);
77 return 0;
78}
79
80int message_new(sd_netlink *nl, sd_netlink_message **ret, uint16_t nlmsg_type, uint16_t nlmsg_flags) {
81 const NLAPolicySet *policy_set;
82 size_t size;
83 int r;
84
85 assert_return(nl, -EINVAL);
86 assert_return(ret, -EINVAL);
87
88 r = netlink_get_policy_set_and_header_size(nl, nlmsg_type, nlmsg_flags, &policy_set, &size);
89 if (r < 0)
90 return r;
91
92 return message_new_full(nl, nlmsg_type, nlmsg_flags, policy_set, size, ret);
93}
94
95int message_new_synthetic_error(sd_netlink *nl, int error, uint32_t serial, sd_netlink_message **ret) {
96 struct nlmsgerr *err;
97 int r;
98
99 assert(error <= 0);
100
101 r = message_new(nl, ret, NLMSG_ERROR, 0);
102 if (r < 0)
103 return r;
104
105 message_seal(*ret);
106 (*ret)->hdr->nlmsg_seq = serial;
107
108 err = NLMSG_DATA((*ret)->hdr);
109 err->error = error;
110
111 return 0;
112}
113
114int sd_netlink_message_set_request_dump(sd_netlink_message *m, int dump) {
115 assert_return(m, -EINVAL);
116 assert_return(m->hdr, -EINVAL);
117 assert_return(m->protocol != NETLINK_ROUTE ||
118 IN_SET(m->hdr->nlmsg_type,
119 RTM_GETLINK, RTM_GETLINKPROP, RTM_GETADDR, RTM_GETROUTE, RTM_GETNEIGH,
120 RTM_GETRULE, RTM_GETADDRLABEL, RTM_GETNEXTHOP, RTM_GETQDISC, RTM_GETTCLASS),
121 -EINVAL);
122
123 SET_FLAG(m->hdr->nlmsg_flags, NLM_F_DUMP, dump);
124
125 return 0;
126}
127
128DEFINE_TRIVIAL_REF_FUNC(sd_netlink_message, sd_netlink_message);
129
130sd_netlink_message* sd_netlink_message_unref(sd_netlink_message *m) {
131 while (m && --m->n_ref == 0) {
132 unsigned i;
133
134 free(m->hdr);
135
136 for (i = 0; i <= m->n_containers; i++)
137 free(m->containers[i].attributes);
138
139 sd_netlink_message *t = m;
140 m = m->next;
141 free(t);
142 }
143
144 return NULL;
145}
146
147int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *ret) {
148 assert_return(m, -EINVAL);
149 assert_return(ret, -EINVAL);
150
151 *ret = m->hdr->nlmsg_type;
152
153 return 0;
154}
155
156int sd_netlink_message_set_flags(sd_netlink_message *m, uint16_t flags) {
157 assert_return(m, -EINVAL);
158 assert_return(flags != 0, -EINVAL);
159
160 m->hdr->nlmsg_flags = flags;
161
162 return 0;
163}
164
165int sd_netlink_message_is_broadcast(sd_netlink_message *m) {
166 assert_return(m, -EINVAL);
167
168 return m->multicast_group != 0;
169}
170
171/* If successful the updated message will be correctly aligned, if unsuccessful the old message is untouched. */
172static int add_rtattr(sd_netlink_message *m, uint16_t attr_type, const void *data, size_t data_length) {
173 size_t message_length;
174 struct nlmsghdr *new_hdr;
175 struct rtattr *rta;
176 int offset;
177
178 assert(m);
179 assert(m->hdr);
180 assert(!m->sealed);
181 assert(NLMSG_ALIGN(m->hdr->nlmsg_len) == m->hdr->nlmsg_len);
182 assert(!data || data_length > 0);
183
184 /* get the new message size (with padding at the end) */
185 message_length = m->hdr->nlmsg_len + RTA_SPACE(data_length);
186
187 /* buffer should be smaller than both one page or 8K to be accepted by the kernel */
188 if (message_length > MIN(page_size(), 8192UL))
189 return -ENOBUFS;
190
191 /* realloc to fit the new attribute */
192 new_hdr = realloc(m->hdr, message_length);
193 if (!new_hdr)
194 return -ENOMEM;
195 m->hdr = new_hdr;
196
197 /* get pointer to the attribute we are about to add */
198 rta = (struct rtattr *) ((uint8_t *) m->hdr + m->hdr->nlmsg_len);
199
200 rtattr_append_attribute_internal(rta, attr_type, data, data_length);
201
202 /* if we are inside containers, extend them */
203 for (unsigned i = 0; i < m->n_containers; i++)
204 GET_CONTAINER(m, i)->rta_len += RTA_SPACE(data_length);
205
206 /* update message size */
207 offset = m->hdr->nlmsg_len;
208 m->hdr->nlmsg_len = message_length;
209
210 /* return old message size */
211 return offset;
212}
213
214static int message_attribute_has_type(sd_netlink_message *m, size_t *ret_size, uint16_t attr_type, NLAType type) {
215 const NLAPolicy *policy;
216
217 assert(m);
218
219 policy = policy_set_get_policy(m->containers[m->n_containers].policy_set, attr_type);
220 if (!policy)
221 return -EOPNOTSUPP;
222
223 if (policy_get_type(policy) != type)
224 return -EINVAL;
225
226 if (ret_size)
227 *ret_size = policy_get_size(policy);
228 return 0;
229}
230
231int sd_netlink_message_append_string(sd_netlink_message *m, uint16_t attr_type, const char *data) {
232 size_t length, size;
233 int r;
234
235 assert_return(m, -EINVAL);
236 assert_return(!m->sealed, -EPERM);
237 assert_return(data, -EINVAL);
238
239 r = message_attribute_has_type(m, &size, attr_type, NETLINK_TYPE_STRING);
240 if (r < 0)
241 return r;
242
243 if (size) {
244 length = strnlen(data, size+1);
245 if (length > size)
246 return -EINVAL;
247 } else
248 length = strlen(data);
249
250 r = add_rtattr(m, attr_type, data, length + 1);
251 if (r < 0)
252 return r;
253
254 return 0;
255}
256
257int sd_netlink_message_append_strv(sd_netlink_message *m, uint16_t attr_type, const char* const *data) {
258 size_t length, size;
259 int r;
260
261 assert_return(m, -EINVAL);
262 assert_return(!m->sealed, -EPERM);
263 assert_return(data, -EINVAL);
264
265 r = message_attribute_has_type(m, &size, attr_type, NETLINK_TYPE_STRING);
266 if (r < 0)
267 return r;
268
269 STRV_FOREACH(p, data) {
270 if (size) {
271 length = strnlen(*p, size+1);
272 if (length > size)
273 return -EINVAL;
274 } else
275 length = strlen(*p);
276
277 r = add_rtattr(m, attr_type, *p, length + 1);
278 if (r < 0)
279 return r;
280 }
281
282 return 0;
283}
284
285int sd_netlink_message_append_flag(sd_netlink_message *m, uint16_t attr_type) {
286 size_t size;
287 int r;
288
289 assert_return(m, -EINVAL);
290 assert_return(!m->sealed, -EPERM);
291
292 r = message_attribute_has_type(m, &size, attr_type, NETLINK_TYPE_FLAG);
293 if (r < 0)
294 return r;
295
296 r = add_rtattr(m, attr_type, NULL, 0);
297 if (r < 0)
298 return r;
299
300 return 0;
301}
302
303int sd_netlink_message_append_u8(sd_netlink_message *m, uint16_t attr_type, uint8_t data) {
304 int r;
305
306 assert_return(m, -EINVAL);
307 assert_return(!m->sealed, -EPERM);
308
309 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_U8);
310 if (r < 0)
311 return r;
312
313 r = add_rtattr(m, attr_type, &data, sizeof(uint8_t));
314 if (r < 0)
315 return r;
316
317 return 0;
318}
319
320int sd_netlink_message_append_u16(sd_netlink_message *m, uint16_t attr_type, uint16_t data) {
321 int r;
322
323 assert_return(m, -EINVAL);
324 assert_return(!m->sealed, -EPERM);
325
326 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_U16);
327 if (r < 0)
328 return r;
329
330 r = add_rtattr(m, attr_type, &data, sizeof(uint16_t));
331 if (r < 0)
332 return r;
333
334 return 0;
335}
336
337int sd_netlink_message_append_u32(sd_netlink_message *m, uint16_t attr_type, uint32_t data) {
338 int r;
339
340 assert_return(m, -EINVAL);
341 assert_return(!m->sealed, -EPERM);
342
343 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_U32);
344 if (r < 0)
345 return r;
346
347 r = add_rtattr(m, attr_type, &data, sizeof(uint32_t));
348 if (r < 0)
349 return r;
350
351 return 0;
352}
353
354int sd_netlink_message_append_u64(sd_netlink_message *m, uint16_t attr_type, uint64_t data) {
355 int r;
356
357 assert_return(m, -EINVAL);
358 assert_return(!m->sealed, -EPERM);
359
360 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_U64);
361 if (r < 0)
362 return r;
363
364 r = add_rtattr(m, attr_type, &data, sizeof(uint64_t));
365 if (r < 0)
366 return r;
367
368 return 0;
369}
370
371int sd_netlink_message_append_s8(sd_netlink_message *m, uint16_t attr_type, int8_t data) {
372 int r;
373
374 assert_return(m, -EINVAL);
375 assert_return(!m->sealed, -EPERM);
376
377 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_S8);
378 if (r < 0)
379 return r;
380
381 r = add_rtattr(m, attr_type, &data, sizeof(int8_t));
382 if (r < 0)
383 return r;
384
385 return 0;
386}
387
388int sd_netlink_message_append_s16(sd_netlink_message *m, uint16_t attr_type, int16_t data) {
389 int r;
390
391 assert_return(m, -EINVAL);
392 assert_return(!m->sealed, -EPERM);
393
394 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_S16);
395 if (r < 0)
396 return r;
397
398 r = add_rtattr(m, attr_type, &data, sizeof(int16_t));
399 if (r < 0)
400 return r;
401
402 return 0;
403}
404
405int sd_netlink_message_append_s32(sd_netlink_message *m, uint16_t attr_type, int32_t data) {
406 int r;
407
408 assert_return(m, -EINVAL);
409 assert_return(!m->sealed, -EPERM);
410
411 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_S32);
412 if (r < 0)
413 return r;
414
415 r = add_rtattr(m, attr_type, &data, sizeof(int32_t));
416 if (r < 0)
417 return r;
418
419 return 0;
420}
421
422int sd_netlink_message_append_s64(sd_netlink_message *m, uint16_t attr_type, int64_t data) {
423 int r;
424
425 assert_return(m, -EINVAL);
426 assert_return(!m->sealed, -EPERM);
427
428 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_S64);
429 if (r < 0)
430 return r;
431
432 r = add_rtattr(m, attr_type, &data, sizeof(int64_t));
433 if (r < 0)
434 return r;
435
436 return 0;
437}
438
439int sd_netlink_message_append_data(sd_netlink_message *m, uint16_t attr_type, const void *data, size_t len) {
440 int r;
441
442 assert_return(m, -EINVAL);
443 assert_return(!m->sealed, -EPERM);
444
445 r = add_rtattr(m, attr_type, data, len);
446 if (r < 0)
447 return r;
448
449 return 0;
450}
451
452int sd_netlink_message_append_container_data(
453 sd_netlink_message *m,
454 uint16_t container_type,
455 uint16_t attr_type,
456 const void *data,
457 size_t len) {
458
459 int r;
460
461 assert_return(m, -EINVAL);
462 assert_return(!m->sealed, -EPERM);
463
464 r = sd_netlink_message_open_container(m, container_type);
465 if (r < 0)
466 return r;
467
468 r = sd_netlink_message_append_data(m, attr_type, data, len);
469 if (r < 0)
470 return r;
471
472 return sd_netlink_message_close_container(m);
473}
474
475int netlink_message_append_in_addr_union(sd_netlink_message *m, uint16_t attr_type, int family, const union in_addr_union *data) {
476 int r;
477
478 assert_return(m, -EINVAL);
479 assert_return(!m->sealed, -EPERM);
480 assert_return(data, -EINVAL);
481 assert_return(IN_SET(family, AF_INET, AF_INET6), -EINVAL);
482
483 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_IN_ADDR);
484 if (r < 0)
485 return r;
486
487 r = add_rtattr(m, attr_type, data, FAMILY_ADDRESS_SIZE(family));
488 if (r < 0)
489 return r;
490
491 return 0;
492}
493
494int sd_netlink_message_append_in_addr(sd_netlink_message *m, uint16_t attr_type, const struct in_addr *data) {
495 return netlink_message_append_in_addr_union(m, attr_type, AF_INET, (const union in_addr_union *) data);
496}
497
498int sd_netlink_message_append_in6_addr(sd_netlink_message *m, uint16_t attr_type, const struct in6_addr *data) {
499 return netlink_message_append_in_addr_union(m, attr_type, AF_INET6, (const union in_addr_union *) data);
500}
501
502int netlink_message_append_sockaddr_union(sd_netlink_message *m, uint16_t attr_type, const union sockaddr_union *data) {
503 int r;
504
505 assert_return(m, -EINVAL);
506 assert_return(!m->sealed, -EPERM);
507 assert_return(data, -EINVAL);
508 assert_return(IN_SET(data->sa.sa_family, AF_INET, AF_INET6), -EINVAL);
509
510 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_SOCKADDR);
511 if (r < 0)
512 return r;
513
514 r = add_rtattr(m, attr_type, data, data->sa.sa_family == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6));
515 if (r < 0)
516 return r;
517
518 return 0;
519}
520
521int sd_netlink_message_append_sockaddr_in(sd_netlink_message *m, uint16_t attr_type, const struct sockaddr_in *data) {
522 return netlink_message_append_sockaddr_union(m, attr_type, (const union sockaddr_union *) data);
523}
524
525int sd_netlink_message_append_sockaddr_in6(sd_netlink_message *m, uint16_t attr_type, const struct sockaddr_in6 *data) {
526 return netlink_message_append_sockaddr_union(m, attr_type, (const union sockaddr_union *) data);
527}
528
529int sd_netlink_message_append_ether_addr(sd_netlink_message *m, uint16_t attr_type, const struct ether_addr *data) {
530 int r;
531
532 assert_return(m, -EINVAL);
533 assert_return(!m->sealed, -EPERM);
534 assert_return(data, -EINVAL);
535
536 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_ETHER_ADDR);
537 if (r < 0)
538 return r;
539
540 r = add_rtattr(m, attr_type, data, ETH_ALEN);
541 if (r < 0)
542 return r;
543
544 return 0;
545}
546
547int netlink_message_append_hw_addr(sd_netlink_message *m, uint16_t attr_type, const struct hw_addr_data *data) {
548 int r;
549
550 assert_return(m, -EINVAL);
551 assert_return(!m->sealed, -EPERM);
552 assert_return(data, -EINVAL);
553 assert_return(data->length > 0, -EINVAL);
554
555 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_ETHER_ADDR);
556 if (r < 0)
557 return r;
558
559 r = add_rtattr(m, attr_type, data->bytes, data->length);
560 if (r < 0)
561 return r;
562
563 return 0;
564}
565
566int sd_netlink_message_append_cache_info(sd_netlink_message *m, uint16_t attr_type, const struct ifa_cacheinfo *info) {
567 int r;
568
569 assert_return(m, -EINVAL);
570 assert_return(!m->sealed, -EPERM);
571 assert_return(info, -EINVAL);
572
573 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_CACHE_INFO);
574 if (r < 0)
575 return r;
576
577 r = add_rtattr(m, attr_type, info, sizeof(struct ifa_cacheinfo));
578 if (r < 0)
579 return r;
580
581 return 0;
582}
583
584int sd_netlink_message_open_container(sd_netlink_message *m, uint16_t attr_type) {
585 size_t size;
586 int r;
587
588 assert_return(m, -EINVAL);
589 assert_return(!m->sealed, -EPERM);
590 /* m->containers[m->n_containers + 1] is accessed both in read and write. Prevent access out of bound */
591 assert_return(m->n_containers < (NETLINK_CONTAINER_DEPTH - 1), -ERANGE);
592
593 r = message_attribute_has_type(m, &size, attr_type, NETLINK_TYPE_NESTED);
594 if (r < 0) {
595 const NLAPolicySetUnion *policy_set_union;
596 int family;
597
598 r = message_attribute_has_type(m, &size, attr_type, NETLINK_TYPE_NESTED_UNION_BY_FAMILY);
599 if (r < 0)
600 return r;
601
602 r = sd_rtnl_message_get_family(m, &family);
603 if (r < 0)
604 return r;
605
606 policy_set_union = policy_set_get_policy_set_union(
607 m->containers[m->n_containers].policy_set,
608 attr_type);
609 if (!policy_set_union)
610 return -EOPNOTSUPP;
611
612 m->containers[m->n_containers + 1].policy_set =
613 policy_set_union_get_policy_set_by_family(
614 policy_set_union,
615 family);
616 } else
617 m->containers[m->n_containers + 1].policy_set =
618 policy_set_get_policy_set(
619 m->containers[m->n_containers].policy_set,
620 attr_type);
621 if (!m->containers[m->n_containers + 1].policy_set)
622 return -EOPNOTSUPP;
623
624 r = add_rtattr(m, attr_type | NLA_F_NESTED, NULL, size);
625 if (r < 0)
626 return r;
627
628 m->containers[m->n_containers++].offset = r;
629
630 return 0;
631}
632
633int sd_netlink_message_open_container_union(sd_netlink_message *m, uint16_t attr_type, const char *key) {
634 const NLAPolicySetUnion *policy_set_union;
635 int r;
636
637 assert_return(m, -EINVAL);
638 assert_return(!m->sealed, -EPERM);
639 assert_return(m->n_containers < (NETLINK_CONTAINER_DEPTH - 1), -ERANGE);
640
641 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_NESTED_UNION_BY_STRING);
642 if (r < 0)
643 return r;
644
645 policy_set_union = policy_set_get_policy_set_union(
646 m->containers[m->n_containers].policy_set,
647 attr_type);
648 if (!policy_set_union)
649 return -EOPNOTSUPP;
650
651 m->containers[m->n_containers + 1].policy_set =
652 policy_set_union_get_policy_set_by_string(
653 policy_set_union,
654 key);
655 if (!m->containers[m->n_containers + 1].policy_set)
656 return -EOPNOTSUPP;
657
658 r = sd_netlink_message_append_string(m, policy_set_union_get_match_attribute(policy_set_union), key);
659 if (r < 0)
660 return r;
661
662 /* do we ever need non-null size */
663 r = add_rtattr(m, attr_type | NLA_F_NESTED, NULL, 0);
664 if (r < 0)
665 return r;
666
667 m->containers[m->n_containers++].offset = r;
668
669 return 0;
670}
671
672int sd_netlink_message_close_container(sd_netlink_message *m) {
673 assert_return(m, -EINVAL);
674 assert_return(!m->sealed, -EPERM);
675 assert_return(m->n_containers > 0, -EINVAL);
676
677 m->containers[m->n_containers].policy_set = NULL;
678 m->containers[m->n_containers].offset = 0;
679 m->n_containers--;
680
681 return 0;
682}
683
684int sd_netlink_message_open_array(sd_netlink_message *m, uint16_t attr_type) {
685 int r;
686
687 assert_return(m, -EINVAL);
688 assert_return(!m->sealed, -EPERM);
689 assert_return(m->n_containers < (NETLINK_CONTAINER_DEPTH - 1), -ERANGE);
690
691 r = add_rtattr(m, attr_type | NLA_F_NESTED, NULL, 0);
692 if (r < 0)
693 return r;
694
695 m->containers[m->n_containers].offset = r;
696 m->n_containers++;
697 m->containers[m->n_containers].policy_set = m->containers[m->n_containers - 1].policy_set;
698
699 return 0;
700}
701
702int sd_netlink_message_cancel_array(sd_netlink_message *m) {
703 uint32_t rta_len;
704
705 assert_return(m, -EINVAL);
706 assert_return(!m->sealed, -EPERM);
707 assert_return(m->n_containers > 1, -EINVAL);
708
709 rta_len = GET_CONTAINER(m, (m->n_containers - 1))->rta_len;
710
711 for (unsigned i = 0; i < m->n_containers; i++)
712 GET_CONTAINER(m, i)->rta_len -= rta_len;
713
714 m->hdr->nlmsg_len -= rta_len;
715
716 m->n_containers--;
717 m->containers[m->n_containers].policy_set = NULL;
718
719 return 0;
720}
721
722static int netlink_message_read_internal(
723 sd_netlink_message *m,
724 uint16_t attr_type,
725 void **ret_data,
726 bool *ret_net_byteorder) {
727
728 struct netlink_attribute *attribute;
729 struct rtattr *rta;
730
731 assert_return(m, -EINVAL);
732 assert_return(m->sealed, -EPERM);
733
734 assert(m->n_containers < NETLINK_CONTAINER_DEPTH);
735
736 if (!m->containers[m->n_containers].attributes)
737 return -ENODATA;
738
739 if (attr_type > m->containers[m->n_containers].max_attribute)
740 return -ENODATA;
741
742 attribute = &m->containers[m->n_containers].attributes[attr_type];
743
744 if (attribute->offset == 0)
745 return -ENODATA;
746
747 rta = (struct rtattr*)((uint8_t *) m->hdr + attribute->offset);
748
749 if (ret_data)
750 *ret_data = RTA_DATA(rta);
751
752 if (ret_net_byteorder)
753 *ret_net_byteorder = attribute->net_byteorder;
754
755 return RTA_PAYLOAD(rta);
756}
757
758static int netlink_message_read_impl(
759 sd_netlink_message *m,
760 uint16_t attr_type,
761 bool strict,
762 NLAType type,
763 size_t size,
764 void *ret,
765 bool *ret_net_byteorder) {
766
767 bool net_byteorder;
768 void *attr_data;
769 int r;
770
771 assert(m);
772
773 if (type >= 0) {
774 r = message_attribute_has_type(m, NULL, attr_type, type);
775 if (r < 0)
776 return r;
777 }
778
779 r = netlink_message_read_internal(m, attr_type, &attr_data, &net_byteorder);
780 if (r < 0)
781 return r;
782
783 if ((size_t) r > size)
784 return -ENOBUFS;
785
786 if (strict && (size_t) r != size)
787 return -EIO;
788
789 if (ret)
790 memzero(mempcpy(ret, attr_data, r), size - (size_t) r);
791
792 if (ret_net_byteorder)
793 *ret_net_byteorder = net_byteorder;
794
795 return r;
796}
797
798int sd_netlink_message_read(sd_netlink_message *m, uint16_t attr_type, size_t size, void *ret) {
799 assert_return(m, -EINVAL);
800
801 return netlink_message_read_impl(
802 m, attr_type, /* strict = */ false,
803 _NETLINK_TYPE_INVALID, size,
804 ret, /* ret_net_byteorder = */ NULL);
805}
806
807int sd_netlink_message_read_data(sd_netlink_message *m, uint16_t attr_type, size_t *ret_size, void **ret_data) {
808 void *attr_data;
809 int r;
810
811 assert_return(m, -EINVAL);
812
813 r = netlink_message_read_internal(m, attr_type, &attr_data, NULL);
814 if (r < 0)
815 return r;
816
817 if (ret_data) {
818 void *data;
819
820 data = memdup_suffix0(attr_data, r);
821 if (!data)
822 return -ENOMEM;
823
824 *ret_data = data;
825 }
826
827 if (ret_size)
828 *ret_size = r;
829
830 return r;
831}
832
833int sd_netlink_message_read_string_strdup(sd_netlink_message *m, uint16_t attr_type, char **ret) {
834 const char *s;
835 int r;
836
837 assert_return(m, -EINVAL);
838
839 r = sd_netlink_message_read_string(m, attr_type, &s);
840 if (r < 0)
841 return r;
842
843 return strdup_to(ret, s);
844}
845
846int sd_netlink_message_read_string(sd_netlink_message *m, uint16_t attr_type, const char **ret) {
847 void *attr_data;
848 int r;
849
850 assert_return(m, -EINVAL);
851
852 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_STRING);
853 if (r < 0)
854 return r;
855
856 r = netlink_message_read_internal(m, attr_type, &attr_data, NULL);
857 if (r < 0)
858 return r;
859
860 if (strnlen(attr_data, r) >= (size_t) r)
861 return -EIO;
862
863 if (ret)
864 *ret = (const char *) attr_data;
865
866 return r;
867}
868
869int sd_netlink_message_read_u8(sd_netlink_message *m, uint16_t attr_type, uint8_t *ret) {
870 assert_return(m, -EINVAL);
871
872 return netlink_message_read_impl(
873 m, attr_type, /* strict = */ true,
874 NETLINK_TYPE_U8, sizeof(uint8_t),
875 ret, /* ret_net_byteorder = */ NULL);
876}
877
878int sd_netlink_message_read_u16(sd_netlink_message *m, uint16_t attr_type, uint16_t *ret) {
879 bool net_byteorder;
880 uint16_t u;
881 int r;
882
883 assert_return(m, -EINVAL);
884
885 r = netlink_message_read_impl(
886 m, attr_type, /* strict = */ true,
887 NETLINK_TYPE_U16, sizeof(uint16_t),
888 ret ? &u : NULL, &net_byteorder);
889 if (r < 0)
890 return r;
891
892 if (ret)
893 *ret = net_byteorder ? be16toh(u) : u;
894
895 return 0;
896}
897
898int sd_netlink_message_read_u32(sd_netlink_message *m, uint16_t attr_type, uint32_t *ret) {
899 bool net_byteorder;
900 uint32_t u;
901 int r;
902
903 assert_return(m, -EINVAL);
904
905 r = netlink_message_read_impl(
906 m, attr_type, /* strict = */ true,
907 NETLINK_TYPE_U32, sizeof(uint32_t),
908 ret ? &u : NULL, &net_byteorder);
909 if (r < 0)
910 return r;
911
912 if (ret)
913 *ret = net_byteorder ? be32toh(u) : u;
914
915 return 0;
916}
917
918int sd_netlink_message_read_u64(sd_netlink_message *m, uint16_t attr_type, uint64_t *ret) {
919 bool net_byteorder;
920 uint64_t u;
921 int r;
922
923 assert_return(m, -EINVAL);
924
925 r = netlink_message_read_impl(
926 m, attr_type, /* strict = */ true,
927 NETLINK_TYPE_U64, sizeof(uint64_t),
928 ret ? &u : NULL, &net_byteorder);
929 if (r < 0)
930 return r;
931
932 if (ret)
933 *ret = net_byteorder ? be64toh(u) : u;
934
935 return 0;
936}
937
938int sd_netlink_message_read_ether_addr(sd_netlink_message *m, uint16_t attr_type, struct ether_addr *ret) {
939 assert_return(m, -EINVAL);
940
941 return netlink_message_read_impl(
942 m, attr_type, /* strict = */ true,
943 NETLINK_TYPE_ETHER_ADDR, sizeof(struct ether_addr),
944 ret, /* ret_net_byteorder = */ NULL);
945}
946
947int netlink_message_read_hw_addr(sd_netlink_message *m, uint16_t attr_type, struct hw_addr_data *ret) {
948 int r;
949
950 assert_return(m, -EINVAL);
951
952 r = netlink_message_read_impl(
953 m, attr_type, /* strict = */ false,
954 NETLINK_TYPE_ETHER_ADDR, HW_ADDR_MAX_SIZE,
955 ret ? ret->bytes : NULL, /* ret_net_byteorder = */ NULL);
956 if (r < 0)
957 return r;
958
959 if (ret)
960 ret->length = r;
961
962 return r;
963}
964
965int sd_netlink_message_read_cache_info(sd_netlink_message *m, uint16_t attr_type, struct ifa_cacheinfo *ret) {
966 assert_return(m, -EINVAL);
967
968 return netlink_message_read_impl(
969 m, attr_type, /* strict = */ true,
970 NETLINK_TYPE_CACHE_INFO, sizeof(struct ifa_cacheinfo),
971 ret, /* ret_net_byteorder = */ NULL);
972}
973
974int netlink_message_read_in_addr_union(sd_netlink_message *m, uint16_t attr_type, int family, union in_addr_union *ret) {
975 int r;
976
977 assert_return(m, -EINVAL);
978 assert_return(IN_SET(family, AF_INET, AF_INET6), -EINVAL);
979
980 r = netlink_message_read_impl(
981 m, attr_type, /* strict = */ true,
982 NETLINK_TYPE_IN_ADDR, FAMILY_ADDRESS_SIZE(family),
983 ret, /* ret_net_byteorder = */ NULL);
984 if (r < 0)
985 return r;
986
987 if (ret)
988 memzero((uint8_t*) ret + FAMILY_ADDRESS_SIZE(family), sizeof(union in_addr_union) - FAMILY_ADDRESS_SIZE(family));
989
990 return r;
991}
992
993int sd_netlink_message_read_in_addr(sd_netlink_message *m, uint16_t attr_type, struct in_addr *ret) {
994 assert_return(m, -EINVAL);
995
996 return netlink_message_read_impl(
997 m, attr_type, /* strict = */ true,
998 NETLINK_TYPE_IN_ADDR, sizeof(struct in_addr),
999 ret, /* ret_net_byteorder = */ NULL);
1000}
1001
1002int sd_netlink_message_read_in6_addr(sd_netlink_message *m, uint16_t attr_type, struct in6_addr *ret) {
1003 assert_return(m, -EINVAL);
1004
1005 return netlink_message_read_impl(
1006 m, attr_type, /* strict = */ true,
1007 NETLINK_TYPE_IN_ADDR, sizeof(struct in6_addr),
1008 ret, /* ret_net_byteorder = */ NULL);
1009}
1010
1011int sd_netlink_message_has_flag(sd_netlink_message *m, uint16_t attr_type) {
1012 void *attr_data;
1013 int r;
1014
1015 assert_return(m, -EINVAL);
1016
1017 /* This returns 1 when the flag is set, 0 when not set, negative errno on error. */
1018
1019 r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_FLAG);
1020 if (r < 0)
1021 return r;
1022
1023 r = netlink_message_read_internal(m, attr_type, &attr_data, NULL);
1024 if (r == -ENODATA)
1025 return 0;
1026 if (r < 0)
1027 return r;
1028
1029 return 1;
1030}
1031
1032int sd_netlink_message_read_strv(sd_netlink_message *m, uint16_t container_type, uint16_t attr_type, char ***ret) {
1033 _cleanup_strv_free_ char **s = NULL;
1034 const NLAPolicySet *policy_set;
1035 const NLAPolicy *policy;
1036 struct rtattr *rta;
1037 void *container;
1038 size_t rt_len;
1039 int r;
1040
1041 assert_return(m, -EINVAL);
1042 assert_return(m->n_containers < NETLINK_CONTAINER_DEPTH, -EINVAL);
1043
1044 policy = policy_set_get_policy(
1045 m->containers[m->n_containers].policy_set,
1046 container_type);
1047 if (!policy)
1048 return -EOPNOTSUPP;
1049
1050 if (policy_get_type(policy) != NETLINK_TYPE_NESTED)
1051 return -EINVAL;
1052
1053 policy_set = policy_set_get_policy_set(
1054 m->containers[m->n_containers].policy_set,
1055 container_type);
1056 if (!policy_set)
1057 return -EOPNOTSUPP;
1058
1059 policy = policy_set_get_policy(policy_set, attr_type);
1060 if (!policy)
1061 return -EOPNOTSUPP;
1062
1063 if (policy_get_type(policy) != NETLINK_TYPE_STRING)
1064 return -EINVAL;
1065
1066 r = netlink_message_read_internal(m, container_type, &container, NULL);
1067 if (r < 0)
1068 return r;
1069
1070 rt_len = (size_t) r;
1071 rta = container;
1072
1073 /* RTA_OK() macro compares with rta->rt_len, which is unsigned short, and
1074 * LGTM.com analysis does not like the type difference. Hence, here we
1075 * introduce an unsigned short variable as a workaround. */
1076 unsigned short len = rt_len;
1077 for (; RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {
1078 uint16_t type;
1079
1080 type = RTA_TYPE(rta);
1081 if (type != attr_type)
1082 continue;
1083
1084 r = strv_extend(&s, RTA_DATA(rta));
1085 if (r < 0)
1086 return r;
1087 }
1088
1089 *ret = TAKE_PTR(s);
1090 return 0;
1091}
1092
1093static int netlink_container_parse(
1094 sd_netlink_message *m,
1095 struct netlink_container *container,
1096 struct rtattr *rta,
1097 size_t rt_len) {
1098
1099 _cleanup_free_ struct netlink_attribute *attributes = NULL;
1100 uint16_t max_attr = 0;
1101
1102 /* RTA_OK() macro compares with rta->rt_len, which is unsigned short, and
1103 * LGTM.com analysis does not like the type difference. Hence, here we
1104 * introduce an unsigned short variable as a workaround. */
1105 unsigned short len = rt_len;
1106 for (; RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {
1107 uint16_t attr;
1108
1109 attr = RTA_TYPE(rta);
1110 max_attr = MAX(max_attr, attr);
1111
1112 if (!GREEDY_REALLOC0(attributes, (size_t) max_attr + 1))
1113 return -ENOMEM;
1114
1115 if (attributes[attr].offset != 0)
1116 log_debug("sd-netlink: message parse - overwriting repeated attribute");
1117
1118 attributes[attr].offset = (uint8_t *) rta - (uint8_t *) m->hdr;
1119 attributes[attr].nested = RTA_FLAGS(rta) & NLA_F_NESTED;
1120 attributes[attr].net_byteorder = RTA_FLAGS(rta) & NLA_F_NET_BYTEORDER;
1121 }
1122
1123 container->attributes = TAKE_PTR(attributes);
1124 container->max_attribute = max_attr;
1125
1126 return 0;
1127}
1128
1129int sd_netlink_message_enter_container(sd_netlink_message *m, uint16_t attr_type) {
1130 const NLAPolicy *policy;
1131 const NLAPolicySet *policy_set;
1132 void *container;
1133 size_t size;
1134 int r;
1135
1136 assert_return(m, -EINVAL);
1137 assert_return(m->n_containers < (NETLINK_CONTAINER_DEPTH - 1), -EINVAL);
1138
1139 policy = policy_set_get_policy(
1140 m->containers[m->n_containers].policy_set,
1141 attr_type);
1142 if (!policy)
1143 return -EOPNOTSUPP;
1144
1145 switch (policy_get_type(policy)) {
1146 case NETLINK_TYPE_NESTED:
1147 policy_set = policy_set_get_policy_set(
1148 m->containers[m->n_containers].policy_set,
1149 attr_type);
1150 break;
1151
1152 case NETLINK_TYPE_NESTED_UNION_BY_STRING: {
1153 const NLAPolicySetUnion *policy_set_union;
1154 const char *key;
1155
1156 policy_set_union = policy_get_policy_set_union(policy);
1157 if (!policy_set_union)
1158 return -EOPNOTSUPP;
1159
1160 r = sd_netlink_message_read_string(
1161 m,
1162 policy_set_union_get_match_attribute(policy_set_union),
1163 &key);
1164 if (r < 0)
1165 return r;
1166
1167 policy_set = policy_set_union_get_policy_set_by_string(
1168 policy_set_union,
1169 key);
1170 break;
1171 }
1172 case NETLINK_TYPE_NESTED_UNION_BY_FAMILY: {
1173 const NLAPolicySetUnion *policy_set_union;
1174 int family;
1175
1176 policy_set_union = policy_get_policy_set_union(policy);
1177 if (!policy_set_union)
1178 return -EOPNOTSUPP;
1179
1180 r = sd_rtnl_message_get_family(m, &family);
1181 if (r < 0)
1182 return r;
1183
1184 policy_set = policy_set_union_get_policy_set_by_family(
1185 policy_set_union,
1186 family);
1187 break;
1188 }
1189 default:
1190 assert_not_reached();
1191 }
1192 if (!policy_set)
1193 return -EOPNOTSUPP;
1194
1195 r = netlink_message_read_internal(m, attr_type, &container, NULL);
1196 if (r < 0)
1197 return r;
1198
1199 size = (size_t) r;
1200 m->n_containers++;
1201
1202 r = netlink_container_parse(m,
1203 &m->containers[m->n_containers],
1204 container,
1205 size);
1206 if (r < 0) {
1207 m->n_containers--;
1208 return r;
1209 }
1210
1211 m->containers[m->n_containers].policy_set = policy_set;
1212
1213 return 0;
1214}
1215
1216int sd_netlink_message_enter_array(sd_netlink_message *m, uint16_t attr_type) {
1217 void *container;
1218 size_t size;
1219 int r;
1220
1221 assert_return(m, -EINVAL);
1222 assert_return(m->n_containers < (NETLINK_CONTAINER_DEPTH - 1), -EINVAL);
1223
1224 r = netlink_message_read_internal(m, attr_type, &container, NULL);
1225 if (r < 0)
1226 return r;
1227
1228 size = (size_t) r;
1229 m->n_containers++;
1230
1231 r = netlink_container_parse(m,
1232 &m->containers[m->n_containers],
1233 container,
1234 size);
1235 if (r < 0) {
1236 m->n_containers--;
1237 return r;
1238 }
1239
1240 m->containers[m->n_containers].policy_set = m->containers[m->n_containers - 1].policy_set;
1241
1242 return 0;
1243}
1244
1245int sd_netlink_message_exit_container(sd_netlink_message *m) {
1246 assert_return(m, -EINVAL);
1247 assert_return(m->sealed, -EINVAL);
1248 assert_return(m->n_containers > 0, -EINVAL);
1249
1250 m->containers[m->n_containers].attributes = mfree(m->containers[m->n_containers].attributes);
1251 m->containers[m->n_containers].max_attribute = 0;
1252 m->containers[m->n_containers].policy_set = NULL;
1253
1254 m->n_containers--;
1255
1256 return 0;
1257}
1258
1259int sd_netlink_message_get_max_attribute(sd_netlink_message *m, uint16_t *ret) {
1260 assert_return(m, -EINVAL);
1261 assert_return(m->sealed, -EINVAL);
1262 assert_return(ret, -EINVAL);
1263
1264 *ret = m->containers[m->n_containers].max_attribute;
1265 return 0;
1266}
1267
1268int sd_netlink_message_is_error(sd_netlink_message *m) {
1269 assert_return(m, 0);
1270 assert_return(m->hdr, 0);
1271
1272 return m->hdr->nlmsg_type == NLMSG_ERROR;
1273}
1274
1275int sd_netlink_message_get_errno(sd_netlink_message *m) {
1276 struct nlmsgerr *err;
1277
1278 assert_return(m, -EINVAL);
1279 assert_return(m->hdr, -EINVAL);
1280
1281 if (!sd_netlink_message_is_error(m))
1282 return 0;
1283
1284 err = NLMSG_DATA(m->hdr);
1285
1286 return err->error;
1287}
1288
1289static int netlink_message_parse_error(sd_netlink_message *m) {
1290 struct nlmsgerr *err = NLMSG_DATA(m->hdr);
1291 size_t hlen = sizeof(struct nlmsgerr);
1292
1293 /* no TLVs, nothing to do here */
1294 if (!(m->hdr->nlmsg_flags & NLM_F_ACK_TLVS))
1295 return 0;
1296
1297 /* if NLM_F_CAPPED is set then the inner err msg was capped */
1298 if (!(m->hdr->nlmsg_flags & NLM_F_CAPPED))
1299 hlen += err->msg.nlmsg_len - sizeof(struct nlmsghdr);
1300
1301 if (m->hdr->nlmsg_len <= NLMSG_SPACE(hlen))
1302 return 0;
1303
1304 return netlink_container_parse(m,
1305 &m->containers[m->n_containers],
1306 (struct rtattr*)((uint8_t*) NLMSG_DATA(m->hdr) + hlen),
1307 NLMSG_PAYLOAD(m->hdr, hlen));
1308}
1309
1310int sd_netlink_message_rewind(sd_netlink_message *m, sd_netlink *nl) {
1311 size_t size;
1312 int r;
1313
1314 assert_return(m, -EINVAL);
1315 assert_return(nl, -EINVAL);
1316
1317 /* don't allow appending to message once parsed */
1318 message_seal(m);
1319
1320 for (unsigned i = 1; i <= m->n_containers; i++)
1321 m->containers[i].attributes = mfree(m->containers[i].attributes);
1322
1323 m->n_containers = 0;
1324
1325 if (m->containers[0].attributes)
1326 /* top-level attributes have already been parsed */
1327 return 0;
1328
1329 assert(m->hdr);
1330
1331 r = netlink_get_policy_set_and_header_size(
1332 nl,
1333 m->hdr->nlmsg_type,
1334 m->hdr->nlmsg_flags,
1335 &m->containers[0].policy_set,
1336 &size);
1337 if (r < 0)
1338 return r;
1339
1340 if (sd_netlink_message_is_error(m))
1341 return netlink_message_parse_error(m);
1342
1343 return netlink_container_parse(m,
1344 &m->containers[0],
1345 (struct rtattr*)((uint8_t*) NLMSG_DATA(m->hdr) + NLMSG_ALIGN(size)),
1346 NLMSG_PAYLOAD(m->hdr, size));
1347}
1348
1349void message_seal(sd_netlink_message *m) {
1350 assert(m);
1351
1352 m->sealed = true;
1353}
1354
1355sd_netlink_message* sd_netlink_message_next(sd_netlink_message *m) {
1356 assert_return(m, NULL);
1357
1358 return m->next;
1359}
Unnamed repository; edit this file 'description' to name the repository.