]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-rtnl/rtnl-message.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added attribute support for sd-rtnl
[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 <linux/rtnetlink.h>
23 #include <netinet/in.h>
24 #include <netinet/ether.h>
25 #include <stdbool.h>
26 #include <unistd.h>
27
28 #include "util.h"
29 #include "refcnt.h"
30
31 #include "sd-rtnl.h"
32 #include "rtnl-util.h"
33 #include "rtnl-internal.h"
34
35 #define GET_CONTAINER(m, i) (i < (m)->n_containers ? (struct rtattr*)((uint8_t*)(m)->hdr + (m)->container_offsets[i]) : NULL)
36 #define NEXT_RTA(m) ((struct rtattr*)((uint8_t*)(m)->hdr + (m)->next_rta_offset))
37 #define UPDATE_RTA(m, new) (m)->next_rta_offset = (uint8_t*)(new) - (uint8_t*)(m)->hdr;
38 #define PUSH_CONTAINER(m, new) (m)->container_offsets[(m)->n_containers ++] = (uint8_t*)(new) - (uint8_t*)(m)->hdr;
39
40 int message_new(sd_rtnl_message **ret, size_t initial_size) {
41 sd_rtnl_message *m;
42
43 assert_return(ret, -EINVAL);
44 assert_return(initial_size >= sizeof(struct nlmsghdr), -EINVAL);
45
46 m = new0(sd_rtnl_message, 1);
47 if (!m)
48 return -ENOMEM;
49
50 m->hdr = malloc0(initial_size);
51 if (!m->hdr) {
52 free(m);
53 return -ENOMEM;
54 }
55
56 m->n_ref = REFCNT_INIT;
57
58 m->hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
59 m->sealed = false;
60
61 *ret = m;
62
63 return 0;
64 }
65
66 int sd_rtnl_message_route_set_dst_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
67 struct rtmsg *rtm;
68
69 assert_return(m, -EINVAL);
70 assert_return(m->hdr, -EINVAL);
71 assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
72
73 rtm = NLMSG_DATA(m->hdr);
74
75 if ((rtm->rtm_family == AF_INET && prefixlen > 32) ||
76 (rtm->rtm_family == AF_INET6 && prefixlen > 128))
77 return -ERANGE;
78
79 rtm->rtm_dst_len = prefixlen;
80
81 return 0;
82 }
83
84 int sd_rtnl_message_route_new(uint16_t nlmsg_type, unsigned char rtm_family,
85 sd_rtnl_message **ret) {
86 struct rtmsg *rtm;
87 int r;
88
89 assert_return(rtnl_message_type_is_route(nlmsg_type), -EINVAL);
90 assert_return(rtm_family == AF_INET || rtm_family == AF_INET6, -EINVAL);
91 assert_return(ret, -EINVAL);
92
93 r = message_new(ret, NLMSG_SPACE(sizeof(struct rtmsg)));
94 if (r < 0)
95 return r;
96
97 (*ret)->hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
98 (*ret)->hdr->nlmsg_type = nlmsg_type;
99 if (nlmsg_type == RTM_NEWROUTE)
100 (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
101
102 rtm = NLMSG_DATA((*ret)->hdr);
103
104 UPDATE_RTA(*ret, RTM_RTA(rtm));
105
106 rtm->rtm_family = rtm_family;
107 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
108 rtm->rtm_type = RTN_UNICAST;
109 rtm->rtm_table = RT_TABLE_MAIN;
110 rtm->rtm_protocol = RTPROT_BOOT;
111
112 return 0;
113 }
114
115 int sd_rtnl_message_link_set_flags(sd_rtnl_message *m, unsigned flags, unsigned change) {
116 struct ifinfomsg *ifi;
117
118 assert_return(m, -EINVAL);
119 assert_return(m->hdr, -EINVAL);
120 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
121
122 ifi = NLMSG_DATA(m->hdr);
123
124 ifi->ifi_flags = flags;
125 if (change)
126 ifi->ifi_change = change;
127 else
128 ifi->ifi_change = 0xffffffff;
129
130 return 0;
131 }
132
133 int sd_rtnl_message_link_set_type(sd_rtnl_message *m, unsigned type) {
134 struct ifinfomsg *ifi;
135
136 assert_return(m, -EINVAL);
137 assert_return(m->hdr, -EINVAL);
138 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
139
140 ifi = NLMSG_DATA(m->hdr);
141
142 ifi->ifi_type = type;
143
144 return 0;
145 }
146
147 int sd_rtnl_message_link_new(uint16_t nlmsg_type, int index, sd_rtnl_message **ret) {
148 struct ifinfomsg *ifi;
149 int r;
150
151 assert_return(rtnl_message_type_is_link(nlmsg_type), -EINVAL);
152 assert_return(nlmsg_type == RTM_NEWLINK || index > 0, -EINVAL);
153 assert_return(ret, -EINVAL);
154
155 r = message_new(ret, NLMSG_SPACE(sizeof(struct ifinfomsg)));
156 if (r < 0)
157 return r;
158
159 (*ret)->hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
160 (*ret)->hdr->nlmsg_type = nlmsg_type;
161 if (nlmsg_type == RTM_NEWLINK)
162 (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE;
163
164 ifi = NLMSG_DATA((*ret)->hdr);
165
166 ifi->ifi_family = AF_UNSPEC;
167 ifi->ifi_index = index;
168
169 UPDATE_RTA(*ret, IFLA_RTA(ifi));
170
171 return 0;
172 }
173
174 int sd_rtnl_message_addr_set_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
175 struct ifaddrmsg *ifa;
176
177 assert_return(m, -EINVAL);
178 assert_return(m->hdr, -EINVAL);
179 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
180
181 ifa = NLMSG_DATA(m->hdr);
182
183 if ((ifa->ifa_family == AF_INET && prefixlen > 32) ||
184 (ifa->ifa_family == AF_INET6 && prefixlen > 128))
185 return -ERANGE;
186
187 ifa->ifa_prefixlen = prefixlen;
188
189 return 0;
190 }
191
192 int sd_rtnl_message_addr_set_flags(sd_rtnl_message *m, unsigned char flags) {
193 struct ifaddrmsg *ifa;
194
195 assert_return(m, -EINVAL);
196 assert_return(m->hdr, -EINVAL);
197 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
198
199 ifa = NLMSG_DATA(m->hdr);
200
201 ifa->ifa_flags = flags;
202
203 return 0;
204 }
205
206 int sd_rtnl_message_addr_set_scope(sd_rtnl_message *m, unsigned char scope) {
207 struct ifaddrmsg *ifa;
208
209 assert_return(m, -EINVAL);
210 assert_return(m->hdr, -EINVAL);
211 assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
212
213 ifa = NLMSG_DATA(m->hdr);
214
215 ifa->ifa_scope = scope;
216
217 return 0;
218 }
219
220 int sd_rtnl_message_addr_new(uint16_t nlmsg_type, int index, unsigned char family,
221 sd_rtnl_message **ret) {
222 struct ifaddrmsg *ifa;
223 int r;
224
225 assert_return(rtnl_message_type_is_addr(nlmsg_type), -EINVAL);
226 assert_return(index > 0, -EINVAL);
227 assert_return(family == AF_INET || family == AF_INET6, -EINVAL);
228 assert_return(ret, -EINVAL);
229
230 r = message_new(ret, NLMSG_SPACE(sizeof(struct ifaddrmsg)));
231 if (r < 0)
232 return r;
233
234 (*ret)->hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
235 (*ret)->hdr->nlmsg_type = nlmsg_type;
236
237 ifa = NLMSG_DATA((*ret)->hdr);
238
239 ifa->ifa_index = index;
240 ifa->ifa_family = family;
241 if (family == AF_INET)
242 ifa->ifa_prefixlen = 32;
243 else if (family == AF_INET6)
244 ifa->ifa_prefixlen = 128;
245
246 UPDATE_RTA(*ret, IFA_RTA(ifa));
247
248 return 0;
249 }
250
251 sd_rtnl_message *sd_rtnl_message_ref(sd_rtnl_message *m) {
252 if (m)
253 assert_se(REFCNT_INC(m->n_ref) >= 2);
254
255 return m;
256 }
257
258 sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m) {
259 if (m && REFCNT_DEC(m->n_ref) <= 0) {
260 free(m->hdr);
261 free(m);
262 }
263
264 return NULL;
265 }
266
267 int sd_rtnl_message_get_type(sd_rtnl_message *m, uint16_t *type) {
268 assert_return(m, -EINVAL);
269 assert_return(type, -EINVAL);
270
271 *type = m->hdr->nlmsg_type;
272
273 return 0;
274 }
275
276 int sd_rtnl_message_link_get_ifindex(sd_rtnl_message *m, int *ifindex) {
277 struct ifinfomsg *ifi;
278
279 assert_return(m, -EINVAL);
280 assert_return(m->hdr, -EINVAL);
281 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
282 assert_return(ifindex, -EINVAL);
283
284 ifi = NLMSG_DATA(m->hdr);
285
286 *ifindex = ifi->ifi_index;
287
288 return 0;
289 }
290
291 int sd_rtnl_message_link_get_flags(sd_rtnl_message *m, unsigned *flags) {
292 struct ifinfomsg *ifi;
293
294 assert_return(m, -EINVAL);
295 assert_return(m->hdr, -EINVAL);
296 assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
297 assert_return(flags, -EINVAL);
298
299 ifi = NLMSG_DATA(m->hdr);
300
301 *flags = ifi->ifi_flags;
302
303 return 0;
304 }
305
306 /* If successful the updated message will be correctly aligned, if
307 unsuccessful the old message is untouched. */
308 static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, size_t data_length) {
309 uint32_t rta_length, message_length;
310 struct nlmsghdr *new_hdr;
311 struct rtattr *rta;
312 char *padding;
313 unsigned i;
314
315 assert(m);
316 assert(m->hdr);
317 assert(!m->sealed);
318 assert(NLMSG_ALIGN(m->hdr->nlmsg_len) == m->hdr->nlmsg_len);
319 assert(!data || data_length > 0);
320 assert(data || m->n_containers < RTNL_CONTAINER_DEPTH);
321
322 /* get the size of the new rta attribute (with padding at the end) */
323 rta_length = RTA_LENGTH(data_length);
324
325 /* get the new message size (with padding at the end) */
326 message_length = m->hdr->nlmsg_len + RTA_ALIGN(rta_length);
327
328 /* realloc to fit the new attribute */
329 new_hdr = realloc(m->hdr, message_length);
330 if (!new_hdr)
331 return -ENOMEM;
332 m->hdr = new_hdr;
333
334 /* get pointer to the attribute we are about to add */
335 rta = (struct rtattr *) ((uint8_t *) m->hdr + m->hdr->nlmsg_len);
336
337 /* if we are inside containers, extend them */
338 for (i = 0; i < m->n_containers; i++)
339 GET_CONTAINER(m, i)->rta_len += message_length - m->hdr->nlmsg_len;
340
341 /* fill in the attribute */
342 rta->rta_type = type;
343 rta->rta_len = rta_length;
344 if (!data) {
345 /* this is the start of a new container */
346 m->container_offsets[m->n_containers ++] = m->hdr->nlmsg_len;
347 } else {
348 /* we don't deal with the case where the user lies about the type
349 * and gives us too little data (so don't do that)
350 */
351 padding = mempcpy(RTA_DATA(rta), data, data_length);
352 /* make sure also the padding at the end of the message is initialized */
353 memzero(padding,
354 (uint8_t *) m->hdr + message_length - (uint8_t *) padding);
355 }
356
357 /* update message size */
358 m->hdr->nlmsg_len = message_length;
359
360 return 0;
361 }
362
363 int sd_rtnl_message_append_string(sd_rtnl_message *m, unsigned short type, const char *data) {
364 uint16_t rtm_type;
365 int r;
366
367 assert_return(m, -EINVAL);
368 assert_return(!m->sealed, -EPERM);
369 assert_return(data, -EINVAL);
370
371 r = sd_rtnl_message_get_type(m, &rtm_type);
372 if (r < 0)
373 return r;
374
375 /* check that the type is correct */
376 switch (rtm_type) {
377 case RTM_NEWLINK:
378 case RTM_SETLINK:
379 case RTM_GETLINK:
380 case RTM_DELLINK:
381 if (m->n_containers == 1) {
382 if (GET_CONTAINER(m, 0)->rta_type != IFLA_LINKINFO ||
383 type != IFLA_INFO_KIND)
384 return -ENOTSUP;
385 } else {
386 switch (type) {
387 case IFLA_IFNAME:
388 case IFLA_IFALIAS:
389 case IFLA_QDISC:
390 break;
391 default:
392 return -ENOTSUP;
393 }
394 }
395 break;
396 case RTM_NEWADDR:
397 case RTM_GETADDR:
398 case RTM_DELADDR:
399 if (type != IFA_LABEL)
400 return -ENOTSUP;
401 break;
402 default:
403 return -ENOTSUP;
404 }
405
406 r = add_rtattr(m, type, data, strlen(data) + 1);
407 if (r < 0)
408 return r;
409
410 return 0;
411 }
412
413 int sd_rtnl_message_append_u8(sd_rtnl_message *m, unsigned short type, uint8_t data) {
414 uint16_t rtm_type;
415 int r;
416
417 assert_return(m, -EINVAL);
418 assert_return(!m->sealed, -EPERM);
419
420 r = sd_rtnl_message_get_type(m, &rtm_type);
421 if (r < 0)
422 return r;
423
424 switch (rtm_type) {
425 case RTM_NEWLINK:
426 case RTM_SETLINK:
427 case RTM_GETLINK:
428 case RTM_DELLINK:
429 switch (type) {
430 case IFLA_CARRIER:
431 case IFLA_OPERSTATE:
432 case IFLA_LINKMODE:
433 break;
434 default:
435 return -ENOTSUP;
436 }
437
438 break;
439 default:
440 return -ENOTSUP;
441 }
442
443 r = add_rtattr(m, type, &data, sizeof(uint8_t));
444 if (r < 0)
445 return r;
446
447 return 0;
448 }
449
450
451 int sd_rtnl_message_append_u16(sd_rtnl_message *m, unsigned short type, uint16_t data) {
452 uint16_t rtm_type;
453 int r;
454
455 assert_return(m, -EINVAL);
456 assert_return(!m->sealed, -EPERM);
457
458 r = sd_rtnl_message_get_type(m, &rtm_type);
459 if (r < 0)
460 return r;
461
462 /* check that the type is correct */
463 switch (rtm_type) {
464 case RTM_NEWLINK:
465 case RTM_SETLINK:
466 case RTM_GETLINK:
467 case RTM_DELLINK:
468 if (m->n_containers == 2 &&
469 GET_CONTAINER(m, 0)->rta_type == IFLA_LINKINFO &&
470 GET_CONTAINER(m, 1)->rta_type == IFLA_INFO_DATA &&
471 type == IFLA_VLAN_ID)
472 break;
473 else
474 return -ENOTSUP;
475 break;
476 default:
477 return -ENOTSUP;
478 }
479
480 r = add_rtattr(m, type, &data, sizeof(uint16_t));
481 if (r < 0)
482 return r;
483
484 return 0;
485 }
486
487 int sd_rtnl_message_append_u32(sd_rtnl_message *m, unsigned short type, uint32_t data) {
488 uint16_t rtm_type;
489 int r;
490
491 assert_return(m, -EINVAL);
492 assert_return(!m->sealed, -EPERM);
493
494 r = sd_rtnl_message_get_type(m, &rtm_type);
495 if (r < 0)
496 return r;
497
498 /* check that the type is correct */
499 switch (rtm_type) {
500 case RTM_NEWLINK:
501 case RTM_SETLINK:
502 case RTM_GETLINK:
503 case RTM_DELLINK:
504 switch (type) {
505 case IFLA_MASTER:
506 case IFLA_MTU:
507 case IFLA_LINK:
508 case IFLA_GROUP:
509 case IFLA_TXQLEN:
510 case IFLA_NUM_TX_QUEUES:
511 case IFLA_NUM_RX_QUEUES:
512 break;
513 default:
514 return -ENOTSUP;
515 }
516 break;
517 case RTM_NEWROUTE:
518 case RTM_GETROUTE:
519 case RTM_DELROUTE:
520 switch (type) {
521 case RTA_TABLE:
522 case RTA_PRIORITY:
523 case RTA_IIF:
524 case RTA_OIF:
525 break;
526 default:
527 return -ENOTSUP;
528 }
529 break;
530 default:
531 return -ENOTSUP;
532 }
533
534 r = add_rtattr(m, type, &data, sizeof(uint32_t));
535 if (r < 0)
536 return r;
537
538 return 0;
539 }
540
541 int sd_rtnl_message_append_in_addr(sd_rtnl_message *m, unsigned short type, const struct in_addr *data) {
542 struct ifaddrmsg *ifa;
543 struct rtmsg *rtm;
544 uint16_t rtm_type;
545 int r;
546
547 assert_return(m, -EINVAL);
548 assert_return(!m->sealed, -EPERM);
549 assert_return(data, -EINVAL);
550
551 r = sd_rtnl_message_get_type(m, &rtm_type);
552 if (r < 0)
553 return r;
554
555 /* check that the type is correct */
556 switch (rtm_type) {
557 case RTM_NEWADDR:
558 case RTM_GETADDR:
559 case RTM_DELADDR:
560 switch (type) {
561 case IFA_ADDRESS:
562 case IFA_LOCAL:
563 case IFA_BROADCAST:
564 case IFA_ANYCAST:
565 ifa = NLMSG_DATA(m->hdr);
566
567 if (ifa->ifa_family != AF_INET)
568 return -EINVAL;
569
570 break;
571 default:
572 return -ENOTSUP;
573 }
574 break;
575 case RTM_NEWROUTE:
576 case RTM_GETROUTE:
577 case RTM_DELROUTE:
578 switch (type) {
579 case RTA_DST:
580 case RTA_SRC:
581 case RTA_GATEWAY:
582 rtm = NLMSG_DATA(m->hdr);
583
584 if (rtm->rtm_family != AF_INET)
585 return -EINVAL;
586
587 break;
588 default:
589 return -ENOTSUP;
590 }
591 break;
592 default:
593 return -ENOTSUP;
594 }
595
596 r = add_rtattr(m, type, data, sizeof(struct in_addr));
597 if (r < 0)
598 return r;
599
600 return 0;
601 }
602
603 int sd_rtnl_message_append_in6_addr(sd_rtnl_message *m, unsigned short type, const struct in6_addr *data) {
604 struct ifaddrmsg *ifa;
605 struct rtmsg *rtm;
606 uint16_t rtm_type;
607 int r;
608
609 assert_return(m, -EINVAL);
610 assert_return(!m->sealed, -EPERM);
611 assert_return(data, -EINVAL);
612
613 r = sd_rtnl_message_get_type(m, &rtm_type);
614 if (r < 0)
615 return r;
616
617 /* check that the type is correct */
618 switch (rtm_type) {
619 case RTM_NEWADDR:
620 case RTM_GETADDR:
621 case RTM_DELADDR:
622 switch (type) {
623 case IFA_ADDRESS:
624 case IFA_LOCAL:
625 case IFA_BROADCAST:
626 case IFA_ANYCAST:
627 ifa = NLMSG_DATA(m->hdr);
628
629 if (ifa->ifa_family != AF_INET6)
630 return -EINVAL;
631
632 break;
633 default:
634 return -ENOTSUP;
635 }
636 break;
637 case RTM_NEWROUTE:
638 case RTM_GETROUTE:
639 case RTM_DELROUTE:
640 switch (type) {
641 case RTA_DST:
642 case RTA_SRC:
643 case RTA_GATEWAY:
644 rtm = NLMSG_DATA(m->hdr);
645
646 if (rtm->rtm_family != AF_INET6)
647 return -EINVAL;
648
649 break;
650 default:
651 return -ENOTSUP;
652 }
653 default:
654 return -ENOTSUP;
655 }
656
657 r = add_rtattr(m, type, data, sizeof(struct in6_addr));
658 if (r < 0)
659 return r;
660
661 return 0;
662 }
663
664 int sd_rtnl_message_append_ether_addr(sd_rtnl_message *m, unsigned short type, const struct ether_addr *data) {
665 uint16_t rtm_type;
666 int r;
667
668 assert_return(m, -EINVAL);
669 assert_return(!m->sealed, -EPERM);
670 assert_return(data, -EINVAL);
671
672 sd_rtnl_message_get_type(m, &rtm_type);
673
674 switch (rtm_type) {
675 case RTM_NEWLINK:
676 case RTM_SETLINK:
677 case RTM_DELLINK:
678 case RTM_GETLINK:
679 switch (type) {
680 case IFLA_ADDRESS:
681 case IFLA_BROADCAST:
682 break;
683 default:
684 return -ENOTSUP;
685 }
686 break;
687 default:
688 return -ENOTSUP;
689 }
690
691 r = add_rtattr(m, type, data, ETH_ALEN);
692 if (r < 0)
693 return r;
694
695 return 0;
696 }
697
698 int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type) {
699 uint16_t rtm_type;
700
701 assert_return(m, -EINVAL);
702 assert_return(!m->sealed, -EPERM);
703
704 sd_rtnl_message_get_type(m, &rtm_type);
705
706 if (rtnl_message_type_is_link(rtm_type)) {
707 if ((type == IFLA_LINKINFO && m->n_containers == 0) ||
708 (type == IFLA_INFO_DATA && m->n_containers == 1 &&
709 GET_CONTAINER(m, 0)->rta_type == IFLA_LINKINFO))
710 return add_rtattr(m, type, NULL, 0);
711 else
712 return -ENOTSUP;
713 } else
714 return -ENOTSUP;
715
716 return 0;
717 }
718
719 int sd_rtnl_message_close_container(sd_rtnl_message *m) {
720 assert_return(m, -EINVAL);
721 assert_return(!m->sealed, -EPERM);
722 assert_return(m->n_containers > 0, -EINVAL);
723
724 m->n_containers --;
725
726 return 0;
727 }
728
729 int sd_rtnl_message_read(sd_rtnl_message *m, unsigned short *type, void **data) {
730 size_t remaining_size;
731 uint16_t rtm_type;
732 int r;
733
734 assert_return(m, -EINVAL);
735 assert_return(m->sealed, -EPERM);
736 assert_return(m->next_rta_offset, -EINVAL);
737 assert_return(type, -EINVAL);
738 assert_return(data, -EINVAL);
739
740 /* only read until the end of the current container */
741 if (m->n_containers)
742 remaining_size = GET_CONTAINER(m, m->n_containers - 1)->rta_len -
743 (m->next_rta_offset -
744 m->container_offsets[m->n_containers - 1]);
745 else
746 remaining_size = m->hdr->nlmsg_len - m->next_rta_offset;
747
748 if (!RTA_OK(NEXT_RTA(m), remaining_size))
749 return 0;
750
751 /* if we read a container, enter it and return its type */
752 r = sd_rtnl_message_get_type(m, &rtm_type);
753 if (r < 0)
754 return r;
755
756 *type = NEXT_RTA(m)->rta_type;
757
758 if (rtnl_message_type_is_link(rtm_type) &&
759 ((m->n_containers == 0 &&
760 NEXT_RTA(m)->rta_type == IFLA_LINKINFO) ||
761 (m->n_containers == 1 &&
762 GET_CONTAINER(m, 0)->rta_type == IFLA_LINKINFO &&
763 NEXT_RTA(m)->rta_type == IFLA_INFO_DATA))) {
764 *data = NULL;
765 PUSH_CONTAINER(m, NEXT_RTA(m));
766 UPDATE_RTA(m, RTA_DATA(NEXT_RTA(m)));
767 } else {
768 *data = RTA_DATA(NEXT_RTA(m));
769 UPDATE_RTA(m, RTA_NEXT(NEXT_RTA(m), remaining_size));
770 }
771
772 return 1;
773 }
774
775 int sd_rtnl_message_exit_container(sd_rtnl_message *m) {
776 assert_return(m, -EINVAL);
777 assert_return(m->sealed, -EINVAL);
778 assert_return(m->n_containers > 0, -EINVAL);
779
780 m->n_containers --;
781
782 return 0;
783 }
784
785 uint32_t rtnl_message_get_serial(sd_rtnl_message *m) {
786 assert(m);
787 assert(m->hdr);
788
789 return m->hdr->nlmsg_seq;
790 }
791
792 int sd_rtnl_message_get_errno(sd_rtnl_message *m) {
793 struct nlmsgerr *err;
794
795 assert_return(m, -EINVAL);
796 assert_return(m->hdr, -EINVAL);
797
798 if (m->hdr->nlmsg_type != NLMSG_ERROR)
799 return 0;
800
801 err = NLMSG_DATA(m->hdr);
802
803 return err->error;
804 }
805
806 int rtnl_message_seal(sd_rtnl *nl, sd_rtnl_message *m) {
807 int r;
808
809 assert(m);
810 assert(m->hdr);
811
812 if (m->sealed)
813 return -EPERM;
814
815 if (nl)
816 m->hdr->nlmsg_seq = nl->serial++;
817
818 m->sealed = true;
819
820 r = sd_rtnl_message_rewind(m);
821 if (r < 0)
822 return r;
823
824 return 0;
825 }
826
827 static int message_receive_need(sd_rtnl *rtnl, size_t *need) {
828 assert(rtnl);
829 assert(need);
830
831 /* ioctl(rtnl->fd, FIONREAD, &need)
832 Does not appear to work on netlink sockets. libnl uses
833 MSG_PEEK instead. I don't know if that is worth the
834 extra roundtrip.
835
836 For now we simply use the maximum message size the kernel
837 may use (NLMSG_GOODSIZE), and then realloc to the actual
838 size after reading the message (hence avoiding huge memory
839 usage in case many small messages are kept around) */
840 *need = page_size();
841 if (*need > 8192UL)
842 *need = 8192UL;
843
844 return 0;
845 }
846
847 /* returns the number of bytes sent, or a negative error code */
848 int socket_write_message(sd_rtnl *nl, sd_rtnl_message *m) {
849 union {
850 struct sockaddr sa;
851 struct sockaddr_nl nl;
852 } addr = {
853 .nl.nl_family = AF_NETLINK,
854 };
855 ssize_t k;
856
857 assert(nl);
858 assert(m);
859 assert(m->hdr);
860
861 k = sendto(nl->fd, m->hdr, m->hdr->nlmsg_len,
862 0, &addr.sa, sizeof(addr));
863 if (k < 0)
864 return (errno == EAGAIN) ? 0 : -errno;
865
866 return k;
867 }
868
869 /* On success, the number of bytes received is returned and *ret points to the received message
870 * which has a valid header and the correct size.
871 * If nothing useful was received 0 is returned.
872 * On failure, a negative error code is returned.
873 */
874 int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) {
875 sd_rtnl_message *m;
876 union {
877 struct sockaddr sa;
878 struct sockaddr_nl nl;
879 } addr;
880 socklen_t addr_len;
881 int r;
882 ssize_t k;
883 size_t need;
884
885 assert(nl);
886 assert(ret);
887
888 r = message_receive_need(nl, &need);
889 if (r < 0)
890 return r;
891
892 r = message_new(&m, need);
893 if (r < 0)
894 return r;
895
896 /* don't allow sealing/appending to received messages */
897 m->sealed = true;
898
899 addr_len = sizeof(addr);
900
901 k = recvfrom(nl->fd, m->hdr, need,
902 0, &addr.sa, &addr_len);
903 if (k < 0)
904 k = (errno == EAGAIN) ? 0 : -errno; /* no data */
905 else if (k == 0)
906 k = -ECONNRESET; /* connection was closed by the kernel */
907 else if (addr_len != sizeof(addr.nl) ||
908 addr.nl.nl_family != AF_NETLINK)
909 k = -EIO; /* not a netlink message */
910 else if (addr.nl.nl_pid != 0)
911 k = 0; /* not from the kernel */
912 else if ((size_t) k < sizeof(struct nlmsghdr) ||
913 (size_t) k < m->hdr->nlmsg_len)
914 k = -EIO; /* too small (we do accept too big though) */
915 else if (m->hdr->nlmsg_pid && m->hdr->nlmsg_pid != nl->sockaddr.nl.nl_pid)
916 k = 0; /* not broadcast and not for us */
917
918 if (k > 0)
919 switch (m->hdr->nlmsg_type) {
920 struct ifinfomsg *ifi;
921 struct ifaddrmsg *ifa;
922 struct rtmsg *rtm;
923
924 /* check that the size matches the message type */
925 case NLMSG_ERROR:
926 if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
927 k = -EIO;
928 break;
929 case RTM_NEWLINK:
930 case RTM_SETLINK:
931 case RTM_DELLINK:
932 case RTM_GETLINK:
933 if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifinfomsg)))
934 k = -EIO;
935 else {
936 ifi = NLMSG_DATA(m->hdr);
937 UPDATE_RTA(m, IFLA_RTA(ifi));
938 }
939 break;
940 case RTM_NEWADDR:
941 case RTM_DELADDR:
942 case RTM_GETADDR:
943 if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifaddrmsg)))
944 k = -EIO;
945 else {
946 ifa = NLMSG_DATA(m->hdr);
947 UPDATE_RTA(m, IFA_RTA(ifa));
948 }
949 break;
950 case RTM_NEWROUTE:
951 case RTM_DELROUTE:
952 case RTM_GETROUTE:
953 if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtmsg)))
954 k = -EIO;
955 else {
956 rtm = NLMSG_DATA(m->hdr);
957 UPDATE_RTA(m, RTM_RTA(rtm));
958 }
959 break;
960 case NLMSG_NOOP:
961 k = 0;
962 break;
963 default:
964 k = 0; /* ignoring message of unknown type */
965 }
966
967 if (k <= 0)
968 sd_rtnl_message_unref(m);
969 else {
970 /* we probably allocated way too much memory, give it back */
971 m->hdr = realloc(m->hdr, m->hdr->nlmsg_len);
972 *ret = m;
973 }
974
975 return k;
976 }
977
978 int sd_rtnl_message_rewind(sd_rtnl_message *m) {
979 struct ifinfomsg *ifi;
980 struct ifaddrmsg *ifa;
981 struct rtmsg *rtm;
982
983 assert_return(m, -EINVAL);
984 assert_return(m->sealed, -EPERM);
985 assert_return(m->hdr, -EINVAL);
986
987 switch(m->hdr->nlmsg_type) {
988 case RTM_NEWLINK:
989 case RTM_SETLINK:
990 case RTM_GETLINK:
991 case RTM_DELLINK:
992 ifi = NLMSG_DATA(m->hdr);
993 UPDATE_RTA(m, IFLA_RTA(ifi));
994
995 break;
996 case RTM_NEWADDR:
997 case RTM_GETADDR:
998 case RTM_DELADDR:
999 ifa = NLMSG_DATA(m->hdr);
1000 UPDATE_RTA(m, IFA_RTA(ifa));
1001
1002 break;
1003 case RTM_NEWROUTE:
1004 case RTM_GETROUTE:
1005 case RTM_DELROUTE:
1006 rtm = NLMSG_DATA(m->hdr);
1007 UPDATE_RTA(m, RTM_RTA(rtm));
1008
1009 break;
1010 default:
1011 return -ENOTSUP;
1012 }
1013
1014 m->n_containers = 0;
1015
1016 return 0;
1017 }
Unnamed repository; edit this file 'description' to name the repository.