]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-rtnl/rtnl-message.c
projects / thirdparty / systemd.git / blob
? search:


06a7a4b83a7636bb19d53e6ddecc599e25c4550c
[thirdparty/systemd.git] / src / libsystemd / sd-rtnl / rtnl-message.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2013 Tom Gundersen <teg@jklm.no>
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <netinet/in.h>
23 #include <netinet/ether.h>
24 #include <stdbool.h>
25 #include <unistd.h>
26
27 #include "util.h"
28 #include "refcnt.h"
29 #include "missing.h"
30
31 #include "sd-rtnl.h"
32 #include "rtnl-util.h"
33 #include "rtnl-internal.h"
34 #include "rtnl-types.h"
35
36 #define GET_CONTAINER(m, i) ((i) < (m)->n_containers ? (struct rtattr*)((uint8_t*)(m)->hdr + (m)->container_offsets[i]) : NULL)
37 #define PUSH_CONTAINER(m, new) (m)->container_offsets[(m)->n_containers ++] = (uint8_t*)(new) - (uint8_t*)(m)->hdr;
38
39 #define RTA_TYPE(rta) ((rta)->rta_type & NLA_TYPE_MASK)
40
41 static int message_new_empty(sd_rtnl *rtnl, sd_rtnl_message **ret) {
42 sd_rtnl_message *m;
43
44 assert_return(ret, -EINVAL);
45
46 /* Note that 'rtnl' is currently unused, if we start using it internally
47 we must take care to avoid problems due to mutual references between
48 busses and their queued messages. See sd-bus.
49 */
50
51 m = new0(sd_rtnl_message, 1);
52 if (!m)
53 return -ENOMEM;
54
55 m->n_ref = REFCNT_INIT;
56
57 m->sealed = false;
58
59 *ret = m;
60
61 return 0;
62 }
63
64 int message_new(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t type) {
65 _cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
66 const NLType *nl_type;
67 size_t size;
68 int r;
69
70 r = type_system_get_type(NULL, &nl_type, type);
71 if (r < 0)
72 return r;
73
74 assert(nl_type->type == NLA_NESTED);
75
76 r = message_new_empty(rtnl, &m);
77 if (r < 0)
78 return r;
79
80 size = NLMSG_SPACE(nl_type->size);
81
82 assert(size >= sizeof(struct nlmsghdr));
83 m->hdr = malloc0(size);
84 if (!m->hdr)
85 return -ENOMEM;
86
87 m->hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
88
89 m->container_type_system[0] = nl_type->type_system;
90 m->hdr->nlmsg_len = size;
91 m->hdr->nlmsg_type = type;
92
93 *ret = m;
94 m = NULL;
95
96 return 0;
97 }
98
99 int sd_rtnl_message_route_set_dst_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
100 struct rtmsg *rtm;
101
102 assert_return(m, -EINVAL);
103 assert_return(m->hdr, -EINVAL);
104 assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
105
106 rtm = NLMSG_DATA(m->hdr);
107
108 if ((rtm->rtm_family == AF_INET && prefixlen > 32) ||
109 (rtm->rtm_family == AF_INET6 && prefixlen > 128))
110 return -ERANGE;
111
112 rtm->rtm_dst_len = prefixlen;
113
114 return 0;
115 }
116
117 int sd_rtnl_message_route_set_src_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
118 struct rtmsg *rtm;
119
120 assert_return(m, -EINVAL);
121 assert_return(m->hdr, -EINVAL);
122 assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
123
124 rtm = NLMSG_DATA(m->hdr);
125
126 if ((rtm->rtm_family == AF_INET && prefixlen > 32) ||
127 (rtm->rtm_family == AF_INET6 && prefixlen > 128))
128 return -ERANGE;
129
130 rtm->rtm_src_len = prefixlen;
131
132 return 0;
133 }
134
135 int sd_rtnl_message_route_set_scope(sd_rtnl_message *m, unsigned char scope) {
136 struct rtmsg *rtm;
137
138 assert_return(m, -EINVAL);
139 assert_return(m->hdr, -EINVAL);
140 assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
141
142 rtm = NLMSG_DATA(m->hdr);
143
144 rtm->rtm_scope = scope;
145
146 return 0;
147 }
148
149 int sd_rtnl_message_route_get_family(sd_rtnl_message *m, int *family) {
150 struct rtmsg *rtm;
151
152 assert_return(m, -EINVAL);
153 assert_return(m->hdr, -EINVAL);
154 assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
155 assert_return(family, -EINVAL);
156
157 rtm = NLMSG_DATA(m->hdr);
158
159 *family = rtm->rtm_family;
160
161 return 0;
162 }
163
164 int sd_rtnl_message_route_get_dst_prefixlen(sd_rtnl_message *m, unsigned char *dst_len) {
165 struct rtmsg *rtm;
166
167 assert_return(m, -EINVAL);
168 assert_return(m->hdr, -EINVAL);
169 assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
170 assert_return(dst_len, -EINVAL);
171
172 rtm = NLMSG_DATA(m->hdr);
173
174 *dst_len = rtm->rtm_dst_len;
175
176 return 0;
177 }
178
179 int sd_rtnl_message_route_get_src_prefixlen(sd_rtnl_message *m, unsigned char *src_len) {
180 struct rtmsg *rtm;
181
182 assert_return(m, -EINVAL);
183 assert_return(m->hdr, -EINVAL);
184 assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
185 assert_return(src_len, -EINVAL);
186
187 rtm = NLMSG_DATA(m->hdr);
188
189 *src_len = rtm->rtm_src_len;
190
191 return 0;
192 }
193
194 int sd_rtnl_message_new_route(sd_rtnl *rtnl, sd_rtnl_message **ret,
195 uint16_t nlmsg_type, int rtm_family,
196 unsigned char rtm_protocol) {
197 struct rtmsg *rtm;
198 int r;
199
200 assert_return(rtnl_message_type_is_route(nlmsg_type), -EINVAL);
201 assert_return((nlmsg_type == RTM_GETROUTE && rtm_family == AF_UNSPEC) ||
202 rtm_family == AF_INET || rtm_family == AF_INET6, -EINVAL);
203 assert_return(ret, -EINVAL);
204
205 r = message_new(rtnl, ret, nlmsg_type);
206 if (r < 0)
207 return r;
208
209 if (nlmsg_type == RTM_NEWROUTE)
210 (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND;
211
212 rtm = NLMSG_DATA((*ret)->hdr);
213
214 rtm->rtm_family = rtm_family;
215 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
216 rtm->rtm_type = RTN_UNICAST;
217 rtm->rtm_table = RT_TABLE_MAIN;
218 rtm->rtm_protocol = rtm_protocol;
219
220 return 0;
221 }
222
223 int sd_rtnl_message_neigh_set_flags(sd_rtnl_message *m, uint8_t flags) {
224 struct ndmsg *ndm;
225
226 assert_return(m, -EINVAL);
227 assert_return(m->hdr, -EINVAL);
228 assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
229
230 ndm = NLMSG_DATA(m->hdr);
231 ndm->ndm_flags |= flags;
232
233 return 0;
234 }
235
236 int sd_rtnl_message_neigh_set_state(sd_rtnl_message *m, uint16_t state) {
237 struct ndmsg *ndm;
238
239 assert_return(m, -EINVAL);
240 assert_return(m->hdr, -EINVAL);
241 assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
242
243 ndm = NLMSG_DATA(m->hdr);
244 ndm->ndm_state |= state;
245
246 return 0;
247 }
248
249 int sd_rtnl_message_neigh_get_flags(sd_rtnl_message *m, uint8_t *flags) {
250 struct ndmsg *ndm;
251
252 assert_return(m, -EINVAL);
253 assert_return(m->hdr, -EINVAL);
254 assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
255
256 ndm = NLMSG_DATA(m->hdr);
257 *flags = ndm->ndm_flags;
258
259 return 0;
260 }
261
262 int sd_rtnl_message_neigh_get_state(sd_rtnl_message *m, uint16_t *state) {
263 struct ndmsg *ndm;
264
265 assert_return(m, -EINVAL);
266 assert_return(m->hdr, -EINVAL);
267 assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
268
269 ndm = NLMSG_DATA(m->hdr);
270 *state = ndm->ndm_state;
271
272 return 0;
273 }
274
275 int sd_rtnl_message_neigh_get_family(sd_rtnl_message *m, int *family) {
276 struct ndmsg *ndm;
277
278 assert_return(m, -EINVAL);
279 assert_return(m->hdr, -EINVAL);
280 assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
281 assert_return(family, -EINVAL);
282
283 ndm = NLMSG_DATA(m->hdr);
284
285 *family = ndm->ndm_family;
286
287 return 0;
288 }
289
290 int sd_rtnl_message_neigh_get_ifindex(sd_rtnl_message *m, int *index) {
291 struct ndmsg *ndm;
292
293 assert_return(m, -EINVAL);
294 assert_return(m->hdr, -EINVAL);
295 assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
296 assert_return(index, -EINVAL);
297
298 ndm = NLMSG_DATA(m->hdr);
299
300 *index = ndm->ndm_ifindex;
301
302 return 0;
303 }
304
305 int sd_rtnl_message_new_neigh(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t nlmsg_type, int index, int ndm_family) {
306 struct ndmsg *ndm;
307 int r;
308
309 assert_return(rtnl_message_type_is_neigh(nlmsg_type), -EINVAL);
310 assert_return(ndm_family == AF_INET ||
311 ndm_family == AF_INET6 ||
312 ndm_family == PF_BRIDGE, -EINVAL);
313 assert_return(ret, -EINVAL);
314
315 r = message_new(rtnl, ret, nlmsg_type);
316 if (r < 0)
317 return r;
318
319 if (nlmsg_type == RTM_NEWNEIGH)
320 (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND;
321
322 ndm = NLMSG_DATA((*ret)->hdr);
323
324 ndm->ndm_family = ndm_family;
325 ndm->ndm_ifindex = index;
326
327 return 0;
328 }
329
330 int sd_rtnl_message_link_set_flags(sd_rtnl_message *m, unsigned flags, unsigned change) {
331 struct ifinfomsg *ifi;
332
333 assert_return(m, -EINVAL);
334 assert_return(m->hdr, -EINVAL);
335 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
336 assert_return(change, -EINVAL);
337
338 ifi = NLMSG_DATA(m->hdr);
339
340 ifi->ifi_flags = flags;
341 ifi->ifi_change = change;
342
343 return 0;
344 }
345
346 int sd_rtnl_message_link_set_type(sd_rtnl_message *m, unsigned type) {
347 struct ifinfomsg *ifi;
348
349 assert_return(m, -EINVAL);
350 assert_return(m->hdr, -EINVAL);
351 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
352
353 ifi = NLMSG_DATA(m->hdr);
354
355 ifi->ifi_type = type;
356
357 return 0;
358 }
359
360 int sd_rtnl_message_link_set_family(sd_rtnl_message *m, unsigned family) {
361 struct ifinfomsg *ifi;
362
363 assert_return(m, -EINVAL);
364 assert_return(m->hdr, -EINVAL);
365 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
366
367 ifi = NLMSG_DATA(m->hdr);
368
369 ifi->ifi_family = family;
370
371 return 0;
372 }
373
374 int sd_rtnl_message_new_link(sd_rtnl *rtnl, sd_rtnl_message **ret,
375 uint16_t nlmsg_type, int index) {
376 struct ifinfomsg *ifi;
377 int r;
378
379 assert_return(rtnl_message_type_is_link(nlmsg_type), -EINVAL);
380 assert_return(nlmsg_type != RTM_DELLINK || index > 0, -EINVAL);
381 assert_return(ret, -EINVAL);
382
383 r = message_new(rtnl, ret, nlmsg_type);
384 if (r < 0)
385 return r;
386
387 if (nlmsg_type == RTM_NEWLINK)
388 (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
389
390 ifi = NLMSG_DATA((*ret)->hdr);
391
392 ifi->ifi_family = AF_UNSPEC;
393 ifi->ifi_index = index;
394
395 return 0;
396 }
397
398 int sd_rtnl_message_request_dump(sd_rtnl_message *m, int dump) {
399 assert_return(m, -EINVAL);
400 assert_return(m->hdr, -EINVAL);
401 assert_return(m->hdr->nlmsg_type == RTM_GETLINK ||
402 m->hdr->nlmsg_type == RTM_GETADDR ||
403 m->hdr->nlmsg_type == RTM_GETROUTE ||
404 m->hdr->nlmsg_type == RTM_GETNEIGH,
405 -EINVAL);
406
407 if (dump)
408 m->hdr->nlmsg_flags |= NLM_F_DUMP;
409 else
410 m->hdr->nlmsg_flags &= ~NLM_F_DUMP;
411
412 return 0;
413 }
414
415 int sd_rtnl_message_addr_set_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
416 struct ifaddrmsg *ifa;
417
418 assert_return(m, -EINVAL);
419 assert_return(m->hdr, -EINVAL);
420 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
421
422 ifa = NLMSG_DATA(m->hdr);
423
424 if ((ifa->ifa_family == AF_INET && prefixlen > 32) ||
425 (ifa->ifa_family == AF_INET6 && prefixlen > 128))
426 return -ERANGE;
427
428 ifa->ifa_prefixlen = prefixlen;
429
430 return 0;
431 }
432
433 int sd_rtnl_message_addr_set_flags(sd_rtnl_message *m, unsigned char flags) {
434 struct ifaddrmsg *ifa;
435
436 assert_return(m, -EINVAL);
437 assert_return(m->hdr, -EINVAL);
438 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
439
440 ifa = NLMSG_DATA(m->hdr);
441
442 ifa->ifa_flags = flags;
443
444 return 0;
445 }
446
447 int sd_rtnl_message_addr_set_scope(sd_rtnl_message *m, unsigned char scope) {
448 struct ifaddrmsg *ifa;
449
450 assert_return(m, -EINVAL);
451 assert_return(m->hdr, -EINVAL);
452 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
453
454 ifa = NLMSG_DATA(m->hdr);
455
456 ifa->ifa_scope = scope;
457
458 return 0;
459 }
460
461 int sd_rtnl_message_addr_get_family(sd_rtnl_message *m, int *family) {
462 struct ifaddrmsg *ifa;
463
464 assert_return(m, -EINVAL);
465 assert_return(m->hdr, -EINVAL);
466 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
467 assert_return(family, -EINVAL);
468
469 ifa = NLMSG_DATA(m->hdr);
470
471 *family = ifa->ifa_family;
472
473 return 0;
474 }
475
476 int sd_rtnl_message_addr_get_prefixlen(sd_rtnl_message *m, unsigned char *prefixlen) {
477 struct ifaddrmsg *ifa;
478
479 assert_return(m, -EINVAL);
480 assert_return(m->hdr, -EINVAL);
481 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
482 assert_return(prefixlen, -EINVAL);
483
484 ifa = NLMSG_DATA(m->hdr);
485
486 *prefixlen = ifa->ifa_prefixlen;
487
488 return 0;
489 }
490
491 int sd_rtnl_message_addr_get_scope(sd_rtnl_message *m, unsigned char *scope) {
492 struct ifaddrmsg *ifa;
493
494 assert_return(m, -EINVAL);
495 assert_return(m->hdr, -EINVAL);
496 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
497 assert_return(scope, -EINVAL);
498
499 ifa = NLMSG_DATA(m->hdr);
500
501 *scope = ifa->ifa_scope;
502
503 return 0;
504 }
505
506 int sd_rtnl_message_addr_get_flags(sd_rtnl_message *m, unsigned char *flags) {
507 struct ifaddrmsg *ifa;
508
509 assert_return(m, -EINVAL);
510 assert_return(m->hdr, -EINVAL);
511 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
512 assert_return(flags, -EINVAL);
513
514 ifa = NLMSG_DATA(m->hdr);
515
516 *flags = ifa->ifa_flags;
517
518 return 0;
519 }
520
521 int sd_rtnl_message_addr_get_ifindex(sd_rtnl_message *m, int *ifindex) {
522 struct ifaddrmsg *ifa;
523
524 assert_return(m, -EINVAL);
525 assert_return(m->hdr, -EINVAL);
526 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
527 assert_return(ifindex, -EINVAL);
528
529 ifa = NLMSG_DATA(m->hdr);
530
531 *ifindex = ifa->ifa_index;
532
533 return 0;
534 }
535
536 int sd_rtnl_message_new_addr(sd_rtnl *rtnl, sd_rtnl_message **ret,
537 uint16_t nlmsg_type, int index,
538 int family) {
539 struct ifaddrmsg *ifa;
540 int r;
541
542 assert_return(rtnl_message_type_is_addr(nlmsg_type), -EINVAL);
543 assert_return((nlmsg_type == RTM_GETADDR && index == 0) ||
544 index > 0, -EINVAL);
545 assert_return((nlmsg_type == RTM_GETADDR && family == AF_UNSPEC) ||
546 family == AF_INET || family == AF_INET6, -EINVAL);
547 assert_return(ret, -EINVAL);
548
549 r = message_new(rtnl, ret, nlmsg_type);
550 if (r < 0)
551 return r;
552
553 if (nlmsg_type == RTM_GETADDR)
554 (*ret)->hdr->nlmsg_flags |= NLM_F_DUMP;
555
556 ifa = NLMSG_DATA((*ret)->hdr);
557
558 ifa->ifa_index = index;
559 ifa->ifa_family = family;
560 if (family == AF_INET)
561 ifa->ifa_prefixlen = 32;
562 else if (family == AF_INET6)
563 ifa->ifa_prefixlen = 128;
564
565 return 0;
566 }
567
568 int sd_rtnl_message_new_addr_update(sd_rtnl *rtnl, sd_rtnl_message **ret,
569 int index, int family) {
570 int r;
571
572 r = sd_rtnl_message_new_addr(rtnl, ret, RTM_NEWADDR, index, family);
573 if (r < 0)
574 return r;
575
576 (*ret)->hdr->nlmsg_flags |= NLM_F_REPLACE;
577
578 return 0;
579 }
580
581 sd_rtnl_message *sd_rtnl_message_ref(sd_rtnl_message *m) {
582 if (m)
583 assert_se(REFCNT_INC(m->n_ref) >= 2);
584
585 return m;
586 }
587
588 sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m) {
589 if (m && REFCNT_DEC(m->n_ref) == 0) {
590 unsigned i;
591
592 free(m->hdr);
593
594 for (i = 0; i <= m->n_containers; i++)
595 free(m->rta_offset_tb[i]);
596
597 sd_rtnl_message_unref(m->next);
598
599 free(m);
600 }
601
602 return NULL;
603 }
604
605 int sd_rtnl_message_get_type(sd_rtnl_message *m, uint16_t *type) {
606 assert_return(m, -EINVAL);
607 assert_return(type, -EINVAL);
608
609 *type = m->hdr->nlmsg_type;
610
611 return 0;
612 }
613
614 int sd_rtnl_message_is_broadcast(sd_rtnl_message *m) {
615 assert_return(m, -EINVAL);
616
617 return !m->hdr->nlmsg_pid;
618 }
619
620 int sd_rtnl_message_link_get_ifindex(sd_rtnl_message *m, int *ifindex) {
621 struct ifinfomsg *ifi;
622
623 assert_return(m, -EINVAL);
624 assert_return(m->hdr, -EINVAL);
625 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
626 assert_return(ifindex, -EINVAL);
627
628 ifi = NLMSG_DATA(m->hdr);
629
630 *ifindex = ifi->ifi_index;
631
632 return 0;
633 }
634
635 int sd_rtnl_message_link_get_flags(sd_rtnl_message *m, unsigned *flags) {
636 struct ifinfomsg *ifi;
637
638 assert_return(m, -EINVAL);
639 assert_return(m->hdr, -EINVAL);
640 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
641 assert_return(flags, -EINVAL);
642
643 ifi = NLMSG_DATA(m->hdr);
644
645 *flags = ifi->ifi_flags;
646
647 return 0;
648 }
649
650 int sd_rtnl_message_link_get_type(sd_rtnl_message *m, unsigned *type) {
651 struct ifinfomsg *ifi;
652
653 assert_return(m, -EINVAL);
654 assert_return(m->hdr, -EINVAL);
655 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
656 assert_return(type, -EINVAL);
657
658 ifi = NLMSG_DATA(m->hdr);
659
660 *type = ifi->ifi_type;
661
662 return 0;
663 }
664
665 /* If successful the updated message will be correctly aligned, if
666 unsuccessful the old message is untouched. */
667 static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, size_t data_length) {
668 uint32_t rta_length;
669 size_t message_length, padding_length;
670 struct nlmsghdr *new_hdr;
671 struct rtattr *rta;
672 char *padding;
673 unsigned i;
674 int offset;
675
676 assert(m);
677 assert(m->hdr);
678 assert(!m->sealed);
679 assert(NLMSG_ALIGN(m->hdr->nlmsg_len) == m->hdr->nlmsg_len);
680 assert(!data || data_length);
681
682 /* get offset of the new attribute */
683 offset = m->hdr->nlmsg_len;
684
685 /* get the size of the new rta attribute (with padding at the end) */
686 rta_length = RTA_LENGTH(data_length);
687
688 /* get the new message size (with padding at the end) */
689 message_length = offset + RTA_ALIGN(rta_length);
690
691 /* realloc to fit the new attribute */
692 new_hdr = realloc(m->hdr, message_length);
693 if (!new_hdr)
694 return -ENOMEM;
695 m->hdr = new_hdr;
696
697 /* get pointer to the attribute we are about to add */
698 rta = (struct rtattr *) ((uint8_t *) m->hdr + offset);
699
700 /* if we are inside containers, extend them */
701 for (i = 0; i < m->n_containers; i++)
702 GET_CONTAINER(m, i)->rta_len += message_length - offset;
703
704 /* fill in the attribute */
705 rta->rta_type = type;
706 rta->rta_len = rta_length;
707 if (data)
708 /* we don't deal with the case where the user lies about the type
709 * and gives us too little data (so don't do that)
710 */
711 padding = mempcpy(RTA_DATA(rta), data, data_length);
712 else {
713 /* if no data was passed, make sure we still initialize the padding
714 note that we can have data_length > 0 (used by some containers) */
715 padding = RTA_DATA(rta);
716 }
717
718 /* make sure also the padding at the end of the message is initialized */
719 padding_length = (uint8_t*)m->hdr + message_length - (uint8_t*)padding;
720 memzero(padding, padding_length);
721
722 /* update message size */
723 m->hdr->nlmsg_len = message_length;
724
725 return offset;
726 }
727
728 static int message_attribute_has_type(sd_rtnl_message *m, uint16_t attribute_type, uint16_t data_type) {
729 const NLType *type;
730 int r;
731
732 r = type_system_get_type(m->container_type_system[m->n_containers], &type, attribute_type);
733 if (r < 0)
734 return r;
735
736 if (type->type != data_type)
737 return -EINVAL;
738
739 return type->size;
740 }
741
742 int sd_rtnl_message_append_string(sd_rtnl_message *m, unsigned short type, const char *data) {
743 size_t length, size;
744 int r;
745
746 assert_return(m, -EINVAL);
747 assert_return(!m->sealed, -EPERM);
748 assert_return(data, -EINVAL);
749
750 r = message_attribute_has_type(m, type, NLA_STRING);
751 if (r < 0)
752 return r;
753 else
754 size = (size_t)r;
755
756 if (size) {
757 length = strnlen(data, size+1);
758 if (length > size)
759 return -EINVAL;
760 } else
761 length = strlen(data);
762
763 r = add_rtattr(m, type, data, length + 1);
764 if (r < 0)
765 return r;
766
767 return 0;
768 }
769
770 int sd_rtnl_message_append_u8(sd_rtnl_message *m, unsigned short type, uint8_t data) {
771 int r;
772
773 assert_return(m, -EINVAL);
774 assert_return(!m->sealed, -EPERM);
775
776 r = message_attribute_has_type(m, type, NLA_U8);
777 if (r < 0)
778 return r;
779
780 r = add_rtattr(m, type, &data, sizeof(uint8_t));
781 if (r < 0)
782 return r;
783
784 return 0;
785 }
786
787
788 int sd_rtnl_message_append_u16(sd_rtnl_message *m, unsigned short type, uint16_t data) {
789 int r;
790
791 assert_return(m, -EINVAL);
792 assert_return(!m->sealed, -EPERM);
793
794 r = message_attribute_has_type(m, type, NLA_U16);
795 if (r < 0)
796 return r;
797
798 r = add_rtattr(m, type, &data, sizeof(uint16_t));
799 if (r < 0)
800 return r;
801
802 return 0;
803 }
804
805 int sd_rtnl_message_append_u32(sd_rtnl_message *m, unsigned short type, uint32_t data) {
806 int r;
807
808 assert_return(m, -EINVAL);
809 assert_return(!m->sealed, -EPERM);
810
811 r = message_attribute_has_type(m, type, NLA_U32);
812 if (r < 0)
813 return r;
814
815 r = add_rtattr(m, type, &data, sizeof(uint32_t));
816 if (r < 0)
817 return r;
818
819 return 0;
820 }
821
822 int sd_rtnl_message_append_in_addr(sd_rtnl_message *m, unsigned short type, const struct in_addr *data) {
823 int r;
824
825 assert_return(m, -EINVAL);
826 assert_return(!m->sealed, -EPERM);
827 assert_return(data, -EINVAL);
828
829 r = message_attribute_has_type(m, type, NLA_IN_ADDR);
830 if (r < 0)
831 return r;
832
833 r = add_rtattr(m, type, data, sizeof(struct in_addr));
834 if (r < 0)
835 return r;
836
837 return 0;
838 }
839
840 int sd_rtnl_message_append_in6_addr(sd_rtnl_message *m, unsigned short type, const struct in6_addr *data) {
841 int r;
842
843 assert_return(m, -EINVAL);
844 assert_return(!m->sealed, -EPERM);
845 assert_return(data, -EINVAL);
846
847 r = message_attribute_has_type(m, type, NLA_IN_ADDR);
848 if (r < 0)
849 return r;
850
851 r = add_rtattr(m, type, data, sizeof(struct in6_addr));
852 if (r < 0)
853 return r;
854
855 return 0;
856 }
857
858 int sd_rtnl_message_append_ether_addr(sd_rtnl_message *m, unsigned short type, const struct ether_addr *data) {
859 int r;
860
861 assert_return(m, -EINVAL);
862 assert_return(!m->sealed, -EPERM);
863 assert_return(data, -EINVAL);
864
865 r = message_attribute_has_type(m, type, NLA_ETHER_ADDR);
866 if (r < 0)
867 return r;
868
869 r = add_rtattr(m, type, data, ETH_ALEN);
870 if (r < 0)
871 return r;
872
873 return 0;
874 }
875
876 int sd_rtnl_message_append_cache_info(sd_rtnl_message *m, unsigned short type, const struct ifa_cacheinfo *info) {
877 int r;
878
879 assert_return(m, -EINVAL);
880 assert_return(!m->sealed, -EPERM);
881 assert_return(info, -EINVAL);
882
883 r = message_attribute_has_type(m, type, NLA_CACHE_INFO);
884 if (r < 0)
885 return r;
886
887 r = add_rtattr(m, type, info, sizeof(struct ifa_cacheinfo));
888 if (r < 0)
889 return r;
890
891 return 0;
892 }
893
894 int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type) {
895 size_t size;
896 int r;
897
898 assert_return(m, -EINVAL);
899 assert_return(!m->sealed, -EPERM);
900 assert_return(m->n_containers < RTNL_CONTAINER_DEPTH, -ERANGE);
901
902 r = message_attribute_has_type(m, type, NLA_NESTED);
903 if (r < 0)
904 return r;
905 else
906 size = (size_t)r;
907
908 r = type_system_get_type_system(m->container_type_system[m->n_containers],
909 &m->container_type_system[m->n_containers + 1],
910 type);
911 if (r < 0)
912 return r;
913
914 r = add_rtattr(m, type | NLA_F_NESTED, NULL, size);
915 if (r < 0)
916 return r;
917
918 m->container_offsets[m->n_containers ++] = r;
919
920 return 0;
921 }
922
923 int sd_rtnl_message_open_container_union(sd_rtnl_message *m, unsigned short type, const char *key) {
924 const NLTypeSystemUnion *type_system_union;
925 int r;
926
927 assert_return(m, -EINVAL);
928 assert_return(!m->sealed, -EPERM);
929
930 r = type_system_get_type_system_union(m->container_type_system[m->n_containers], &type_system_union, type);
931 if (r < 0)
932 return r;
933
934 r = type_system_union_get_type_system(type_system_union,
935 &m->container_type_system[m->n_containers + 1],
936 key);
937 if (r < 0)
938 return r;
939
940 r = sd_rtnl_message_append_string(m, type_system_union->match, key);
941 if (r < 0)
942 return r;
943
944 /* do we evere need non-null size */
945 r = add_rtattr(m, type, NULL, 0);
946 if (r < 0)
947 return r;
948
949 m->container_offsets[m->n_containers ++] = r;
950
951 return 0;
952 }
953
954
955 int sd_rtnl_message_close_container(sd_rtnl_message *m) {
956 assert_return(m, -EINVAL);
957 assert_return(!m->sealed, -EPERM);
958 assert_return(m->n_containers > 0, -EINVAL);
959
960 m->container_type_system[m->n_containers] = NULL;
961 m->n_containers --;
962
963 return 0;
964 }
965
966 int rtnl_message_read_internal(sd_rtnl_message *m, unsigned short type, void **data) {
967 struct rtattr *rta;
968
969 assert_return(m, -EINVAL);
970 assert_return(m->sealed, -EPERM);
971 assert_return(data, -EINVAL);
972 assert(m->n_containers <= RTNL_CONTAINER_DEPTH);
973 assert(m->rta_offset_tb[m->n_containers]);
974 assert(type < m->rta_tb_size[m->n_containers]);
975
976 if(!m->rta_offset_tb[m->n_containers][type])
977 return -ENODATA;
978
979 rta = (struct rtattr*)((uint8_t *) m->hdr + m->rta_offset_tb[m->n_containers][type]);
980
981 *data = RTA_DATA(rta);
982
983 return RTA_PAYLOAD(rta);
984 }
985
986 int sd_rtnl_message_read_string(sd_rtnl_message *m, unsigned short type, const char **data) {
987 int r;
988 void *attr_data;
989
990 assert_return(m, -EINVAL);
991
992 r = message_attribute_has_type(m, type, NLA_STRING);
993 if (r < 0)
994 return r;
995
996 r = rtnl_message_read_internal(m, type, &attr_data);
997 if (r < 0)
998 return r;
999 else if (strnlen(attr_data, r) >= (size_t) r)
1000 return -EIO;
1001
1002 if (data)
1003 *data = (const char *) attr_data;
1004
1005 return 0;
1006 }
1007
1008 int sd_rtnl_message_read_u8(sd_rtnl_message *m, unsigned short type, uint8_t *data) {
1009 int r;
1010 void *attr_data;
1011
1012 assert_return(m, -EINVAL);
1013
1014 r = message_attribute_has_type(m, type, NLA_U8);
1015 if (r < 0)
1016 return r;
1017
1018 r = rtnl_message_read_internal(m, type, &attr_data);
1019 if (r < 0)
1020 return r;
1021 else if ((size_t) r < sizeof(uint8_t))
1022 return -EIO;
1023
1024 if (data)
1025 *data = *(uint8_t *) attr_data;
1026
1027 return 0;
1028 }
1029
1030 int sd_rtnl_message_read_u16(sd_rtnl_message *m, unsigned short type, uint16_t *data) {
1031 int r;
1032 void *attr_data;
1033
1034 assert_return(m, -EINVAL);
1035
1036 r = message_attribute_has_type(m, type, NLA_U16);
1037 if (r < 0)
1038 return r;
1039
1040 r = rtnl_message_read_internal(m, type, &attr_data);
1041 if (r < 0)
1042 return r;
1043 else if ((size_t) r < sizeof(uint16_t))
1044 return -EIO;
1045
1046 if (data)
1047 *data = *(uint16_t *) attr_data;
1048
1049 return 0;
1050 }
1051
1052 int sd_rtnl_message_read_u32(sd_rtnl_message *m, unsigned short type, uint32_t *data) {
1053 int r;
1054 void *attr_data;
1055
1056 assert_return(m, -EINVAL);
1057
1058 r = message_attribute_has_type(m, type, NLA_U32);
1059 if (r < 0)
1060 return r;
1061
1062 r = rtnl_message_read_internal(m, type, &attr_data);
1063 if (r < 0)
1064 return r;
1065 else if ((size_t)r < sizeof(uint32_t))
1066 return -EIO;
1067
1068 if (data)
1069 *data = *(uint32_t *) attr_data;
1070
1071 return 0;
1072 }
1073
1074 int sd_rtnl_message_read_ether_addr(sd_rtnl_message *m, unsigned short type, struct ether_addr *data) {
1075 int r;
1076 void *attr_data;
1077
1078 assert_return(m, -EINVAL);
1079
1080 r = message_attribute_has_type(m, type, NLA_ETHER_ADDR);
1081 if (r < 0)
1082 return r;
1083
1084 r = rtnl_message_read_internal(m, type, &attr_data);
1085 if (r < 0)
1086 return r;
1087 else if ((size_t)r < sizeof(struct ether_addr))
1088 return -EIO;
1089
1090 if (data)
1091 memcpy(data, attr_data, sizeof(struct ether_addr));
1092
1093 return 0;
1094 }
1095
1096 int sd_rtnl_message_read_cache_info(sd_rtnl_message *m, unsigned short type, struct ifa_cacheinfo *info) {
1097 int r;
1098 void *attr_data;
1099
1100 assert_return(m, -EINVAL);
1101
1102 r = message_attribute_has_type(m, type, NLA_CACHE_INFO);
1103 if (r < 0)
1104 return r;
1105
1106 r = rtnl_message_read_internal(m, type, &attr_data);
1107 if (r < 0)
1108 return r;
1109 else if ((size_t)r < sizeof(struct ifa_cacheinfo))
1110 return -EIO;
1111
1112 if (info)
1113 memcpy(info, attr_data, sizeof(struct ifa_cacheinfo));
1114
1115 return 0;
1116 }
1117
1118 int sd_rtnl_message_read_in_addr(sd_rtnl_message *m, unsigned short type, struct in_addr *data) {
1119 int r;
1120 void *attr_data;
1121
1122 assert_return(m, -EINVAL);
1123
1124 r = message_attribute_has_type(m, type, NLA_IN_ADDR);
1125 if (r < 0)
1126 return r;
1127
1128 r = rtnl_message_read_internal(m, type, &attr_data);
1129 if (r < 0)
1130 return r;
1131 else if ((size_t)r < sizeof(struct in_addr))
1132 return -EIO;
1133
1134 if (data)
1135 memcpy(data, attr_data, sizeof(struct in_addr));
1136
1137 return 0;
1138 }
1139
1140 int sd_rtnl_message_read_in6_addr(sd_rtnl_message *m, unsigned short type, struct in6_addr *data) {
1141 int r;
1142 void *attr_data;
1143
1144 assert_return(m, -EINVAL);
1145
1146 r = message_attribute_has_type(m, type, NLA_IN_ADDR);
1147 if (r < 0)
1148 return r;
1149
1150 r = rtnl_message_read_internal(m, type, &attr_data);
1151 if (r < 0)
1152 return r;
1153 else if ((size_t)r < sizeof(struct in6_addr))
1154 return -EIO;
1155
1156 if (data)
1157 memcpy(data, attr_data, sizeof(struct in6_addr));
1158
1159 return 0;
1160 }
1161
1162 int sd_rtnl_message_enter_container(sd_rtnl_message *m, unsigned short type) {
1163 const NLType *nl_type;
1164 const NLTypeSystem *type_system;
1165 void *container;
1166 size_t size;
1167 int r;
1168
1169 assert_return(m, -EINVAL);
1170 assert_return(m->n_containers < RTNL_CONTAINER_DEPTH, -EINVAL);
1171
1172 r = type_system_get_type(m->container_type_system[m->n_containers],
1173 &nl_type,
1174 type);
1175 if (r < 0)
1176 return r;
1177
1178 if (nl_type->type == NLA_NESTED) {
1179 r = type_system_get_type_system(m->container_type_system[m->n_containers],
1180 &type_system,
1181 type);
1182 if (r < 0)
1183 return r;
1184 } else if (nl_type->type == NLA_UNION) {
1185 const NLTypeSystemUnion *type_system_union;
1186 const char *key;
1187
1188 r = type_system_get_type_system_union(m->container_type_system[m->n_containers],
1189 &type_system_union,
1190 type);
1191 if (r < 0)
1192 return r;
1193
1194 r = sd_rtnl_message_read_string(m, type_system_union->match, &key);
1195 if (r < 0)
1196 return r;
1197
1198 r = type_system_union_get_type_system(type_system_union,
1199 &type_system,
1200 key);
1201 if (r < 0)
1202 return r;
1203 } else
1204 return -EINVAL;
1205
1206 r = rtnl_message_read_internal(m, type, &container);
1207 if (r < 0)
1208 return r;
1209 else
1210 size = (size_t)r;
1211
1212 m->n_containers ++;
1213
1214 r = rtnl_message_parse(m,
1215 &m->rta_offset_tb[m->n_containers],
1216 &m->rta_tb_size[m->n_containers],
1217 type_system->max,
1218 container,
1219 size);
1220 if (r < 0) {
1221 m->n_containers --;
1222 return r;
1223 }
1224
1225 m->container_type_system[m->n_containers] = type_system;
1226
1227 return 0;
1228 }
1229
1230 int sd_rtnl_message_exit_container(sd_rtnl_message *m) {
1231 assert_return(m, -EINVAL);
1232 assert_return(m->sealed, -EINVAL);
1233 assert_return(m->n_containers > 0, -EINVAL);
1234
1235 free(m->rta_offset_tb[m->n_containers]);
1236 m->rta_offset_tb[m->n_containers] = NULL;
1237 m->container_type_system[m->n_containers] = NULL;
1238
1239 m->n_containers --;
1240
1241 return 0;
1242 }
1243
1244 uint32_t rtnl_message_get_serial(sd_rtnl_message *m) {
1245 assert(m);
1246 assert(m->hdr);
1247
1248 return m->hdr->nlmsg_seq;
1249 }
1250
1251 int sd_rtnl_message_is_error(sd_rtnl_message *m) {
1252 assert_return(m, 0);
1253 assert_return(m->hdr, 0);
1254
1255 return m->hdr->nlmsg_type == NLMSG_ERROR;
1256 }
1257
1258 int sd_rtnl_message_get_errno(sd_rtnl_message *m) {
1259 struct nlmsgerr *err;
1260
1261 assert_return(m, -EINVAL);
1262 assert_return(m->hdr, -EINVAL);
1263
1264 if (!sd_rtnl_message_is_error(m))
1265 return 0;
1266
1267 err = NLMSG_DATA(m->hdr);
1268
1269 return err->error;
1270 }
1271
1272 int rtnl_message_parse(sd_rtnl_message *m,
1273 size_t **rta_offset_tb,
1274 unsigned short *rta_tb_size,
1275 int max,
1276 struct rtattr *rta,
1277 unsigned int rt_len) {
1278 unsigned short type;
1279 size_t *tb;
1280
1281 tb = new0(size_t, max + 1);
1282 if(!tb)
1283 return -ENOMEM;
1284
1285 *rta_tb_size = max + 1;
1286
1287 for (; RTA_OK(rta, rt_len); rta = RTA_NEXT(rta, rt_len)) {
1288 type = RTA_TYPE(rta);
1289
1290 /* if the kernel is newer than the headers we used
1291 when building, we ignore out-of-range attributes
1292 */
1293 if (type > max)
1294 continue;
1295
1296 if (tb[type])
1297 log_debug("rtnl: message parse - overwriting repeated attribute");
1298
1299 tb[type] = (uint8_t *) rta - (uint8_t *) m->hdr;
1300 }
1301
1302 *rta_offset_tb = tb;
1303
1304 return 0;
1305 }
1306
1307 /* returns the number of bytes sent, or a negative error code */
1308 int socket_write_message(sd_rtnl *nl, sd_rtnl_message *m) {
1309 union {
1310 struct sockaddr sa;
1311 struct sockaddr_nl nl;
1312 } addr = {
1313 .nl.nl_family = AF_NETLINK,
1314 };
1315 ssize_t k;
1316
1317 assert(nl);
1318 assert(m);
1319 assert(m->hdr);
1320
1321 k = sendto(nl->fd, m->hdr, m->hdr->nlmsg_len,
1322 0, &addr.sa, sizeof(addr));
1323 if (k < 0)
1324 return (errno == EAGAIN) ? 0 : -errno;
1325
1326 return k;
1327 }
1328
1329 static int socket_recv_message(int fd, struct iovec *iov, uint32_t *_group, bool peek) {
1330 uint8_t cred_buffer[CMSG_SPACE(sizeof(struct ucred)) +
1331 CMSG_SPACE(sizeof(struct nl_pktinfo))];
1332 struct msghdr msg = {
1333 .msg_iov = iov,
1334 .msg_iovlen = 1,
1335 .msg_control = cred_buffer,
1336 .msg_controllen = sizeof(cred_buffer),
1337 };
1338 struct cmsghdr *cmsg;
1339 uint32_t group = 0;
1340 bool auth = false;
1341 int r;
1342
1343 assert(fd >= 0);
1344 assert(iov);
1345
1346 r = recvmsg(fd, &msg, MSG_TRUNC | (peek ? MSG_PEEK : 0));
1347 if (r < 0) {
1348 /* no data */
1349 if (errno == ENOBUFS)
1350 log_debug("rtnl: kernel receive buffer overrun");
1351 else if (errno == EAGAIN)
1352 log_debug("rtnl: no data in socket");
1353
1354 return (errno == EAGAIN || errno == EINTR) ? 0 : -errno;
1355 } else if (r == 0)
1356 /* connection was closed by the kernel */
1357 return -ECONNRESET;
1358
1359 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
1360 if (cmsg->cmsg_level == SOL_SOCKET &&
1361 cmsg->cmsg_type == SCM_CREDENTIALS &&
1362 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1363 struct ucred *ucred = (void *)CMSG_DATA(cmsg);
1364
1365 /* from the kernel */
1366 if (ucred->pid == 0)
1367 auth = true;
1368 else
1369 log_debug("rtnl: ignoring message from pid %u", ucred->pid);
1370 } else if (cmsg->cmsg_level == SOL_NETLINK &&
1371 cmsg->cmsg_type == NETLINK_PKTINFO &&
1372 cmsg->cmsg_len == CMSG_LEN(sizeof(struct nl_pktinfo))) {
1373 struct nl_pktinfo *pktinfo = (void *)CMSG_DATA(cmsg);
1374
1375 /* multi-cast group */
1376 group = pktinfo->group;
1377 }
1378 }
1379
1380 if (!auth) {
1381 /* not from the kernel, ignore */
1382 if (peek) {
1383 /* drop the message */
1384 r = recvmsg(fd, &msg, 0);
1385 if (r < 0)
1386 return (errno == EAGAIN || errno == EINTR) ? 0 : -errno;
1387 }
1388
1389 return 0;
1390 }
1391
1392 if (group)
1393 *_group = group;
1394
1395 return r;
1396 }
1397
1398 /* On success, the number of bytes received is returned and *ret points to the received message
1399 * which has a valid header and the correct size.
1400 * If nothing useful was received 0 is returned.
1401 * On failure, a negative error code is returned.
1402 */
1403 int socket_read_message(sd_rtnl *rtnl) {
1404 _cleanup_rtnl_message_unref_ sd_rtnl_message *first = NULL;
1405 struct iovec iov = {};
1406 uint32_t group = 0;
1407 bool multi_part = false, done = false;
1408 struct nlmsghdr *new_msg;
1409 size_t len;
1410 int r;
1411 unsigned i = 0;
1412
1413 assert(rtnl);
1414 assert(rtnl->rbuffer);
1415 assert(rtnl->rbuffer_allocated >= sizeof(struct nlmsghdr));
1416
1417 /* read nothing, just get the pending message size */
1418 r = socket_recv_message(rtnl->fd, &iov, &group, true);
1419 if (r <= 0)
1420 return r;
1421 else
1422 len = (size_t)r;
1423
1424 /* make room for the pending message */
1425 if (!greedy_realloc((void **)&rtnl->rbuffer,
1426 &rtnl->rbuffer_allocated,
1427 len, sizeof(uint8_t)))
1428 return -ENOMEM;
1429
1430 iov.iov_base = rtnl->rbuffer;
1431 iov.iov_len = rtnl->rbuffer_allocated;
1432
1433 /* read the pending message */
1434 r = socket_recv_message(rtnl->fd, &iov, &group, false);
1435 if (r <= 0)
1436 return r;
1437 else
1438 len = (size_t)r;
1439
1440 if (len > rtnl->rbuffer_allocated)
1441 /* message did not fit in read buffer */
1442 return -EIO;
1443
1444 if (NLMSG_OK(rtnl->rbuffer, len) && rtnl->rbuffer->nlmsg_flags & NLM_F_MULTI) {
1445 multi_part = true;
1446
1447 for (i = 0; i < rtnl->rqueue_partial_size; i++) {
1448 if (rtnl_message_get_serial(rtnl->rqueue_partial[i]) ==
1449 rtnl->rbuffer->nlmsg_seq) {
1450 first = rtnl->rqueue_partial[i];
1451 break;
1452 }
1453 }
1454 }
1455
1456 for (new_msg = rtnl->rbuffer; NLMSG_OK(new_msg, len) && !done; new_msg = NLMSG_NEXT(new_msg, len)) {
1457 _cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
1458 const NLType *nl_type;
1459
1460 if (!group && new_msg->nlmsg_pid != rtnl->sockaddr.nl.nl_pid)
1461 /* not broadcast and not for us */
1462 continue;
1463
1464 if (new_msg->nlmsg_type == NLMSG_NOOP)
1465 /* silently drop noop messages */
1466 continue;
1467
1468 if (new_msg->nlmsg_type == NLMSG_DONE) {
1469 /* finished reading multi-part message */
1470 done = true;
1471
1472 continue;
1473 }
1474
1475 /* check that we support this message type */
1476 r = type_system_get_type(NULL, &nl_type, new_msg->nlmsg_type);
1477 if (r < 0) {
1478 if (r == -ENOTSUP)
1479 log_debug("sd-rtnl: ignored message with unknown type: %u",
1480 new_msg->nlmsg_type);
1481
1482 continue;
1483 }
1484
1485 /* check that the size matches the message type */
1486 if (new_msg->nlmsg_len < NLMSG_LENGTH(nl_type->size)) {
1487 log_debug("sd-rtnl: message larger than expected, dropping");
1488 continue;
1489 }
1490
1491 r = message_new_empty(rtnl, &m);
1492 if (r < 0)
1493 return r;
1494
1495 m->hdr = memdup(new_msg, new_msg->nlmsg_len);
1496 if (!m->hdr)
1497 return -ENOMEM;
1498
1499 /* seal and parse the top-level message */
1500 r = sd_rtnl_message_rewind(m);
1501 if (r < 0)
1502 return r;
1503
1504 /* push the message onto the multi-part message stack */
1505 if (first)
1506 m->next = first;
1507 first = m;
1508 m = NULL;
1509 }
1510
1511 if (len)
1512 log_debug("sd-rtnl: discarding %zu bytes of incoming message", len);
1513
1514 if (!first)
1515 return 0;
1516
1517 if (!multi_part || done) {
1518 /* we got a complete message, push it on the read queue */
1519 r = rtnl_rqueue_make_room(rtnl);
1520 if (r < 0)
1521 return r;
1522
1523 rtnl->rqueue[rtnl->rqueue_size ++] = first;
1524 first = NULL;
1525
1526 if (multi_part && (i < rtnl->rqueue_partial_size)) {
1527 /* remove the message form the partial read queue */
1528 memmove(rtnl->rqueue_partial + i,rtnl->rqueue_partial + i + 1,
1529 sizeof(sd_rtnl_message*) * (rtnl->rqueue_partial_size - i - 1));
1530 rtnl->rqueue_partial_size --;
1531 }
1532
1533 return 1;
1534 } else {
1535 /* we only got a partial multi-part message, push it on the
1536 partial read queue */
1537 if (i < rtnl->rqueue_partial_size) {
1538 rtnl->rqueue_partial[i] = first;
1539 } else {
1540 r = rtnl_rqueue_partial_make_room(rtnl);
1541 if (r < 0)
1542 return r;
1543
1544 rtnl->rqueue_partial[rtnl->rqueue_partial_size ++] = first;
1545 }
1546 first = NULL;
1547
1548 return 0;
1549 }
1550 }
1551
1552 int sd_rtnl_message_rewind(sd_rtnl_message *m) {
1553 const NLType *type;
1554 unsigned i;
1555 int r;
1556
1557 assert_return(m, -EINVAL);
1558
1559 /* don't allow appending to message once parsed */
1560 if (!m->sealed)
1561 rtnl_message_seal(m);
1562
1563 for (i = 1; i <= m->n_containers; i++) {
1564 free(m->rta_offset_tb[i]);
1565 m->rta_offset_tb[i] = NULL;
1566 m->rta_tb_size[i] = 0;
1567 m->container_type_system[i] = NULL;
1568 }
1569
1570 m->n_containers = 0;
1571
1572 if (m->rta_offset_tb[0]) {
1573 /* top-level attributes have already been parsed */
1574 return 0;
1575 }
1576
1577 assert(m->hdr);
1578
1579 r = type_system_get_type(NULL, &type, m->hdr->nlmsg_type);
1580 if (r < 0)
1581 return r;
1582
1583 if (type->type == NLA_NESTED) {
1584 const NLTypeSystem *type_system = type->type_system;
1585
1586 assert(type_system);
1587
1588 m->container_type_system[0] = type_system;
1589
1590 r = rtnl_message_parse(m,
1591 &m->rta_offset_tb[m->n_containers],
1592 &m->rta_tb_size[m->n_containers],
1593 type_system->max,
1594 (struct rtattr*)((uint8_t*)NLMSG_DATA(m->hdr) +
1595 NLMSG_ALIGN(type->size)),
1596 NLMSG_PAYLOAD(m->hdr, type->size));
1597 if (r < 0)
1598 return r;
1599 }
1600
1601 return 0;
1602 }
1603
1604 void rtnl_message_seal(sd_rtnl_message *m) {
1605 assert(m);
1606 assert(!m->sealed);
1607
1608 m->sealed = true;
1609 }
1610
1611 sd_rtnl_message *sd_rtnl_message_next(sd_rtnl_message *m) {
1612 assert_return(m, NULL);
1613
1614 return m->next;
1615 }
Unnamed repository; edit this file 'description' to name the repository.