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