]> git.proxmox.com Git - mirror_iproute2.git/blob - ip/iproute.c
projects / mirror_iproute2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
iplink: display number of rx/tx queues
[mirror_iproute2.git] / ip / iproute.c
1 /*
2 * iproute.c "ip route".
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 *
11 */
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <unistd.h>
16 #include <syslog.h>
17 #include <fcntl.h>
18 #include <string.h>
19 #include <time.h>
20 #include <sys/time.h>
21 #include <sys/socket.h>
22 #include <netinet/in.h>
23 #include <netinet/ip.h>
24 #include <arpa/inet.h>
25 #include <linux/in_route.h>
26 #include <linux/icmpv6.h>
27 #include <errno.h>
28
29 #include "rt_names.h"
30 #include "utils.h"
31 #include "ip_common.h"
32 #include "iproute_lwtunnel.h"
33
34 #ifndef RTAX_RTTVAR
35 #define RTAX_RTTVAR RTAX_HOPS
36 #endif
37
38 enum list_action {
39 IPROUTE_LIST,
40 IPROUTE_FLUSH,
41 IPROUTE_SAVE,
42 };
43 static const char *mx_names[RTAX_MAX+1] = {
44 [RTAX_MTU] = "mtu",
45 [RTAX_WINDOW] = "window",
46 [RTAX_RTT] = "rtt",
47 [RTAX_RTTVAR] = "rttvar",
48 [RTAX_SSTHRESH] = "ssthresh",
49 [RTAX_CWND] = "cwnd",
50 [RTAX_ADVMSS] = "advmss",
51 [RTAX_REORDERING] = "reordering",
52 [RTAX_HOPLIMIT] = "hoplimit",
53 [RTAX_INITCWND] = "initcwnd",
54 [RTAX_FEATURES] = "features",
55 [RTAX_RTO_MIN] = "rto_min",
56 [RTAX_INITRWND] = "initrwnd",
57 [RTAX_QUICKACK] = "quickack",
58 [RTAX_CC_ALGO] = "congctl",
59 };
60 static void usage(void) __attribute__((noreturn));
61
62 static void usage(void)
63 {
64 fprintf(stderr, "Usage: ip route { list | flush } SELECTOR\n");
65 fprintf(stderr, " ip route save SELECTOR\n");
66 fprintf(stderr, " ip route restore\n");
67 fprintf(stderr, " ip route showdump\n");
68 fprintf(stderr, " ip route get ADDRESS [ from ADDRESS iif STRING ]\n");
69 fprintf(stderr, " [ oif STRING ] [ tos TOS ]\n");
70 fprintf(stderr, " [ mark NUMBER ]\n");
71 fprintf(stderr, " ip route { add | del | change | append | replace } ROUTE\n");
72 fprintf(stderr, "SELECTOR := [ root PREFIX ] [ match PREFIX ] [ exact PREFIX ]\n");
73 fprintf(stderr, " [ table TABLE_ID ] [ proto RTPROTO ]\n");
74 fprintf(stderr, " [ type TYPE ] [ scope SCOPE ]\n");
75 fprintf(stderr, "ROUTE := NODE_SPEC [ INFO_SPEC ]\n");
76 fprintf(stderr, "NODE_SPEC := [ TYPE ] PREFIX [ tos TOS ]\n");
77 fprintf(stderr, " [ table TABLE_ID ] [ proto RTPROTO ]\n");
78 fprintf(stderr, " [ scope SCOPE ] [ metric METRIC ]\n");
79 fprintf(stderr, "INFO_SPEC := NH OPTIONS FLAGS [ nexthop NH ]...\n");
80 fprintf(stderr, "NH := [ encap ENCAPTYPE ENCAPHDR ] [ via [ FAMILY ] ADDRESS ]\n");
81 fprintf(stderr, " [ dev STRING ] [ weight NUMBER ] NHFLAGS\n");
82 fprintf(stderr, "FAMILY := [ inet | inet6 | ipx | dnet | mpls | bridge | link ]\n");
83 fprintf(stderr, "OPTIONS := FLAGS [ mtu NUMBER ] [ advmss NUMBER ] [ as [ to ] ADDRESS ]\n");
84 fprintf(stderr, " [ rtt TIME ] [ rttvar TIME ] [ reordering NUMBER ]\n");
85 fprintf(stderr, " [ window NUMBER ] [ cwnd NUMBER ] [ initcwnd NUMBER ]\n");
86 fprintf(stderr, " [ ssthresh NUMBER ] [ realms REALM ] [ src ADDRESS ]\n");
87 fprintf(stderr, " [ rto_min TIME ] [ hoplimit NUMBER ] [ initrwnd NUMBER ]\n");
88 fprintf(stderr, " [ features FEATURES ] [ quickack BOOL ] [ congctl NAME ]\n");
89 fprintf(stderr, " [ pref PREF ] [ expires TIME ]\n");
90 fprintf(stderr, "TYPE := { unicast | local | broadcast | multicast | throw |\n");
91 fprintf(stderr, " unreachable | prohibit | blackhole | nat }\n");
92 fprintf(stderr, "TABLE_ID := [ local | main | default | all | NUMBER ]\n");
93 fprintf(stderr, "SCOPE := [ host | link | global | NUMBER ]\n");
94 fprintf(stderr, "NHFLAGS := [ onlink | pervasive ]\n");
95 fprintf(stderr, "RTPROTO := [ kernel | boot | static | NUMBER ]\n");
96 fprintf(stderr, "PREF := [ low | medium | high ]\n");
97 fprintf(stderr, "TIME := NUMBER[s|ms]\n");
98 fprintf(stderr, "BOOL := [1|0]\n");
99 fprintf(stderr, "FEATURES := ecn\n");
100 fprintf(stderr, "ENCAPTYPE := [ mpls | ip | ip6 ]\n");
101 fprintf(stderr, "ENCAPHDR := [ MPLSLABEL ]\n");
102 exit(-1);
103 }
104
105
106 static struct
107 {
108 unsigned int tb;
109 int cloned;
110 int flushed;
111 char *flushb;
112 int flushp;
113 int flushe;
114 int protocol, protocolmask;
115 int scope, scopemask;
116 int type, typemask;
117 int tos, tosmask;
118 int iif, iifmask;
119 int oif, oifmask;
120 int mark, markmask;
121 int realm, realmmask;
122 inet_prefix rprefsrc;
123 inet_prefix rvia;
124 inet_prefix rdst;
125 inet_prefix mdst;
126 inet_prefix rsrc;
127 inet_prefix msrc;
128 } filter;
129
130 static int flush_update(void)
131 {
132 if (rtnl_send_check(&rth, filter.flushb, filter.flushp) < 0) {
133 perror("Failed to send flush request");
134 return -1;
135 }
136 filter.flushp = 0;
137 return 0;
138 }
139
140 static int filter_nlmsg(struct nlmsghdr *n, struct rtattr **tb, int host_len)
141 {
142 struct rtmsg *r = NLMSG_DATA(n);
143 inet_prefix dst;
144 inet_prefix src;
145 inet_prefix via;
146 inet_prefix prefsrc;
147 __u32 table;
148 static int ip6_multiple_tables;
149
150 table = rtm_get_table(r, tb);
151
152 if (preferred_family != AF_UNSPEC && r->rtm_family != preferred_family)
153 return 0;
154
155 if (r->rtm_family == AF_INET6 && table != RT_TABLE_MAIN)
156 ip6_multiple_tables = 1;
157
158 if (filter.cloned == !(r->rtm_flags&RTM_F_CLONED))
159 return 0;
160
161 if (r->rtm_family == AF_INET6 && !ip6_multiple_tables) {
162 if (filter.tb) {
163 if (filter.tb == RT_TABLE_LOCAL) {
164 if (r->rtm_type != RTN_LOCAL)
165 return 0;
166 } else if (filter.tb == RT_TABLE_MAIN) {
167 if (r->rtm_type == RTN_LOCAL)
168 return 0;
169 } else {
170 return 0;
171 }
172 }
173 } else {
174 if (filter.tb > 0 && filter.tb != table)
175 return 0;
176 }
177 if ((filter.protocol^r->rtm_protocol)&filter.protocolmask)
178 return 0;
179 if ((filter.scope^r->rtm_scope)&filter.scopemask)
180 return 0;
181 if ((filter.type^r->rtm_type)&filter.typemask)
182 return 0;
183 if ((filter.tos^r->rtm_tos)&filter.tosmask)
184 return 0;
185 if (filter.rdst.family &&
186 (r->rtm_family != filter.rdst.family || filter.rdst.bitlen > r->rtm_dst_len))
187 return 0;
188 if (filter.mdst.family &&
189 (r->rtm_family != filter.mdst.family ||
190 (filter.mdst.bitlen >= 0 && filter.mdst.bitlen < r->rtm_dst_len)))
191 return 0;
192 if (filter.rsrc.family &&
193 (r->rtm_family != filter.rsrc.family || filter.rsrc.bitlen > r->rtm_src_len))
194 return 0;
195 if (filter.msrc.family &&
196 (r->rtm_family != filter.msrc.family ||
197 (filter.msrc.bitlen >= 0 && filter.msrc.bitlen < r->rtm_src_len)))
198 return 0;
199 if (filter.rvia.family) {
200 int family = r->rtm_family;
201
202 if (tb[RTA_VIA]) {
203 struct rtvia *via = RTA_DATA(tb[RTA_VIA]);
204
205 family = via->rtvia_family;
206 }
207 if (family != filter.rvia.family)
208 return 0;
209 }
210 if (filter.rprefsrc.family && r->rtm_family != filter.rprefsrc.family)
211 return 0;
212
213 memset(&dst, 0, sizeof(dst));
214 dst.family = r->rtm_family;
215 if (tb[RTA_DST])
216 memcpy(&dst.data, RTA_DATA(tb[RTA_DST]), (r->rtm_dst_len+7)/8);
217 if (filter.rsrc.family || filter.msrc.family) {
218 memset(&src, 0, sizeof(src));
219 src.family = r->rtm_family;
220 if (tb[RTA_SRC])
221 memcpy(&src.data, RTA_DATA(tb[RTA_SRC]), (r->rtm_src_len+7)/8);
222 }
223 if (filter.rvia.bitlen > 0) {
224 memset(&via, 0, sizeof(via));
225 via.family = r->rtm_family;
226 if (tb[RTA_GATEWAY])
227 memcpy(&via.data, RTA_DATA(tb[RTA_GATEWAY]), host_len/8);
228 if (tb[RTA_VIA]) {
229 size_t len = RTA_PAYLOAD(tb[RTA_VIA]) - 2;
230 struct rtvia *rtvia = RTA_DATA(tb[RTA_VIA]);
231
232 via.family = rtvia->rtvia_family;
233 memcpy(&via.data, rtvia->rtvia_addr, len);
234 }
235 }
236 if (filter.rprefsrc.bitlen > 0) {
237 memset(&prefsrc, 0, sizeof(prefsrc));
238 prefsrc.family = r->rtm_family;
239 if (tb[RTA_PREFSRC])
240 memcpy(&prefsrc.data, RTA_DATA(tb[RTA_PREFSRC]), host_len/8);
241 }
242
243 if (filter.rdst.family && inet_addr_match(&dst, &filter.rdst, filter.rdst.bitlen))
244 return 0;
245 if (filter.mdst.family && filter.mdst.bitlen >= 0 &&
246 inet_addr_match(&dst, &filter.mdst, r->rtm_dst_len))
247 return 0;
248
249 if (filter.rsrc.family && inet_addr_match(&src, &filter.rsrc, filter.rsrc.bitlen))
250 return 0;
251 if (filter.msrc.family && filter.msrc.bitlen >= 0 &&
252 inet_addr_match(&src, &filter.msrc, r->rtm_src_len))
253 return 0;
254
255 if (filter.rvia.family && inet_addr_match(&via, &filter.rvia, filter.rvia.bitlen))
256 return 0;
257 if (filter.rprefsrc.family && inet_addr_match(&prefsrc, &filter.rprefsrc, filter.rprefsrc.bitlen))
258 return 0;
259 if (filter.realmmask) {
260 __u32 realms = 0;
261
262 if (tb[RTA_FLOW])
263 realms = rta_getattr_u32(tb[RTA_FLOW]);
264 if ((realms^filter.realm)&filter.realmmask)
265 return 0;
266 }
267 if (filter.iifmask) {
268 int iif = 0;
269
270 if (tb[RTA_IIF])
271 iif = *(int *)RTA_DATA(tb[RTA_IIF]);
272 if ((iif^filter.iif)&filter.iifmask)
273 return 0;
274 }
275 if (filter.oifmask) {
276 int oif = 0;
277
278 if (tb[RTA_OIF])
279 oif = *(int *)RTA_DATA(tb[RTA_OIF]);
280 if ((oif^filter.oif)&filter.oifmask)
281 return 0;
282 }
283 if (filter.markmask) {
284 int mark = 0;
285
286 if (tb[RTA_MARK])
287 mark = *(int *)RTA_DATA(tb[RTA_MARK]);
288 if ((mark ^ filter.mark) & filter.markmask)
289 return 0;
290 }
291 if (filter.flushb &&
292 r->rtm_family == AF_INET6 &&
293 r->rtm_dst_len == 0 &&
294 r->rtm_type == RTN_UNREACHABLE &&
295 tb[RTA_PRIORITY] &&
296 *(int *)RTA_DATA(tb[RTA_PRIORITY]) == -1)
297 return 0;
298
299 return 1;
300 }
301
302 static void print_rtax_features(FILE *fp, unsigned int features)
303 {
304 unsigned int of = features;
305
306 if (features & RTAX_FEATURE_ECN) {
307 fprintf(fp, " ecn");
308 features &= ~RTAX_FEATURE_ECN;
309 }
310
311 if (features)
312 fprintf(fp, " 0x%x", of);
313 }
314
315 int print_route(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
316 {
317 FILE *fp = (FILE *)arg;
318 struct rtmsg *r = NLMSG_DATA(n);
319 int len = n->nlmsg_len;
320 struct rtattr *tb[RTA_MAX+1];
321 int host_len;
322 __u32 table;
323
324 SPRINT_BUF(b1);
325 static int hz;
326
327 if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
328 fprintf(stderr, "Not a route: %08x %08x %08x\n",
329 n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
330 return 0;
331 }
332 if (filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
333 return 0;
334 len -= NLMSG_LENGTH(sizeof(*r));
335 if (len < 0) {
336 fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
337 return -1;
338 }
339
340 host_len = af_bit_len(r->rtm_family);
341
342 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
343 table = rtm_get_table(r, tb);
344
345 if (!filter_nlmsg(n, tb, host_len))
346 return 0;
347
348 if (filter.flushb) {
349 struct nlmsghdr *fn;
350
351 if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
352 if (flush_update())
353 return -1;
354 }
355 fn = (struct nlmsghdr *)(filter.flushb + NLMSG_ALIGN(filter.flushp));
356 memcpy(fn, n, n->nlmsg_len);
357 fn->nlmsg_type = RTM_DELROUTE;
358 fn->nlmsg_flags = NLM_F_REQUEST;
359 fn->nlmsg_seq = ++rth.seq;
360 filter.flushp = (((char *)fn) + n->nlmsg_len) - filter.flushb;
361 filter.flushed++;
362 if (show_stats < 2)
363 return 0;
364 }
365
366 if (n->nlmsg_type == RTM_DELROUTE)
367 fprintf(fp, "Deleted ");
368 if ((r->rtm_type != RTN_UNICAST || show_details > 0) && !filter.type)
369 fprintf(fp, "%s ", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));
370
371 if (tb[RTA_DST]) {
372 if (r->rtm_dst_len != host_len) {
373 fprintf(fp, "%s/%u ",
374 rt_addr_n2a_rta(r->rtm_family, tb[RTA_DST]),
375 r->rtm_dst_len);
376 } else {
377 fprintf(fp, "%s ",
378 format_host_rta(r->rtm_family, tb[RTA_DST]));
379 }
380 } else if (r->rtm_dst_len) {
381 fprintf(fp, "0/%d ", r->rtm_dst_len);
382 } else {
383 fprintf(fp, "default ");
384 }
385 if (tb[RTA_SRC]) {
386 if (r->rtm_src_len != host_len) {
387 fprintf(fp, "from %s/%u ",
388 rt_addr_n2a_rta(r->rtm_family, tb[RTA_SRC]),
389 r->rtm_src_len);
390 } else {
391 fprintf(fp, "from %s ",
392 format_host_rta(r->rtm_family, tb[RTA_SRC]));
393 }
394 } else if (r->rtm_src_len) {
395 fprintf(fp, "from 0/%u ", r->rtm_src_len);
396 }
397 if (tb[RTA_NEWDST]) {
398 fprintf(fp, "as to %s ",
399 format_host_rta(r->rtm_family, tb[RTA_NEWDST]));
400 }
401
402 if (tb[RTA_ENCAP])
403 lwt_print_encap(fp, tb[RTA_ENCAP_TYPE], tb[RTA_ENCAP]);
404
405 if (r->rtm_tos && filter.tosmask != -1) {
406 SPRINT_BUF(b1);
407 fprintf(fp, "tos %s ", rtnl_dsfield_n2a(r->rtm_tos, b1, sizeof(b1)));
408 }
409
410 if (tb[RTA_GATEWAY] && filter.rvia.bitlen != host_len) {
411 fprintf(fp, "via %s ",
412 format_host_rta(r->rtm_family, tb[RTA_GATEWAY]));
413 }
414 if (tb[RTA_VIA]) {
415 size_t len = RTA_PAYLOAD(tb[RTA_VIA]) - 2;
416 struct rtvia *via = RTA_DATA(tb[RTA_VIA]);
417
418 fprintf(fp, "via %s %s ",
419 family_name(via->rtvia_family),
420 format_host(via->rtvia_family, len, via->rtvia_addr));
421 }
422 if (tb[RTA_OIF] && filter.oifmask != -1)
423 fprintf(fp, "dev %s ", ll_index_to_name(*(int *)RTA_DATA(tb[RTA_OIF])));
424
425 if (table && (table != RT_TABLE_MAIN || show_details > 0) && !filter.tb)
426 fprintf(fp, " table %s ", rtnl_rttable_n2a(table, b1, sizeof(b1)));
427 if (!(r->rtm_flags&RTM_F_CLONED)) {
428 if ((r->rtm_protocol != RTPROT_BOOT || show_details > 0) && filter.protocolmask != -1)
429 fprintf(fp, " proto %s ", rtnl_rtprot_n2a(r->rtm_protocol, b1, sizeof(b1)));
430 if ((r->rtm_scope != RT_SCOPE_UNIVERSE || show_details > 0) && filter.scopemask != -1)
431 fprintf(fp, " scope %s ", rtnl_rtscope_n2a(r->rtm_scope, b1, sizeof(b1)));
432 }
433 if (tb[RTA_PREFSRC] && filter.rprefsrc.bitlen != host_len) {
434 /* Do not use format_host(). It is our local addr
435 and symbolic name will not be useful.
436 */
437 fprintf(fp, " src %s ",
438 rt_addr_n2a_rta(r->rtm_family, tb[RTA_PREFSRC]));
439 }
440 if (tb[RTA_PRIORITY])
441 fprintf(fp, " metric %u ", rta_getattr_u32(tb[RTA_PRIORITY]));
442 if (r->rtm_flags & RTNH_F_DEAD)
443 fprintf(fp, "dead ");
444 if (r->rtm_flags & RTNH_F_ONLINK)
445 fprintf(fp, "onlink ");
446 if (r->rtm_flags & RTNH_F_PERVASIVE)
447 fprintf(fp, "pervasive ");
448 if (r->rtm_flags & RTNH_F_OFFLOAD)
449 fprintf(fp, "offload ");
450 if (r->rtm_flags & RTM_F_NOTIFY)
451 fprintf(fp, "notify ");
452 if (r->rtm_flags & RTNH_F_LINKDOWN)
453 fprintf(fp, "linkdown ");
454 if (tb[RTA_MARK]) {
455 unsigned int mark = *(unsigned int *)RTA_DATA(tb[RTA_MARK]);
456
457 if (mark) {
458 if (mark >= 16)
459 fprintf(fp, " mark 0x%x", mark);
460 else
461 fprintf(fp, " mark %u", mark);
462 }
463 }
464
465 if (tb[RTA_FLOW] && filter.realmmask != ~0U) {
466 __u32 to = rta_getattr_u32(tb[RTA_FLOW]);
467 __u32 from = to>>16;
468
469 to &= 0xFFFF;
470 fprintf(fp, "realm%s ", from ? "s" : "");
471 if (from) {
472 fprintf(fp, "%s/",
473 rtnl_rtrealm_n2a(from, b1, sizeof(b1)));
474 }
475 fprintf(fp, "%s ",
476 rtnl_rtrealm_n2a(to, b1, sizeof(b1)));
477 }
478 if ((r->rtm_flags&RTM_F_CLONED) && r->rtm_family == AF_INET) {
479 __u32 flags = r->rtm_flags&~0xFFFF;
480 int first = 1;
481
482 fprintf(fp, "%s cache ", _SL_);
483
484 #define PRTFL(fl, flname) if (flags&RTCF_##fl) { \
485 flags &= ~RTCF_##fl; \
486 fprintf(fp, "%s" flname "%s", first ? "<" : "", flags ? "," : "> "); \
487 first = 0; }
488 PRTFL(LOCAL, "local");
489 PRTFL(REJECT, "reject");
490 PRTFL(MULTICAST, "mc");
491 PRTFL(BROADCAST, "brd");
492 PRTFL(DNAT, "dst-nat");
493 PRTFL(SNAT, "src-nat");
494 PRTFL(MASQ, "masq");
495 PRTFL(DIRECTDST, "dst-direct");
496 PRTFL(DIRECTSRC, "src-direct");
497 PRTFL(REDIRECTED, "redirected");
498 PRTFL(DOREDIRECT, "redirect");
499 PRTFL(FAST, "fastroute");
500 PRTFL(NOTIFY, "notify");
501 PRTFL(TPROXY, "proxy");
502
503 if (flags)
504 fprintf(fp, "%s%x> ", first ? "<" : "", flags);
505 if (tb[RTA_CACHEINFO]) {
506 struct rta_cacheinfo *ci = RTA_DATA(tb[RTA_CACHEINFO]);
507
508 if (!hz)
509 hz = get_user_hz();
510 if (ci->rta_expires != 0)
511 fprintf(fp, " expires %dsec", ci->rta_expires/hz);
512 if (ci->rta_error != 0)
513 fprintf(fp, " error %d", ci->rta_error);
514 if (show_stats) {
515 if (ci->rta_clntref)
516 fprintf(fp, " users %d", ci->rta_clntref);
517 if (ci->rta_used != 0)
518 fprintf(fp, " used %d", ci->rta_used);
519 if (ci->rta_lastuse != 0)
520 fprintf(fp, " age %dsec", ci->rta_lastuse/hz);
521 }
522 if (ci->rta_id)
523 fprintf(fp, " ipid 0x%04x", ci->rta_id);
524 if (ci->rta_ts || ci->rta_tsage)
525 fprintf(fp, " ts 0x%x tsage %dsec",
526 ci->rta_ts, ci->rta_tsage);
527 }
528 } else if (r->rtm_family == AF_INET6) {
529 struct rta_cacheinfo *ci = NULL;
530
531 if (tb[RTA_CACHEINFO])
532 ci = RTA_DATA(tb[RTA_CACHEINFO]);
533 if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
534 if (!hz)
535 hz = get_user_hz();
536 if (r->rtm_flags & RTM_F_CLONED)
537 fprintf(fp, "%s cache ", _SL_);
538 if (ci->rta_expires)
539 fprintf(fp, " expires %dsec", ci->rta_expires/hz);
540 if (ci->rta_error != 0)
541 fprintf(fp, " error %d", ci->rta_error);
542 if (show_stats) {
543 if (ci->rta_clntref)
544 fprintf(fp, " users %d", ci->rta_clntref);
545 if (ci->rta_used != 0)
546 fprintf(fp, " used %d", ci->rta_used);
547 if (ci->rta_lastuse != 0)
548 fprintf(fp, " age %dsec", ci->rta_lastuse/hz);
549 }
550 } else if (ci) {
551 if (ci->rta_error != 0)
552 fprintf(fp, " error %d", ci->rta_error);
553 }
554 }
555 if (tb[RTA_METRICS]) {
556 int i;
557 unsigned int mxlock = 0;
558 struct rtattr *mxrta[RTAX_MAX+1];
559
560 parse_rtattr(mxrta, RTAX_MAX, RTA_DATA(tb[RTA_METRICS]),
561 RTA_PAYLOAD(tb[RTA_METRICS]));
562 if (mxrta[RTAX_LOCK])
563 mxlock = *(unsigned *)RTA_DATA(mxrta[RTAX_LOCK]);
564
565 for (i = 2; i <= RTAX_MAX; i++) {
566 __u32 val = 0U;
567
568 if (mxrta[i] == NULL)
569 continue;
570
571 if (i != RTAX_CC_ALGO)
572 val = rta_getattr_u32(mxrta[i]);
573
574 if (i == RTAX_HOPLIMIT && (int)val == -1)
575 continue;
576
577 if (i < sizeof(mx_names)/sizeof(char *) && mx_names[i])
578 fprintf(fp, " %s", mx_names[i]);
579 else
580 fprintf(fp, " metric %d", i);
581
582 if (mxlock & (1<<i))
583 fprintf(fp, " lock");
584
585 switch (i) {
586 case RTAX_FEATURES:
587 print_rtax_features(fp, val);
588 break;
589 default:
590 fprintf(fp, " %u", val);
591 break;
592
593 case RTAX_RTT:
594 case RTAX_RTTVAR:
595 case RTAX_RTO_MIN:
596 if (i == RTAX_RTT)
597 val /= 8;
598 else if (i == RTAX_RTTVAR)
599 val /= 4;
600
601 if (val >= 1000)
602 fprintf(fp, " %gs", val/1e3);
603 else
604 fprintf(fp, " %ums", val);
605 break;
606 case RTAX_CC_ALGO:
607 fprintf(fp, " %s", rta_getattr_str(mxrta[i]));
608 break;
609 }
610 }
611 }
612 if (tb[RTA_IIF] && filter.iifmask != -1) {
613 fprintf(fp, " iif %s", ll_index_to_name(*(int *)RTA_DATA(tb[RTA_IIF])));
614 }
615 if (tb[RTA_MULTIPATH]) {
616 struct rtnexthop *nh = RTA_DATA(tb[RTA_MULTIPATH]);
617 int first = 0;
618
619 len = RTA_PAYLOAD(tb[RTA_MULTIPATH]);
620
621 for (;;) {
622 if (len < sizeof(*nh))
623 break;
624 if (nh->rtnh_len > len)
625 break;
626 if (r->rtm_flags&RTM_F_CLONED && r->rtm_type == RTN_MULTICAST) {
627 if (first)
628 fprintf(fp, " Oifs:");
629 else
630 fprintf(fp, " ");
631 } else
632 fprintf(fp, "%s\tnexthop", _SL_);
633 if (nh->rtnh_len > sizeof(*nh)) {
634 parse_rtattr(tb, RTA_MAX, RTNH_DATA(nh), nh->rtnh_len - sizeof(*nh));
635
636 if (tb[RTA_ENCAP])
637 lwt_print_encap(fp,
638 tb[RTA_ENCAP_TYPE],
639 tb[RTA_ENCAP]);
640 if (tb[RTA_NEWDST]) {
641 fprintf(fp, " as to %s ",
642 format_host_rta(r->rtm_family,
643 tb[RTA_NEWDST]));
644 }
645 if (tb[RTA_GATEWAY]) {
646 fprintf(fp, " via %s ",
647 format_host_rta(r->rtm_family,
648 tb[RTA_GATEWAY]));
649 }
650 if (tb[RTA_VIA]) {
651 size_t len = RTA_PAYLOAD(tb[RTA_VIA]) - 2;
652 struct rtvia *via = RTA_DATA(tb[RTA_VIA]);
653
654 fprintf(fp, "via %s %s ",
655 family_name(via->rtvia_family),
656 format_host(via->rtvia_family, len, via->rtvia_addr));
657 }
658 if (tb[RTA_FLOW]) {
659 __u32 to = rta_getattr_u32(tb[RTA_FLOW]);
660 __u32 from = to>>16;
661
662 to &= 0xFFFF;
663 fprintf(fp, " realm%s ", from ? "s" : "");
664 if (from) {
665 fprintf(fp, "%s/",
666 rtnl_rtrealm_n2a(from, b1, sizeof(b1)));
667 }
668 fprintf(fp, "%s",
669 rtnl_rtrealm_n2a(to, b1, sizeof(b1)));
670 }
671 }
672 if (r->rtm_flags&RTM_F_CLONED && r->rtm_type == RTN_MULTICAST) {
673 fprintf(fp, " %s", ll_index_to_name(nh->rtnh_ifindex));
674 if (nh->rtnh_hops != 1)
675 fprintf(fp, "(ttl>%d)", nh->rtnh_hops);
676 } else {
677 fprintf(fp, " dev %s", ll_index_to_name(nh->rtnh_ifindex));
678 if (r->rtm_family != AF_MPLS)
679 fprintf(fp, " weight %d",
680 nh->rtnh_hops+1);
681 }
682 if (nh->rtnh_flags & RTNH_F_DEAD)
683 fprintf(fp, " dead");
684 if (nh->rtnh_flags & RTNH_F_ONLINK)
685 fprintf(fp, " onlink");
686 if (nh->rtnh_flags & RTNH_F_PERVASIVE)
687 fprintf(fp, " pervasive");
688 if (nh->rtnh_flags & RTNH_F_LINKDOWN)
689 fprintf(fp, " linkdown");
690 len -= NLMSG_ALIGN(nh->rtnh_len);
691 nh = RTNH_NEXT(nh);
692 }
693 }
694 if (tb[RTA_PREF]) {
695 unsigned int pref = rta_getattr_u8(tb[RTA_PREF]);
696
697 fprintf(fp, " pref ");
698
699 switch (pref) {
700 case ICMPV6_ROUTER_PREF_LOW:
701 fprintf(fp, "low");
702 break;
703 case ICMPV6_ROUTER_PREF_MEDIUM:
704 fprintf(fp, "medium");
705 break;
706 case ICMPV6_ROUTER_PREF_HIGH:
707 fprintf(fp, "high");
708 break;
709 default:
710 fprintf(fp, "%u", pref);
711 }
712 }
713 fprintf(fp, "\n");
714 fflush(fp);
715 return 0;
716 }
717
718 static int parse_one_nh(struct nlmsghdr *n, struct rtmsg *r,
719 struct rtattr *rta, struct rtnexthop *rtnh,
720 int *argcp, char ***argvp)
721 {
722 int argc = *argcp;
723 char **argv = *argvp;
724
725 while (++argv, --argc > 0) {
726 if (strcmp(*argv, "via") == 0) {
727 inet_prefix addr;
728 int family;
729
730 NEXT_ARG();
731 family = read_family(*argv);
732 if (family == AF_UNSPEC)
733 family = r->rtm_family;
734 else
735 NEXT_ARG();
736 get_addr(&addr, *argv, family);
737 if (r->rtm_family == AF_UNSPEC)
738 r->rtm_family = addr.family;
739 if (addr.family == r->rtm_family) {
740 rta_addattr_l(rta, 4096, RTA_GATEWAY, &addr.data, addr.bytelen);
741 rtnh->rtnh_len += sizeof(struct rtattr) + addr.bytelen;
742 } else {
743 rta_addattr_l(rta, 4096, RTA_VIA, &addr.family, addr.bytelen+2);
744 rtnh->rtnh_len += RTA_SPACE(addr.bytelen+2);
745 }
746 } else if (strcmp(*argv, "dev") == 0) {
747 NEXT_ARG();
748 if ((rtnh->rtnh_ifindex = ll_name_to_index(*argv)) == 0) {
749 fprintf(stderr, "Cannot find device \"%s\"\n", *argv);
750 exit(1);
751 }
752 } else if (strcmp(*argv, "weight") == 0) {
753 unsigned int w;
754
755 NEXT_ARG();
756 if (get_unsigned(&w, *argv, 0) || w == 0 || w > 256)
757 invarg("\"weight\" is invalid\n", *argv);
758 rtnh->rtnh_hops = w - 1;
759 } else if (strcmp(*argv, "onlink") == 0) {
760 rtnh->rtnh_flags |= RTNH_F_ONLINK;
761 } else if (matches(*argv, "realms") == 0) {
762 __u32 realm;
763
764 NEXT_ARG();
765 if (get_rt_realms_or_raw(&realm, *argv))
766 invarg("\"realm\" value is invalid\n", *argv);
767 rta_addattr32(rta, 4096, RTA_FLOW, realm);
768 rtnh->rtnh_len += sizeof(struct rtattr) + 4;
769 } else if (strcmp(*argv, "encap") == 0) {
770 int len = rta->rta_len;
771
772 lwt_parse_encap(rta, 4096, &argc, &argv);
773 rtnh->rtnh_len += rta->rta_len - len;
774 } else if (strcmp(*argv, "as") == 0) {
775 inet_prefix addr;
776
777 NEXT_ARG();
778 if (strcmp(*argv, "to") == 0)
779 NEXT_ARG();
780 get_addr(&addr, *argv, r->rtm_family);
781 rta_addattr_l(rta, 4096, RTA_NEWDST, &addr.data,
782 addr.bytelen);
783 rtnh->rtnh_len += sizeof(struct rtattr) + addr.bytelen;
784 } else
785 break;
786 }
787 *argcp = argc;
788 *argvp = argv;
789 return 0;
790 }
791
792 static int parse_nexthops(struct nlmsghdr *n, struct rtmsg *r,
793 int argc, char **argv)
794 {
795 char buf[1024];
796 struct rtattr *rta = (void *)buf;
797 struct rtnexthop *rtnh;
798
799 rta->rta_type = RTA_MULTIPATH;
800 rta->rta_len = RTA_LENGTH(0);
801 rtnh = RTA_DATA(rta);
802
803 while (argc > 0) {
804 if (strcmp(*argv, "nexthop") != 0) {
805 fprintf(stderr, "Error: \"nexthop\" or end of line is expected instead of \"%s\"\n", *argv);
806 exit(-1);
807 }
808 if (argc <= 1) {
809 fprintf(stderr, "Error: unexpected end of line after \"nexthop\"\n");
810 exit(-1);
811 }
812 memset(rtnh, 0, sizeof(*rtnh));
813 rtnh->rtnh_len = sizeof(*rtnh);
814 rta->rta_len += rtnh->rtnh_len;
815 parse_one_nh(n, r, rta, rtnh, &argc, &argv);
816 rtnh = RTNH_NEXT(rtnh);
817 }
818
819 if (rta->rta_len > RTA_LENGTH(0))
820 addattr_l(n, 1024, RTA_MULTIPATH, RTA_DATA(rta), RTA_PAYLOAD(rta));
821 return 0;
822 }
823
824 static int iproute_modify(int cmd, unsigned int flags, int argc, char **argv)
825 {
826 struct {
827 struct nlmsghdr n;
828 struct rtmsg r;
829 char buf[1024];
830 } req;
831 char mxbuf[256];
832 struct rtattr *mxrta = (void *)mxbuf;
833 unsigned int mxlock = 0;
834 char *d = NULL;
835 int gw_ok = 0;
836 int dst_ok = 0;
837 int nhs_ok = 0;
838 int scope_ok = 0;
839 int table_ok = 0;
840 int raw = 0;
841 int type_ok = 0;
842 static int hz;
843
844 memset(&req, 0, sizeof(req));
845
846 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
847 req.n.nlmsg_flags = NLM_F_REQUEST|flags;
848 req.n.nlmsg_type = cmd;
849 req.r.rtm_family = preferred_family;
850 req.r.rtm_table = RT_TABLE_MAIN;
851 req.r.rtm_scope = RT_SCOPE_NOWHERE;
852
853 if (cmd != RTM_DELROUTE) {
854 req.r.rtm_protocol = RTPROT_BOOT;
855 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
856 req.r.rtm_type = RTN_UNICAST;
857 }
858
859 mxrta->rta_type = RTA_METRICS;
860 mxrta->rta_len = RTA_LENGTH(0);
861
862 while (argc > 0) {
863 if (strcmp(*argv, "src") == 0) {
864 inet_prefix addr;
865
866 NEXT_ARG();
867 get_addr(&addr, *argv, req.r.rtm_family);
868 if (req.r.rtm_family == AF_UNSPEC)
869 req.r.rtm_family = addr.family;
870 addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
871 } else if (strcmp(*argv, "as") == 0) {
872 inet_prefix addr;
873
874 NEXT_ARG();
875 if (strcmp(*argv, "to") == 0) {
876 NEXT_ARG();
877 }
878 get_addr(&addr, *argv, req.r.rtm_family);
879 if (req.r.rtm_family == AF_UNSPEC)
880 req.r.rtm_family = addr.family;
881 addattr_l(&req.n, sizeof(req), RTA_NEWDST, &addr.data, addr.bytelen);
882 } else if (strcmp(*argv, "via") == 0) {
883 inet_prefix addr;
884 int family;
885
886 gw_ok = 1;
887 NEXT_ARG();
888 family = read_family(*argv);
889 if (family == AF_UNSPEC)
890 family = req.r.rtm_family;
891 else
892 NEXT_ARG();
893 get_addr(&addr, *argv, family);
894 if (req.r.rtm_family == AF_UNSPEC)
895 req.r.rtm_family = addr.family;
896 if (addr.family == req.r.rtm_family)
897 addattr_l(&req.n, sizeof(req), RTA_GATEWAY,
898 &addr.data, addr.bytelen);
899 else
900 addattr_l(&req.n, sizeof(req), RTA_VIA,
901 &addr.family, addr.bytelen+2);
902 } else if (strcmp(*argv, "from") == 0) {
903 inet_prefix addr;
904
905 NEXT_ARG();
906 get_prefix(&addr, *argv, req.r.rtm_family);
907 if (req.r.rtm_family == AF_UNSPEC)
908 req.r.rtm_family = addr.family;
909 if (addr.bytelen)
910 addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
911 req.r.rtm_src_len = addr.bitlen;
912 } else if (strcmp(*argv, "tos") == 0 ||
913 matches(*argv, "dsfield") == 0) {
914 __u32 tos;
915
916 NEXT_ARG();
917 if (rtnl_dsfield_a2n(&tos, *argv))
918 invarg("\"tos\" value is invalid\n", *argv);
919 req.r.rtm_tos = tos;
920 } else if (strcmp(*argv, "expires") == 0) {
921 __u32 expires;
922
923 NEXT_ARG();
924 if (get_u32(&expires, *argv, 0))
925 invarg("\"expires\" value is invalid\n", *argv);
926 if (!hz)
927 hz = get_user_hz();
928 addattr32(&req.n, sizeof(req), RTA_EXPIRES, expires*hz);
929 } else if (matches(*argv, "metric") == 0 ||
930 matches(*argv, "priority") == 0 ||
931 strcmp(*argv, "preference") == 0) {
932 __u32 metric;
933
934 NEXT_ARG();
935 if (get_u32(&metric, *argv, 0))
936 invarg("\"metric\" value is invalid\n", *argv);
937 addattr32(&req.n, sizeof(req), RTA_PRIORITY, metric);
938 } else if (strcmp(*argv, "scope") == 0) {
939 __u32 scope = 0;
940
941 NEXT_ARG();
942 if (rtnl_rtscope_a2n(&scope, *argv))
943 invarg("invalid \"scope\" value\n", *argv);
944 req.r.rtm_scope = scope;
945 scope_ok = 1;
946 } else if (strcmp(*argv, "mtu") == 0) {
947 unsigned int mtu;
948
949 NEXT_ARG();
950 if (strcmp(*argv, "lock") == 0) {
951 mxlock |= (1<<RTAX_MTU);
952 NEXT_ARG();
953 }
954 if (get_unsigned(&mtu, *argv, 0))
955 invarg("\"mtu\" value is invalid\n", *argv);
956 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
957 } else if (strcmp(*argv, "hoplimit") == 0) {
958 unsigned int hoplimit;
959
960 NEXT_ARG();
961 if (strcmp(*argv, "lock") == 0) {
962 mxlock |= (1<<RTAX_HOPLIMIT);
963 NEXT_ARG();
964 }
965 if (get_unsigned(&hoplimit, *argv, 0) || hoplimit > 255)
966 invarg("\"hoplimit\" value is invalid\n", *argv);
967 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_HOPLIMIT, hoplimit);
968 } else if (strcmp(*argv, "advmss") == 0) {
969 unsigned int mss;
970
971 NEXT_ARG();
972 if (strcmp(*argv, "lock") == 0) {
973 mxlock |= (1<<RTAX_ADVMSS);
974 NEXT_ARG();
975 }
976 if (get_unsigned(&mss, *argv, 0))
977 invarg("\"mss\" value is invalid\n", *argv);
978 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_ADVMSS, mss);
979 } else if (matches(*argv, "reordering") == 0) {
980 unsigned int reord;
981
982 NEXT_ARG();
983 if (strcmp(*argv, "lock") == 0) {
984 mxlock |= (1<<RTAX_REORDERING);
985 NEXT_ARG();
986 }
987 if (get_unsigned(&reord, *argv, 0))
988 invarg("\"reordering\" value is invalid\n", *argv);
989 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_REORDERING, reord);
990 } else if (strcmp(*argv, "rtt") == 0) {
991 unsigned int rtt;
992
993 NEXT_ARG();
994 if (strcmp(*argv, "lock") == 0) {
995 mxlock |= (1<<RTAX_RTT);
996 NEXT_ARG();
997 }
998 if (get_time_rtt(&rtt, *argv, &raw))
999 invarg("\"rtt\" value is invalid\n", *argv);
1000 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_RTT,
1001 (raw) ? rtt : rtt * 8);
1002 } else if (strcmp(*argv, "rto_min") == 0) {
1003 unsigned int rto_min;
1004
1005 NEXT_ARG();
1006 mxlock |= (1<<RTAX_RTO_MIN);
1007 if (get_time_rtt(&rto_min, *argv, &raw))
1008 invarg("\"rto_min\" value is invalid\n",
1009 *argv);
1010 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_RTO_MIN,
1011 rto_min);
1012 } else if (matches(*argv, "window") == 0) {
1013 unsigned int win;
1014
1015 NEXT_ARG();
1016 if (strcmp(*argv, "lock") == 0) {
1017 mxlock |= (1<<RTAX_WINDOW);
1018 NEXT_ARG();
1019 }
1020 if (get_unsigned(&win, *argv, 0))
1021 invarg("\"window\" value is invalid\n", *argv);
1022 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_WINDOW, win);
1023 } else if (matches(*argv, "cwnd") == 0) {
1024 unsigned int win;
1025
1026 NEXT_ARG();
1027 if (strcmp(*argv, "lock") == 0) {
1028 mxlock |= (1<<RTAX_CWND);
1029 NEXT_ARG();
1030 }
1031 if (get_unsigned(&win, *argv, 0))
1032 invarg("\"cwnd\" value is invalid\n", *argv);
1033 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_CWND, win);
1034 } else if (matches(*argv, "initcwnd") == 0) {
1035 unsigned int win;
1036
1037 NEXT_ARG();
1038 if (strcmp(*argv, "lock") == 0) {
1039 mxlock |= (1<<RTAX_INITCWND);
1040 NEXT_ARG();
1041 }
1042 if (get_unsigned(&win, *argv, 0))
1043 invarg("\"initcwnd\" value is invalid\n", *argv);
1044 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_INITCWND, win);
1045 } else if (matches(*argv, "initrwnd") == 0) {
1046 unsigned int win;
1047
1048 NEXT_ARG();
1049 if (strcmp(*argv, "lock") == 0) {
1050 mxlock |= (1<<RTAX_INITRWND);
1051 NEXT_ARG();
1052 }
1053 if (get_unsigned(&win, *argv, 0))
1054 invarg("\"initrwnd\" value is invalid\n", *argv);
1055 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_INITRWND, win);
1056 } else if (matches(*argv, "features") == 0) {
1057 unsigned int features = 0;
1058
1059 while (argc > 0) {
1060 NEXT_ARG();
1061
1062 if (strcmp(*argv, "ecn") == 0)
1063 features |= RTAX_FEATURE_ECN;
1064 else
1065 invarg("\"features\" value not valid\n", *argv);
1066 break;
1067 }
1068
1069 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_FEATURES, features);
1070 } else if (matches(*argv, "quickack") == 0) {
1071 unsigned int quickack;
1072
1073 NEXT_ARG();
1074 if (get_unsigned(&quickack, *argv, 0))
1075 invarg("\"quickack\" value is invalid\n", *argv);
1076 if (quickack != 1 && quickack != 0)
1077 invarg("\"quickack\" value should be 0 or 1\n", *argv);
1078 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_QUICKACK, quickack);
1079 } else if (matches(*argv, "congctl") == 0) {
1080 NEXT_ARG();
1081 if (strcmp(*argv, "lock") == 0) {
1082 mxlock |= 1 << RTAX_CC_ALGO;
1083 NEXT_ARG();
1084 }
1085 rta_addattr_l(mxrta, sizeof(mxbuf), RTAX_CC_ALGO, *argv,
1086 strlen(*argv));
1087 } else if (matches(*argv, "rttvar") == 0) {
1088 unsigned int win;
1089
1090 NEXT_ARG();
1091 if (strcmp(*argv, "lock") == 0) {
1092 mxlock |= (1<<RTAX_RTTVAR);
1093 NEXT_ARG();
1094 }
1095 if (get_time_rtt(&win, *argv, &raw))
1096 invarg("\"rttvar\" value is invalid\n", *argv);
1097 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_RTTVAR,
1098 (raw) ? win : win * 4);
1099 } else if (matches(*argv, "ssthresh") == 0) {
1100 unsigned int win;
1101
1102 NEXT_ARG();
1103 if (strcmp(*argv, "lock") == 0) {
1104 mxlock |= (1<<RTAX_SSTHRESH);
1105 NEXT_ARG();
1106 }
1107 if (get_unsigned(&win, *argv, 0))
1108 invarg("\"ssthresh\" value is invalid\n", *argv);
1109 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_SSTHRESH, win);
1110 } else if (matches(*argv, "realms") == 0) {
1111 __u32 realm;
1112
1113 NEXT_ARG();
1114 if (get_rt_realms_or_raw(&realm, *argv))
1115 invarg("\"realm\" value is invalid\n", *argv);
1116 addattr32(&req.n, sizeof(req), RTA_FLOW, realm);
1117 } else if (strcmp(*argv, "onlink") == 0) {
1118 req.r.rtm_flags |= RTNH_F_ONLINK;
1119 } else if (strcmp(*argv, "nexthop") == 0) {
1120 nhs_ok = 1;
1121 break;
1122 } else if (matches(*argv, "protocol") == 0) {
1123 __u32 prot;
1124
1125 NEXT_ARG();
1126 if (rtnl_rtprot_a2n(&prot, *argv))
1127 invarg("\"protocol\" value is invalid\n", *argv);
1128 req.r.rtm_protocol = prot;
1129 } else if (matches(*argv, "table") == 0) {
1130 __u32 tid;
1131
1132 NEXT_ARG();
1133 if (rtnl_rttable_a2n(&tid, *argv))
1134 invarg("\"table\" value is invalid\n", *argv);
1135 if (tid < 256)
1136 req.r.rtm_table = tid;
1137 else {
1138 req.r.rtm_table = RT_TABLE_UNSPEC;
1139 addattr32(&req.n, sizeof(req), RTA_TABLE, tid);
1140 }
1141 table_ok = 1;
1142 } else if (strcmp(*argv, "dev") == 0 ||
1143 strcmp(*argv, "oif") == 0) {
1144 NEXT_ARG();
1145 d = *argv;
1146 } else if (matches(*argv, "pref") == 0) {
1147 __u8 pref;
1148
1149 NEXT_ARG();
1150 if (strcmp(*argv, "low") == 0)
1151 pref = ICMPV6_ROUTER_PREF_LOW;
1152 else if (strcmp(*argv, "medium") == 0)
1153 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1154 else if (strcmp(*argv, "high") == 0)
1155 pref = ICMPV6_ROUTER_PREF_HIGH;
1156 else if (get_u8(&pref, *argv, 0))
1157 invarg("\"pref\" value is invalid\n", *argv);
1158 addattr8(&req.n, sizeof(req), RTA_PREF, pref);
1159 } else if (strcmp(*argv, "encap") == 0) {
1160 char buf[1024];
1161 struct rtattr *rta = (void *)buf;
1162
1163 rta->rta_type = RTA_ENCAP;
1164 rta->rta_len = RTA_LENGTH(0);
1165
1166 lwt_parse_encap(rta, sizeof(buf), &argc, &argv);
1167
1168 if (rta->rta_len > RTA_LENGTH(0))
1169 addraw_l(&req.n, 1024, RTA_DATA(rta), RTA_PAYLOAD(rta));
1170 } else {
1171 int type;
1172 inet_prefix dst;
1173
1174 if (strcmp(*argv, "to") == 0) {
1175 NEXT_ARG();
1176 }
1177 if ((**argv < '0' || **argv > '9') &&
1178 rtnl_rtntype_a2n(&type, *argv) == 0) {
1179 NEXT_ARG();
1180 req.r.rtm_type = type;
1181 type_ok = 1;
1182 }
1183
1184 if (matches(*argv, "help") == 0)
1185 usage();
1186 if (dst_ok)
1187 duparg2("to", *argv);
1188 get_prefix(&dst, *argv, req.r.rtm_family);
1189 if (req.r.rtm_family == AF_UNSPEC)
1190 req.r.rtm_family = dst.family;
1191 req.r.rtm_dst_len = dst.bitlen;
1192 dst_ok = 1;
1193 if (dst.bytelen)
1194 addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
1195 }
1196 argc--; argv++;
1197 }
1198
1199 if (!dst_ok)
1200 usage();
1201
1202 if (d || nhs_ok) {
1203 int idx;
1204
1205 if (d) {
1206 if ((idx = ll_name_to_index(d)) == 0) {
1207 fprintf(stderr, "Cannot find device \"%s\"\n", d);
1208 return -1;
1209 }
1210 addattr32(&req.n, sizeof(req), RTA_OIF, idx);
1211 }
1212 }
1213
1214 if (mxrta->rta_len > RTA_LENGTH(0)) {
1215 if (mxlock)
1216 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_LOCK, mxlock);
1217 addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
1218 }
1219
1220 if (nhs_ok)
1221 parse_nexthops(&req.n, &req.r, argc, argv);
1222
1223 if (req.r.rtm_family == AF_UNSPEC)
1224 req.r.rtm_family = AF_INET;
1225
1226 if (!table_ok) {
1227 if (req.r.rtm_type == RTN_LOCAL ||
1228 req.r.rtm_type == RTN_BROADCAST ||
1229 req.r.rtm_type == RTN_NAT ||
1230 req.r.rtm_type == RTN_ANYCAST)
1231 req.r.rtm_table = RT_TABLE_LOCAL;
1232 }
1233 if (!scope_ok) {
1234 if (req.r.rtm_family == AF_INET6 ||
1235 req.r.rtm_family == AF_MPLS)
1236 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
1237 else if (req.r.rtm_type == RTN_LOCAL ||
1238 req.r.rtm_type == RTN_NAT)
1239 req.r.rtm_scope = RT_SCOPE_HOST;
1240 else if (req.r.rtm_type == RTN_BROADCAST ||
1241 req.r.rtm_type == RTN_MULTICAST ||
1242 req.r.rtm_type == RTN_ANYCAST)
1243 req.r.rtm_scope = RT_SCOPE_LINK;
1244 else if (req.r.rtm_type == RTN_UNICAST ||
1245 req.r.rtm_type == RTN_UNSPEC) {
1246 if (cmd == RTM_DELROUTE)
1247 req.r.rtm_scope = RT_SCOPE_NOWHERE;
1248 else if (!gw_ok && !nhs_ok)
1249 req.r.rtm_scope = RT_SCOPE_LINK;
1250 }
1251 }
1252
1253 if (!type_ok && req.r.rtm_family == AF_MPLS)
1254 req.r.rtm_type = RTN_UNICAST;
1255
1256 if (rtnl_talk(&rth, &req.n, NULL, 0) < 0)
1257 return -2;
1258
1259 return 0;
1260 }
1261
1262 static int rtnl_rtcache_request(struct rtnl_handle *rth, int family)
1263 {
1264 struct {
1265 struct nlmsghdr nlh;
1266 struct rtmsg rtm;
1267 } req;
1268 struct sockaddr_nl nladdr;
1269
1270 memset(&nladdr, 0, sizeof(nladdr));
1271 memset(&req, 0, sizeof(req));
1272 nladdr.nl_family = AF_NETLINK;
1273
1274 req.nlh.nlmsg_len = sizeof(req);
1275 req.nlh.nlmsg_type = RTM_GETROUTE;
1276 req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_REQUEST;
1277 req.nlh.nlmsg_pid = 0;
1278 req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
1279 req.rtm.rtm_family = family;
1280 req.rtm.rtm_flags |= RTM_F_CLONED;
1281
1282 return sendto(rth->fd, (void *)&req, sizeof(req), 0, (struct sockaddr *)&nladdr, sizeof(nladdr));
1283 }
1284
1285 static int iproute_flush_cache(void)
1286 {
1287 #define ROUTE_FLUSH_PATH "/proc/sys/net/ipv4/route/flush"
1288
1289 int len;
1290 int flush_fd = open(ROUTE_FLUSH_PATH, O_WRONLY);
1291 char *buffer = "-1";
1292
1293 if (flush_fd < 0) {
1294 fprintf(stderr, "Cannot open \"%s\": %s\n",
1295 ROUTE_FLUSH_PATH, strerror(errno));
1296 return -1;
1297 }
1298
1299 len = strlen(buffer);
1300
1301 if ((write(flush_fd, (void *)buffer, len)) < len) {
1302 fprintf(stderr, "Cannot flush routing cache\n");
1303 close(flush_fd);
1304 return -1;
1305 }
1306 close(flush_fd);
1307 return 0;
1308 }
1309
1310 static __u32 route_dump_magic = 0x45311224;
1311
1312 static int save_route(const struct sockaddr_nl *who, struct nlmsghdr *n,
1313 void *arg)
1314 {
1315 int ret;
1316 int len = n->nlmsg_len;
1317 struct rtmsg *r = NLMSG_DATA(n);
1318 struct rtattr *tb[RTA_MAX+1];
1319 int host_len;
1320
1321 host_len = af_bit_len(r->rtm_family);
1322 len -= NLMSG_LENGTH(sizeof(*r));
1323 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
1324
1325 if (!filter_nlmsg(n, tb, host_len))
1326 return 0;
1327
1328 ret = write(STDOUT_FILENO, n, n->nlmsg_len);
1329 if ((ret > 0) && (ret != n->nlmsg_len)) {
1330 fprintf(stderr, "Short write while saving nlmsg\n");
1331 ret = -EIO;
1332 }
1333
1334 return ret == n->nlmsg_len ? 0 : ret;
1335 }
1336
1337 static int save_route_prep(void)
1338 {
1339 int ret;
1340
1341 if (isatty(STDOUT_FILENO)) {
1342 fprintf(stderr, "Not sending a binary stream to stdout\n");
1343 return -1;
1344 }
1345
1346 ret = write(STDOUT_FILENO, &route_dump_magic, sizeof(route_dump_magic));
1347 if (ret != sizeof(route_dump_magic)) {
1348 fprintf(stderr, "Can't write magic to dump file\n");
1349 return -1;
1350 }
1351
1352 return 0;
1353 }
1354
1355 static int iproute_list_flush_or_save(int argc, char **argv, int action)
1356 {
1357 int do_ipv6 = preferred_family;
1358 char *id = NULL;
1359 char *od = NULL;
1360 unsigned int mark = 0;
1361 rtnl_filter_t filter_fn;
1362
1363 if (action == IPROUTE_SAVE) {
1364 if (save_route_prep())
1365 return -1;
1366
1367 filter_fn = save_route;
1368 } else
1369 filter_fn = print_route;
1370
1371 iproute_reset_filter(0);
1372 filter.tb = RT_TABLE_MAIN;
1373
1374 if ((action == IPROUTE_FLUSH) && argc <= 0) {
1375 fprintf(stderr, "\"ip route flush\" requires arguments.\n");
1376 return -1;
1377 }
1378
1379 while (argc > 0) {
1380 if (matches(*argv, "table") == 0) {
1381 __u32 tid;
1382
1383 NEXT_ARG();
1384 if (rtnl_rttable_a2n(&tid, *argv)) {
1385 if (strcmp(*argv, "all") == 0) {
1386 filter.tb = 0;
1387 } else if (strcmp(*argv, "cache") == 0) {
1388 filter.cloned = 1;
1389 } else if (strcmp(*argv, "help") == 0) {
1390 usage();
1391 } else {
1392 invarg("table id value is invalid\n", *argv);
1393 }
1394 } else
1395 filter.tb = tid;
1396 } else if (matches(*argv, "cached") == 0 ||
1397 matches(*argv, "cloned") == 0) {
1398 filter.cloned = 1;
1399 } else if (strcmp(*argv, "tos") == 0 ||
1400 matches(*argv, "dsfield") == 0) {
1401 __u32 tos;
1402
1403 NEXT_ARG();
1404 if (rtnl_dsfield_a2n(&tos, *argv))
1405 invarg("TOS value is invalid\n", *argv);
1406 filter.tos = tos;
1407 filter.tosmask = -1;
1408 } else if (matches(*argv, "protocol") == 0) {
1409 __u32 prot = 0;
1410
1411 NEXT_ARG();
1412 filter.protocolmask = -1;
1413 if (rtnl_rtprot_a2n(&prot, *argv)) {
1414 if (strcmp(*argv, "all") != 0)
1415 invarg("invalid \"protocol\"\n", *argv);
1416 prot = 0;
1417 filter.protocolmask = 0;
1418 }
1419 filter.protocol = prot;
1420 } else if (matches(*argv, "scope") == 0) {
1421 __u32 scope = 0;
1422
1423 NEXT_ARG();
1424 filter.scopemask = -1;
1425 if (rtnl_rtscope_a2n(&scope, *argv)) {
1426 if (strcmp(*argv, "all") != 0)
1427 invarg("invalid \"scope\"\n", *argv);
1428 scope = RT_SCOPE_NOWHERE;
1429 filter.scopemask = 0;
1430 }
1431 filter.scope = scope;
1432 } else if (matches(*argv, "type") == 0) {
1433 int type;
1434
1435 NEXT_ARG();
1436 filter.typemask = -1;
1437 if (rtnl_rtntype_a2n(&type, *argv))
1438 invarg("node type value is invalid\n", *argv);
1439 filter.type = type;
1440 } else if (strcmp(*argv, "dev") == 0 ||
1441 strcmp(*argv, "oif") == 0) {
1442 NEXT_ARG();
1443 od = *argv;
1444 } else if (strcmp(*argv, "iif") == 0) {
1445 NEXT_ARG();
1446 id = *argv;
1447 } else if (strcmp(*argv, "mark") == 0) {
1448 NEXT_ARG();
1449 get_unsigned(&mark, *argv, 0);
1450 filter.markmask = -1;
1451 } else if (strcmp(*argv, "via") == 0) {
1452 int family;
1453
1454 NEXT_ARG();
1455 family = read_family(*argv);
1456 if (family == AF_UNSPEC)
1457 family = do_ipv6;
1458 else
1459 NEXT_ARG();
1460 get_prefix(&filter.rvia, *argv, family);
1461 } else if (strcmp(*argv, "src") == 0) {
1462 NEXT_ARG();
1463 get_prefix(&filter.rprefsrc, *argv, do_ipv6);
1464 } else if (matches(*argv, "realms") == 0) {
1465 __u32 realm;
1466
1467 NEXT_ARG();
1468 if (get_rt_realms_or_raw(&realm, *argv))
1469 invarg("invalid realms\n", *argv);
1470 filter.realm = realm;
1471 filter.realmmask = ~0U;
1472 if ((filter.realm&0xFFFF) == 0 &&
1473 (*argv)[strlen(*argv) - 1] == '/')
1474 filter.realmmask &= ~0xFFFF;
1475 if ((filter.realm&0xFFFF0000U) == 0 &&
1476 (strchr(*argv, '/') == NULL ||
1477 (*argv)[0] == '/'))
1478 filter.realmmask &= ~0xFFFF0000U;
1479 } else if (matches(*argv, "from") == 0) {
1480 NEXT_ARG();
1481 if (matches(*argv, "root") == 0) {
1482 NEXT_ARG();
1483 get_prefix(&filter.rsrc, *argv, do_ipv6);
1484 } else if (matches(*argv, "match") == 0) {
1485 NEXT_ARG();
1486 get_prefix(&filter.msrc, *argv, do_ipv6);
1487 } else {
1488 if (matches(*argv, "exact") == 0) {
1489 NEXT_ARG();
1490 }
1491 get_prefix(&filter.msrc, *argv, do_ipv6);
1492 filter.rsrc = filter.msrc;
1493 }
1494 } else {
1495 if (matches(*argv, "to") == 0) {
1496 NEXT_ARG();
1497 }
1498 if (matches(*argv, "root") == 0) {
1499 NEXT_ARG();
1500 get_prefix(&filter.rdst, *argv, do_ipv6);
1501 } else if (matches(*argv, "match") == 0) {
1502 NEXT_ARG();
1503 get_prefix(&filter.mdst, *argv, do_ipv6);
1504 } else {
1505 if (matches(*argv, "exact") == 0) {
1506 NEXT_ARG();
1507 }
1508 get_prefix(&filter.mdst, *argv, do_ipv6);
1509 filter.rdst = filter.mdst;
1510 }
1511 }
1512 argc--; argv++;
1513 }
1514
1515 if (do_ipv6 == AF_UNSPEC && filter.tb)
1516 do_ipv6 = AF_INET;
1517
1518 if (id || od) {
1519 int idx;
1520
1521 if (id) {
1522 if ((idx = ll_name_to_index(id)) == 0) {
1523 fprintf(stderr, "Cannot find device \"%s\"\n", id);
1524 return -1;
1525 }
1526 filter.iif = idx;
1527 filter.iifmask = -1;
1528 }
1529 if (od) {
1530 if ((idx = ll_name_to_index(od)) == 0) {
1531 fprintf(stderr, "Cannot find device \"%s\"\n", od);
1532 return -1;
1533 }
1534 filter.oif = idx;
1535 filter.oifmask = -1;
1536 }
1537 }
1538 filter.mark = mark;
1539
1540 if (action == IPROUTE_FLUSH) {
1541 int round = 0;
1542 char flushb[4096-512];
1543 time_t start = time(0);
1544
1545 if (filter.cloned) {
1546 if (do_ipv6 != AF_INET6) {
1547 iproute_flush_cache();
1548 if (show_stats)
1549 printf("*** IPv4 routing cache is flushed.\n");
1550 }
1551 if (do_ipv6 == AF_INET)
1552 return 0;
1553 }
1554
1555 filter.flushb = flushb;
1556 filter.flushp = 0;
1557 filter.flushe = sizeof(flushb);
1558
1559 for (;;) {
1560 if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
1561 perror("Cannot send dump request");
1562 exit(1);
1563 }
1564 filter.flushed = 0;
1565 if (rtnl_dump_filter(&rth, filter_fn, stdout) < 0) {
1566 fprintf(stderr, "Flush terminated\n");
1567 exit(1);
1568 }
1569 if (filter.flushed == 0) {
1570 if (show_stats) {
1571 if (round == 0 && (!filter.cloned || do_ipv6 == AF_INET6))
1572 printf("Nothing to flush.\n");
1573 else
1574 printf("*** Flush is complete after %d round%s ***\n", round, round > 1?"s":"");
1575 }
1576 fflush(stdout);
1577 return 0;
1578 }
1579 round++;
1580 if (flush_update() < 0)
1581 exit(1);
1582
1583 if (time(0) - start > 30) {
1584 printf("\n*** Flush not completed after %ld seconds, %d entries remain ***\n",
1585 (long)(time(0) - start), filter.flushed);
1586 exit(1);
1587 }
1588
1589 if (show_stats) {
1590 printf("\n*** Round %d, deleting %d entries ***\n", round, filter.flushed);
1591 fflush(stdout);
1592 }
1593 }
1594 }
1595
1596 if (!filter.cloned) {
1597 if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
1598 perror("Cannot send dump request");
1599 exit(1);
1600 }
1601 } else {
1602 if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
1603 perror("Cannot send dump request");
1604 exit(1);
1605 }
1606 }
1607
1608 if (rtnl_dump_filter(&rth, filter_fn, stdout) < 0) {
1609 fprintf(stderr, "Dump terminated\n");
1610 exit(1);
1611 }
1612
1613 exit(0);
1614 }
1615
1616
1617 static int iproute_get(int argc, char **argv)
1618 {
1619 struct {
1620 struct nlmsghdr n;
1621 struct rtmsg r;
1622 char buf[1024];
1623 } req;
1624 char *idev = NULL;
1625 char *odev = NULL;
1626 int connected = 0;
1627 int from_ok = 0;
1628 unsigned int mark = 0;
1629
1630 memset(&req, 0, sizeof(req));
1631
1632 iproute_reset_filter(0);
1633 filter.cloned = 2;
1634
1635 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
1636 req.n.nlmsg_flags = NLM_F_REQUEST;
1637 req.n.nlmsg_type = RTM_GETROUTE;
1638 req.r.rtm_family = preferred_family;
1639 req.r.rtm_table = 0;
1640 req.r.rtm_protocol = 0;
1641 req.r.rtm_scope = 0;
1642 req.r.rtm_type = 0;
1643 req.r.rtm_src_len = 0;
1644 req.r.rtm_dst_len = 0;
1645 req.r.rtm_tos = 0;
1646
1647 while (argc > 0) {
1648 if (strcmp(*argv, "tos") == 0 ||
1649 matches(*argv, "dsfield") == 0) {
1650 __u32 tos;
1651
1652 NEXT_ARG();
1653 if (rtnl_dsfield_a2n(&tos, *argv))
1654 invarg("TOS value is invalid\n", *argv);
1655 req.r.rtm_tos = tos;
1656 } else if (matches(*argv, "from") == 0) {
1657 inet_prefix addr;
1658
1659 NEXT_ARG();
1660 if (matches(*argv, "help") == 0)
1661 usage();
1662 from_ok = 1;
1663 get_prefix(&addr, *argv, req.r.rtm_family);
1664 if (req.r.rtm_family == AF_UNSPEC)
1665 req.r.rtm_family = addr.family;
1666 if (addr.bytelen)
1667 addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
1668 req.r.rtm_src_len = addr.bitlen;
1669 } else if (matches(*argv, "iif") == 0) {
1670 NEXT_ARG();
1671 idev = *argv;
1672 } else if (matches(*argv, "mark") == 0) {
1673 NEXT_ARG();
1674 get_unsigned(&mark, *argv, 0);
1675 } else if (matches(*argv, "oif") == 0 ||
1676 strcmp(*argv, "dev") == 0) {
1677 NEXT_ARG();
1678 odev = *argv;
1679 } else if (matches(*argv, "notify") == 0) {
1680 req.r.rtm_flags |= RTM_F_NOTIFY;
1681 } else if (matches(*argv, "connected") == 0) {
1682 connected = 1;
1683 } else {
1684 inet_prefix addr;
1685
1686 if (strcmp(*argv, "to") == 0) {
1687 NEXT_ARG();
1688 }
1689 if (matches(*argv, "help") == 0)
1690 usage();
1691 get_prefix(&addr, *argv, req.r.rtm_family);
1692 if (req.r.rtm_family == AF_UNSPEC)
1693 req.r.rtm_family = addr.family;
1694 if (addr.bytelen)
1695 addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen);
1696 req.r.rtm_dst_len = addr.bitlen;
1697 }
1698 argc--; argv++;
1699 }
1700
1701 if (req.r.rtm_dst_len == 0) {
1702 fprintf(stderr, "need at least a destination address\n");
1703 exit(1);
1704 }
1705
1706 if (idev || odev) {
1707 int idx;
1708
1709 if (idev) {
1710 if ((idx = ll_name_to_index(idev)) == 0) {
1711 fprintf(stderr, "Cannot find device \"%s\"\n", idev);
1712 return -1;
1713 }
1714 addattr32(&req.n, sizeof(req), RTA_IIF, idx);
1715 }
1716 if (odev) {
1717 if ((idx = ll_name_to_index(odev)) == 0) {
1718 fprintf(stderr, "Cannot find device \"%s\"\n", odev);
1719 return -1;
1720 }
1721 addattr32(&req.n, sizeof(req), RTA_OIF, idx);
1722 }
1723 }
1724 if (mark)
1725 addattr32(&req.n, sizeof(req), RTA_MARK, mark);
1726
1727 if (req.r.rtm_family == AF_UNSPEC)
1728 req.r.rtm_family = AF_INET;
1729
1730 req.r.rtm_flags |= RTM_F_LOOKUP_TABLE;
1731
1732 if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0)
1733 return -2;
1734
1735 if (connected && !from_ok) {
1736 struct rtmsg *r = NLMSG_DATA(&req.n);
1737 int len = req.n.nlmsg_len;
1738 struct rtattr *tb[RTA_MAX+1];
1739
1740 if (print_route(NULL, &req.n, (void *)stdout) < 0) {
1741 fprintf(stderr, "An error :-)\n");
1742 exit(1);
1743 }
1744
1745 if (req.n.nlmsg_type != RTM_NEWROUTE) {
1746 fprintf(stderr, "Not a route?\n");
1747 return -1;
1748 }
1749 len -= NLMSG_LENGTH(sizeof(*r));
1750 if (len < 0) {
1751 fprintf(stderr, "Wrong len %d\n", len);
1752 return -1;
1753 }
1754
1755 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
1756
1757 if (tb[RTA_PREFSRC]) {
1758 tb[RTA_PREFSRC]->rta_type = RTA_SRC;
1759 r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
1760 } else if (!tb[RTA_SRC]) {
1761 fprintf(stderr, "Failed to connect the route\n");
1762 return -1;
1763 }
1764 if (!odev && tb[RTA_OIF])
1765 tb[RTA_OIF]->rta_type = 0;
1766 if (tb[RTA_GATEWAY])
1767 tb[RTA_GATEWAY]->rta_type = 0;
1768 if (tb[RTA_VIA])
1769 tb[RTA_VIA]->rta_type = 0;
1770 if (!idev && tb[RTA_IIF])
1771 tb[RTA_IIF]->rta_type = 0;
1772 req.n.nlmsg_flags = NLM_F_REQUEST;
1773 req.n.nlmsg_type = RTM_GETROUTE;
1774
1775 if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0)
1776 return -2;
1777 }
1778
1779 if (print_route(NULL, &req.n, (void *)stdout) < 0) {
1780 fprintf(stderr, "An error :-)\n");
1781 return -1;
1782 }
1783
1784 return 0;
1785 }
1786
1787 static int restore_handler(const struct sockaddr_nl *nl,
1788 struct rtnl_ctrl_data *ctrl,
1789 struct nlmsghdr *n, void *arg)
1790 {
1791 int ret;
1792
1793 n->nlmsg_flags |= NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK;
1794
1795 ll_init_map(&rth);
1796
1797 ret = rtnl_talk(&rth, n, n, sizeof(*n));
1798 if ((ret < 0) && (errno == EEXIST))
1799 ret = 0;
1800
1801 return ret;
1802 }
1803
1804 static int route_dump_check_magic(void)
1805 {
1806 int ret;
1807 __u32 magic = 0;
1808
1809 if (isatty(STDIN_FILENO)) {
1810 fprintf(stderr, "Can't restore route dump from a terminal\n");
1811 return -1;
1812 }
1813
1814 ret = fread(&magic, sizeof(magic), 1, stdin);
1815 if (magic != route_dump_magic) {
1816 fprintf(stderr, "Magic mismatch (%d elems, %x magic)\n", ret, magic);
1817 return -1;
1818 }
1819
1820 return 0;
1821 }
1822
1823 static int iproute_restore(void)
1824 {
1825 if (route_dump_check_magic())
1826 exit(-1);
1827
1828 exit(rtnl_from_file(stdin, &restore_handler, NULL));
1829 }
1830
1831 static int show_handler(const struct sockaddr_nl *nl,
1832 struct rtnl_ctrl_data *ctrl,
1833 struct nlmsghdr *n, void *arg)
1834 {
1835 print_route(nl, n, stdout);
1836 return 0;
1837 }
1838
1839 static int iproute_showdump(void)
1840 {
1841 if (route_dump_check_magic())
1842 exit(-1);
1843
1844 exit(rtnl_from_file(stdin, &show_handler, NULL));
1845 }
1846
1847 void iproute_reset_filter(int ifindex)
1848 {
1849 memset(&filter, 0, sizeof(filter));
1850 filter.mdst.bitlen = -1;
1851 filter.msrc.bitlen = -1;
1852 filter.oif = ifindex;
1853 if (filter.oif > 0)
1854 filter.oifmask = -1;
1855 }
1856
1857 int do_iproute(int argc, char **argv)
1858 {
1859 if (argc < 1)
1860 return iproute_list_flush_or_save(0, NULL, IPROUTE_LIST);
1861
1862 if (matches(*argv, "add") == 0)
1863 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_EXCL,
1864 argc-1, argv+1);
1865 if (matches(*argv, "change") == 0 || strcmp(*argv, "chg") == 0)
1866 return iproute_modify(RTM_NEWROUTE, NLM_F_REPLACE,
1867 argc-1, argv+1);
1868 if (matches(*argv, "replace") == 0)
1869 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_REPLACE,
1870 argc-1, argv+1);
1871 if (matches(*argv, "prepend") == 0)
1872 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE,
1873 argc-1, argv+1);
1874 if (matches(*argv, "append") == 0)
1875 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_APPEND,
1876 argc-1, argv+1);
1877 if (matches(*argv, "test") == 0)
1878 return iproute_modify(RTM_NEWROUTE, NLM_F_EXCL,
1879 argc-1, argv+1);
1880 if (matches(*argv, "delete") == 0)
1881 return iproute_modify(RTM_DELROUTE, 0,
1882 argc-1, argv+1);
1883 if (matches(*argv, "list") == 0 || matches(*argv, "show") == 0
1884 || matches(*argv, "lst") == 0)
1885 return iproute_list_flush_or_save(argc-1, argv+1, IPROUTE_LIST);
1886 if (matches(*argv, "get") == 0)
1887 return iproute_get(argc-1, argv+1);
1888 if (matches(*argv, "flush") == 0)
1889 return iproute_list_flush_or_save(argc-1, argv+1, IPROUTE_FLUSH);
1890 if (matches(*argv, "save") == 0)
1891 return iproute_list_flush_or_save(argc-1, argv+1, IPROUTE_SAVE);
1892 if (matches(*argv, "restore") == 0)
1893 return iproute_restore();
1894 if (matches(*argv, "showdump") == 0)
1895 return iproute_showdump();
1896 if (matches(*argv, "help") == 0)
1897 usage();
1898 fprintf(stderr, "Command \"%s\" is unknown, try \"ip route help\".\n", *argv);
1899 exit(-1);
1900 }
Upstream mirror of iproute2