1 /* ip.c - Show / manipulate routing, devices, policy routing and tunnels.
2 *
3 * Copyright 2014 Sameer Prakash Pradhan <sameer.p.pradhan@gmail.com>
4 * Copyright 2014 Ranjan Kumar <ranjankumar.bth@gmail.com>
5 * Copyright 2014 Rajni Kant <rajnikant12345@gmail.com>
6 * Copyright 2014 Bilal Qureshi <bilal.jmi@gmail.com>
7 *
8 * No Standard.
9 *
10 USE_IP(NEWTOY(ip, NULL, TOYFLAG_SBIN))
11 USE_IP(OLDTOY(ipaddr, ip, TOYFLAG_SBIN))
12 USE_IP(OLDTOY(iplink, ip, TOYFLAG_SBIN))
13 USE_IP(OLDTOY(iproute, ip, TOYFLAG_SBIN))
14 USE_IP(OLDTOY(iprule, ip, TOYFLAG_SBIN))
15 USE_IP(OLDTOY(iptunnel, ip, TOYFLAG_SBIN))
16
17 config IP
18 bool "ip"
19 default n
20 help
21 usage: ip [ OPTIONS ] OBJECT { COMMAND }
22
23 Show / manipulate routing, devices, policy routing and tunnels.
24
25 where OBJECT := {address | link | route | rule | tunnel}
26 OPTIONS := { -f[amily] { inet | inet6 | link } | -o[neline] }
27 */
28 #define FOR_ip
29 #include "toys.h"
30 #include <linux/netlink.h>
31 #include <linux/rtnetlink.h>
32 #include <linux/if_ether.h>
33 #include <linux/if_addr.h>
34 #include <net/if_arp.h>
35 #include <ifaddrs.h>
36 #include <fnmatch.h>
37 #include <netinet/ip.h>
38 #include <linux/if_tunnel.h>
39
40 GLOBALS(
41 char stats, singleline, flush, *filter_dev, gbuf[8192];
42 int sockfd, connected, from_ok, route_cmd;
43 int8_t addressfamily, is_addr;
44 )
45
46 struct arglist {
47 char *name;
48 int idx;
49 };
50
51 static struct
52 {
53 int ifindex, scope, scopemask, up, to;
54 char *label, *addr;
55 } addrinfo;
56
57 struct linkdata {
58 struct linkdata *next, *prev;
59 int flags, iface_idx, mtu, txqueuelen, parent,iface_type;
60 char qdiscpline[IFNAMSIZ+1], state[IFNAMSIZ+1], type[IFNAMSIZ+1],
61 iface[IFNAMSIZ+1], laddr[64], bcast[64];
62 struct rtnl_link_stats rt_stat;
63 }*linfo;
64
65 typedef int (*cmdobj)(char **argv);
66
67 #define MESG_LEN 8192
68
69 // For "/etc/iproute2/RPDB_tables"
70 enum {
71 RPDB_rtdsfield = 1,
72 RPDB_rtprotos = 2,
73 RPDB_rtrealms = 3,
74 RPDB_rtscopes = 4,
75 RPDB_rttables = 5
76 };
77
78 #define RPDB_ENTRIES 256
79 static int8_t rttable_init;
80 static int8_t rtprotos_init;
81 static int8_t rtdsfield_init;
82 static int8_t rtscope_init;
83 static int8_t rtrealms_init;
84
85 static struct arglist *rt_dsfield[RPDB_ENTRIES];
86 static struct arglist *rt_protos[RPDB_ENTRIES];
87 static struct arglist *rt_tables[RPDB_ENTRIES];
88 static struct arglist *rt_realms[RPDB_ENTRIES];
89 static struct arglist *rt_scope[RPDB_ENTRIES];
90
91 static struct arglist rtmtypes[] = { {"none", RTN_UNSPEC},
92 {"unicast", RTN_UNICAST}, {"local", RTN_LOCAL},
93 {"broadcast", RTN_BROADCAST}, {"anycast", RTN_ANYCAST},
94 {"multicast", RTN_MULTICAST}, {"blackhole", RTN_BLACKHOLE},
95 {"unreachable", RTN_UNREACHABLE}, {"prohibit", RTN_PROHIBIT},
96 {"throw", RTN_THROW}, {"nat", RTN_NAT},
97 {"xresolve", RTN_XRESOLVE}, {NULL, -1}
98 };
99
100 static int filter_nlmesg(int (*fun)(struct nlmsghdr *mhdr, char **), char **);
101 static int ipaddr_print(struct linkdata *, int flg);
102
103
104 // ===========================================================================
105 // Common Code for IP Options (like: addr, link, route etc.)
106 // ===========================================================================
substring_to_idx(char * str,struct arglist * list)107 static int substring_to_idx(char *str, struct arglist *list)
108 {
109 struct arglist *alist;
110 int len;
111
112 if (!str) return -1;
113 len = strlen(str);
114
115 for (alist = list; alist->name; alist++)
116 if (!memcmp(str, alist->name, len)) return alist->idx;
117 return -1;
118 }
119
string_to_idx(char * str,struct arglist * list)120 static int string_to_idx(char *str, struct arglist *list)
121 {
122 struct arglist *alist;
123
124 if (!str) return -1;
125 for (alist = list; alist->name; alist++)
126 if (!strcmp(str, alist->name)) return alist->idx;
127 return -1;
128 }
129
idx_to_string(int idx,struct arglist * list)130 static char *idx_to_string(int idx, struct arglist *list)
131 {
132 struct arglist *alist;
133
134 if (idx < 0) return NULL;
135 for (alist = list; alist->name; alist++)
136 if (idx == alist->idx) return alist->name;
137 return NULL;
138 }
139
send_nlmesg(int type,int flags,int family,void * buf,int blen)140 static void send_nlmesg(int type, int flags, int family,
141 void *buf, int blen)
142 {
143 struct {
144 struct nlmsghdr nlh;
145 struct rtgenmsg g;
146 } req;
147
148 if (!buf) {
149 memset(&req, 0, sizeof(req));
150 req.nlh.nlmsg_len = sizeof(req);
151 req.nlh.nlmsg_type = type;
152 req.nlh.nlmsg_flags = flags;
153 req.g.rtgen_family = family;
154 buf = &req;
155 blen = sizeof(req);
156 }
157 if (send(TT.sockfd , (void*)buf, blen, 0) < 0)
158 perror_exit("Unable to send data on socket.");
159 }
160
161 // Parse /etc/iproute2/RPDB_tables and prepare list.
parseRPDB(char * fname,struct arglist ** list,int32_t size)162 static void parseRPDB(char *fname, struct arglist **list, int32_t size)
163 {
164 char *line;
165 int fd = open(fname, O_RDONLY);
166
167 if (fd < 0) return;
168 for (; (line = get_line(fd)); free(line)) {
169 char *ptr = line;
170 int32_t idx;
171
172 while (*ptr == ' ' || *ptr == '\t') ptr++;
173 if (*ptr == 0 || *ptr == '#' || *ptr == '\n') continue;
174 if ((sscanf(ptr, "0x%x %s\n", &idx, toybuf) != 2) &&
175 (sscanf(ptr, "0x%x %s #", &idx, toybuf) != 2) &&
176 (sscanf(ptr, "%d %s\n", &idx, toybuf) != 2) &&
177 (sscanf(ptr, "%d %s #", &idx, toybuf) != 2)) {
178 error_msg("Corrupted '%s' file", fname);
179 xclose(fd);
180 free(line);
181 return;
182 }
183 if (idx >= 0 && idx < size) {
184 int index = idx & (size-1);
185 if (list[index]) free(list[index]->name);
186 else list[index] = xzalloc(sizeof(struct arglist));
187 list[index]->idx = idx;
188 list[index]->name = xstrdup(toybuf);
189 }
190 }
191 xclose(fd);
192 }
193
free_alist(struct arglist ** list)194 static void free_alist(struct arglist **list)
195 {
196 int i;
197 for (i = 0;i<RPDB_ENTRIES;i++) {
198 if (list[i]) {
199 free(list[i]->name);
200 free(list[i]);
201 }
202 }
203 }
204
init_arglist(struct arglist ** list,int value,char * name)205 static void init_arglist(struct arglist **list,int value, char* name)
206 {
207 if (!list[value]) list[value] = xzalloc(sizeof(struct arglist));
208 list[value]->idx = value;
209 list[value]->name = xstrdup(name);
210 }
211
getlist(u_int8_t whichDB)212 static struct arglist **getlist(u_int8_t whichDB)
213 {
214 struct arglist **alist;
215
216 switch (whichDB) {
217 case RPDB_rtdsfield:
218 alist = rt_dsfield;
219 if (!rtdsfield_init) {
220 rtdsfield_init = 1;
221 parseRPDB("/etc/iproute2/rt_dsfield", alist, ARRAY_LEN(rt_dsfield));
222 }
223 break;
224 case RPDB_rtprotos:
225 alist = rt_protos;
226 if (!rttable_init) {
227 rtprotos_init = 1;
228 init_arglist(rt_protos,0,"none");
229 init_arglist(rt_protos,1,"redirect");
230 init_arglist(rt_protos,2,"kernel");
231 init_arglist(rt_protos,3,"boot");
232 init_arglist(rt_protos,4,"static");
233 init_arglist(rt_protos,8,"gated");
234 init_arglist(rt_protos,9,"ra");
235 init_arglist(rt_protos,10,"mrt");
236 init_arglist(rt_protos,11,"zebra");
237 init_arglist(rt_protos,12,"bird");
238 parseRPDB("/etc/iproute2/rt_protos", alist, ARRAY_LEN(rt_protos));
239 }
240 break;
241 case RPDB_rtrealms:
242 alist = rt_realms;
243 if (!rtrealms_init) {
244 rtrealms_init = 1;
245 init_arglist(rt_realms,0,"unspec");
246 parseRPDB("/etc/iproute2/rt_realms", alist, ARRAY_LEN(rt_realms));
247 }
248 break;
249 case RPDB_rtscopes:
250 alist = rt_scope;
251 if (!rtscope_init) {
252 rtscope_init = 1;
253 init_arglist(rt_scope,0,"global");
254 init_arglist(rt_scope,200,"site");
255 init_arglist(rt_scope,253,"link");
256 init_arglist(rt_scope,254,"host");
257 init_arglist(rt_scope,255,"nowhere");
258 parseRPDB("/etc/iproute2/rt_scopes", alist, ARRAY_LEN(rt_scope));
259 }
260 break;
261 case RPDB_rttables:
262 alist = rt_tables;
263 if (!rttable_init) {
264 rttable_init = 1;
265 init_arglist(rt_tables,RT_TABLE_DEFAULT,"default");
266 init_arglist(rt_tables,RT_TABLE_MAIN,"main");
267 init_arglist(rt_tables,RT_TABLE_LOCAL,"local");
268 parseRPDB("/etc/iproute2/rt_tables", alist, ARRAY_LEN(rt_tables));
269 }
270 break;
271 default:
272 error_exit("wrong database");
273 break; // Unreachable code.
274 }
275 return alist;
276 }
277
278 /*
279 * Parse RPBD tables (if not parsed already).
280 * return RPDB table name as per idx.
281 */
namefromRPDB(int idx,u_int8_t whichDB)282 static char *namefromRPDB(int idx, u_int8_t whichDB)
283 {
284 struct arglist **alist;
285
286 if (idx < 0 || idx >= RPDB_ENTRIES) {
287 snprintf(toybuf, RPDB_ENTRIES, "%u", idx);
288 return toybuf;
289 }
290
291 alist = getlist(whichDB);
292
293 if (alist[idx] && alist[idx]->name) return alist[idx]->name;
294
295 if (whichDB == RPDB_rtdsfield) snprintf(toybuf, RPDB_ENTRIES, "0x%02x", idx);
296 else snprintf(toybuf, RPDB_ENTRIES, "%u", idx);
297
298 return toybuf;
299 }
300
idxfromRPDB(char * name,u_int8_t whichDB)301 static int idxfromRPDB(char *name, u_int8_t whichDB)
302 {
303 struct arglist **alist;
304 long i = 0;
305 char *ptr = NULL;
306
307 for (alist = getlist(whichDB); i < RPDB_ENTRIES; i++) {
308 if (!alist[i] || !alist[i]->name) continue;
309 if (!strcmp(alist[i]->name, name)) return i;
310 }
311 i = strtol(name, &ptr, 0);
312 if (errno || (ptr && *ptr) || i < 0 || i > 255)
313 return -1;
314 return i;
315 }
316
rtmtype_idx2str(u_int8_t idx)317 static char *rtmtype_idx2str(u_int8_t idx)
318 {
319 char *name = idx_to_string(idx, rtmtypes);
320
321 if (!name) snprintf(toybuf, RPDB_ENTRIES, "%u", idx);
322 else snprintf(toybuf, sizeof(toybuf), "%s", name);
323 return toybuf;
324 }
325
rtmtype_str2idx(char * name)326 static int rtmtype_str2idx(char *name)
327 {
328 int idx = string_to_idx(name, rtmtypes);
329
330 if (idx < 0) return atolx_range(name, 0, 255);
331 return idx;
332 }
333
334 /*
335 * Used to get the prefix value in binary form.
336 * For IPv4: non-standard parsing used; as 10.10 will be treated as 10.10.0.0
337 * unlike inet_aton which is 10.0.0.10
338 */
get_prefix(uint32_t * addr,uint8_t * af,char * name,int family)339 static int get_prefix(uint32_t *addr, uint8_t *af, char *name, int family)
340 {
341 if (family == AF_PACKET) error_exit("'%s' may be inet prefix", name);
342 if (!memcmp(name, "default", strlen(name))
343 || !memcmp(name, "all", strlen(name))
344 || !memcmp(name, "any", strlen(name))) {
345 *af = family;
346 return 0;
347 }
348 if (strchr(name, ':')) {
349 *af = AF_INET6;
350 if (family != AF_UNSPEC && family != AF_INET6) return 1;
351 if (inet_pton(AF_INET6, name, (void *)addr) != 1)
352 return 1;
353 } else { // for IPv4.
354 char *ptr = name;
355 uint8_t count = 0;
356
357 *af = AF_INET;
358 if (family != AF_UNSPEC && family != AF_INET) return 1;
359 while (*ptr) {
360 int val, len = 0;
361
362 if (*ptr == '.') ptr++;
363 sscanf(ptr, "%d%n", &val, &len);
364 if (!len || len > 3 || val < 0 || val > 255 || count > 3) return 1;
365 ptr += len;
366 ((uint8_t*)addr)[count++] = val;
367 }
368 }
369 return 0;
370 }
371
372 /*
373 * Used to calculate netmask, which can be in the form of
374 * either 255.255.255.0 or 24 or default or any or all strings.
375 */
get_nmask_prefix(uint32_t * netmask,uint8_t af,char * name,uint8_t family)376 static int get_nmask_prefix(uint32_t *netmask, uint8_t af,
377 char *name, uint8_t family)
378 {
379 char *ptr;
380 uint32_t naddr[4] = {0,};
381 uint64_t plen;
382 uint8_t naf = AF_UNSPEC;
383
384 *netmask = (af == AF_INET6) ? 128 : 32; // set default netmask
385 plen = strtoul(name, &ptr, 0);
386
387 if (!ptr || ptr == name || *ptr || !plen || plen > *netmask) {
388 if (get_prefix(naddr, &naf, name, family)) return -1;
389 if (naf == AF_INET) {
390 uint32_t mask = htonl(*naddr), host = ~mask;
391 if (host & (host + 1)) return -1;
392 for (plen = 0; mask; mask <<= 1) ++plen;
393 if (plen > 32) return -1;
394 }
395 }
396 *netmask = plen;
397 return 0;
398 }
399
400 /*
401 * Parse prefix, which will be in form of
402 * either default or default/default or default/24 or default/255.255.255.0
403 * or 10.20.30.40 or 10.20.30.40/default or 10.20.30.40/24
404 * or 10.20.30.40/255.255.255.0
405 */
parse_prefix(uint32_t * addr,uint32_t * netmask,uint8_t * len,char * name,int family)406 static void parse_prefix(uint32_t *addr, uint32_t *netmask, uint8_t *len,
407 char *name, int family)
408 {
409 uint8_t af = AF_UNSPEC;
410 char *slash = strchr(name, '/');
411
412 if (slash) *slash = 0;
413 if (get_prefix(addr, &af, name, family)) error_exit("Invalid prefix");
414
415 if (slash) { // grab netmask.
416 if (get_nmask_prefix(netmask, af, slash+1, family))
417 error_exit("Invalid prefix");
418 *slash ='/';
419 }
420 else if (af == AF_INET && *addr) *netmask = 32;
421 else if (af == AF_INET6 && (*addr || *(addr+3))) *netmask = 128;
422
423 if (!*addr && !slash && !af) *len = 0;
424 else *len = (af == AF_INET6) ? 16 : 4;
425 }
426
add_string_to_rtattr(struct nlmsghdr * n,int maxlen,int type,void * data,int alen)427 static void add_string_to_rtattr(struct nlmsghdr *n, int maxlen,
428 int type, void *data, int alen)
429 {
430 int len = RTA_LENGTH(alen);
431 struct rtattr *rta;
432
433 if ((int)(NLMSG_ALIGN(n->nlmsg_len) + len) > maxlen) return;
434 rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
435 rta->rta_type = type;
436 rta->rta_len = len;
437 memcpy(RTA_DATA(rta), data, alen);
438 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
439 }
440
441
442
443 // ===========================================================================
444 // Code for ip link.
445 // ===========================================================================
446 #ifndef NLMSG_TAIL
447 #define NLMSG_TAIL(nmsg) \
448 ((struct rtattr *) (((void *) (nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
449 #endif
450
get_ifaceindex(char * name,int ext)451 static uint32_t get_ifaceindex(char *name, int ext)
452 {
453 struct if_nameindex *if_ni, *i;
454 int index = -1;
455
456 if_ni = if_nameindex();
457 if (!if_ni) perror_exit("if_nameindex");
458
459 for (i = if_ni; i->if_index && i->if_name; i++)
460 if (!strcmp(name, i->if_name)) {
461 index = i->if_index;
462 break;
463 }
464 if_freenameindex(if_ni);
465 if (index == -1 && ext) perror_exit("can't find device '%s'", name);
466 return index;
467 }
468
fill_hwaddr(char * arg,int len,unsigned char * address)469 static void fill_hwaddr(char *arg, int len, unsigned char *address)
470 {
471 int count = 0, val, length;
472
473 while (count < len) {
474 val = length = 0;
475 if (!arg) error_exit("bad hw-addr '%s'", "");
476 if (*arg == ':') arg++, count++;
477 sscanf(arg, "%2x%n", &val, &length);
478 if (!length || length > 2)
479 error_exit("bad hw-addr '%s'", arg);
480 arg += length;
481 count += length;
482 *address++ = val;
483 }
484 }
485
486 // Multimach = 1, single match = 0
get_flag_string(struct arglist * aflags,int flags,int ismulti)487 static char *get_flag_string(struct arglist *aflags, int flags, int ismulti)
488 {
489 struct arglist *p = aflags;
490 char *out = NULL, *tmp = NULL;
491
492 for (; p->name; p++) {
493 int test = (ismulti ? p->idx & flags : 0) || p->idx == flags;
494 if (test) { // flags can be zero
495 tmp = out ? xmprintf("%s,%s", out, p->name) : xmprintf("%s", p->name);
496 if (out) free(out);
497 out = tmp;
498 }
499 }
500 return out;
501 }
502
vlan_parse_opt(char ** argv,struct nlmsghdr * n,unsigned int size)503 static void vlan_parse_opt(char **argv, struct nlmsghdr *n, unsigned int size)
504 {
505 struct arglist vlan_optlist[] = {{"id", 0}, {"protocol", 1},
506 {"reorder_hdr", 2}, {"gvrp", 3}, {NULL,-1}};
507 struct arglist vlan_protolist[] = {{"802.1q", 0}, {"802.1ad", 1}, {NULL,-1}};
508 struct arglist on_off[] = { {"on", 0}, {"off", 1}, {NULL,-1}};
509 int idx;
510 struct ifla_vlan_flags flags;
511
512 memset(&flags, 0, sizeof(flags));
513 for (; *argv; argv++) {
514 int param, proto;
515
516 if ((idx = substring_to_idx(*argv++, vlan_optlist)) == -1) help_exit(0);
517 switch (idx) {
518 case 0: // ARG_id
519 if (!*argv) help_exit(0);
520 param = atolx(*argv);
521 add_string_to_rtattr(n, size, IFLA_VLAN_ID, ¶m, sizeof(param));
522 break;
523 case 1: // ARG_protocol
524 if (!*argv) error_exit("Invalid vlan id.");
525 if ((idx = substring_to_idx(*argv, vlan_protolist)) == -1) help_exit(0);
526 if (!idx) proto = ETH_P_8021Q; // PROTO_8021Q - 0
527 else if (idx == 1) proto = 0x88A8; // ETH Protocol - 8021AD
528 // IFLA VLAN PROTOCOL - 5
529 add_string_to_rtattr(n, size, 5, &proto, sizeof(proto));
530 break;
531 case 2: // ARG_reorder_hdr
532 case 3: // ARG_gvrp
533 if ((param = substring_to_idx(*argv, on_off)) == -1) help_exit(0);
534
535 flags.mask |= (idx -1); // VLAN FLAG REORDER Header
536 flags.flags &= ~(idx -1); // VLAN FLAG REORDER Header
537 if (!param) flags.flags |= (idx -1); // VLAN FLAG REORDER Header
538 break;
539 }
540 }
541 if (flags.mask)
542 add_string_to_rtattr(n, size, IFLA_VLAN_FLAGS, &flags, sizeof(flags));
543 }
544
linkupdate(char ** argv)545 static int linkupdate(char **argv)
546 {
547 struct {
548 struct nlmsghdr mhdr;
549 struct ifinfomsg info;
550 char buf[1024];
551 } request;
552 char *name, *dev, *type, *link, *addr;
553 struct rtattr *attr = NULL;
554 int len = 0, add = (*argv[-1] == 'a') ? 1 : 0;
555
556 name = dev = type = link = addr = NULL;
557 for (; *argv; argv++) {
558 struct arglist objectlist[] = { {"type", 0}, {"name", 1}, {"link", 2},
559 {"address", 3}, {NULL,-1}};
560 uint8_t idx = substring_to_idx(*argv, objectlist);
561
562 if (!idx) {
563 type = *++argv;
564 break;
565 }
566 else if (idx == 1) dev = name = *++argv;
567 else if (idx == 2) link = *++argv;
568 else if (idx == 3) addr = *++argv;
569 else if (!dev) name = dev = *argv;
570 }
571
572 if (!name && !add)
573 error_exit("Not enough information: \"dev\" argument is required.\n");
574 else if (!type && add)
575 error_exit("Not enough information: \"type\" argument is required.\n");
576
577 memset(&request, 0, sizeof(request));
578 request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
579 request.mhdr.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
580 if (add) {
581 request.mhdr.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
582 request.mhdr.nlmsg_type = RTM_NEWLINK;
583 } else {
584 request.mhdr.nlmsg_type = RTM_DELLINK;
585 request.info.ifi_index = get_ifaceindex(name, 1);
586 }
587 request.info.ifi_family = AF_UNSPEC;
588 attr = NLMSG_TAIL(&request.mhdr);
589 if (type) {
590 add_string_to_rtattr(&request.mhdr, sizeof(request),
591 IFLA_LINKINFO, NULL, 0);
592 add_string_to_rtattr(&request.mhdr, sizeof(request),
593 IFLA_INFO_KIND, type, strlen(type));
594 if (!strcmp(type, "vlan")) {
595 struct rtattr *data = NLMSG_TAIL(&request.mhdr);
596 add_string_to_rtattr(&request.mhdr, sizeof(request),
597 IFLA_INFO_DATA, NULL, 0);
598 vlan_parse_opt(++argv, &request.mhdr, sizeof(request));
599 data->rta_len = (void *)NLMSG_TAIL(&request.mhdr) - (void *)data;
600 }
601 attr->rta_len = (void *)NLMSG_TAIL(&request.mhdr) - (void *)attr;
602 }
603
604 if (link) {
605 uint32_t idx = get_ifaceindex(link, 1);
606 add_string_to_rtattr(&request.mhdr, sizeof(request),
607 IFLA_LINK, &idx, sizeof(uint32_t));
608 }
609 if (addr) {
610 char abuf[IF_NAMESIZE] = {0,};
611
612 fill_hwaddr(addr, IF_NAMESIZE, (unsigned char *)abuf);
613 add_string_to_rtattr(&request.mhdr, sizeof(request),
614 IFLA_ADDRESS, abuf, strlen(abuf));
615 }
616 if (!name) {
617 snprintf(toybuf, IFNAMSIZ, "%s%d", type, 0);
618 for (len = 1; ; len++) {
619 if (!get_ifaceindex(toybuf, 0)) break;
620 snprintf(toybuf, IFNAMSIZ, "%s%d", type, len);
621 }
622 name = toybuf;
623 }
624 len = strlen(name) + 1;
625 if (len < 2 || len > IFNAMSIZ) error_exit("Invalid device name.");
626 add_string_to_rtattr(&request.mhdr, sizeof(request), IFLA_IFNAME, name, len);
627
628 send_nlmesg(0, 0, 0, (void *)&request, request.mhdr.nlmsg_len);
629 return (filter_nlmesg(NULL,NULL));
630 }
631
link_set(char ** argv)632 static int link_set(char **argv)
633 {
634 struct arglist cmd_objectlist[] = {{"up", 0}, {"down", 1}, {"arp", 2},
635 {"multicast", 3}, {"dynamic", 4}, {"name", 5}, {"txqueuelen", 6},
636 {"mtu", 7},{"address", 8}, {"broadcast", 9}, {NULL,-1}};
637 int case_flags[] = {IFF_NOARP,IFF_MULTICAST,IFF_DYNAMIC};
638 struct ifreq req;
639 int idx, flags = 0, masks = 0xffff, fd;
640
641 memset(&req, 0, sizeof(req));
642 if (!*argv) error_exit("\"dev\" missing");
643 xstrncpy(req.ifr_name, *argv, IF_NAMESIZE);
644 fd = xsocket(AF_INET, SOCK_DGRAM, 0);
645 xioctl(fd, SIOCGIFINDEX, &req);
646 for (++argv; *argv;) {
647 if ((idx = substring_to_idx(*argv++, cmd_objectlist)) == -1) help_exit(0);
648 switch(idx) {
649 case 0:
650 flags |= IFF_UP; break;
651 case 1:
652 masks &= ~IFF_UP; break;
653 case 2:
654 case 3:
655 case 4:
656 if (!*argv) help_exit(0);
657 else if (!strcmp(*argv, "on")) {
658 if (idx == 2) {
659 masks &= ~case_flags[idx-2];
660 flags &= ~case_flags[idx-2];
661 } else flags |= case_flags[idx-2];
662 } else if (!strcmp(*argv,"off")) {
663 if (idx == 2) {
664 masks |= case_flags[idx-2];
665 flags |= case_flags[idx-2];
666 } else masks &= ~case_flags[idx-2];
667 } else help_exit(0);
668 ++argv;
669 break;
670 case 5:
671 xstrncpy(req.ifr_ifru.ifru_newname, *argv, IF_NAMESIZE);
672 xioctl(fd, SIOCSIFNAME, &req);
673 xstrncpy(req.ifr_name, *argv++, IF_NAMESIZE);
674 xioctl(fd, SIOCGIFINDEX, &req);
675 break;
676 case 6:
677 req.ifr_ifru.ifru_ivalue = atolx(*argv++);
678 xioctl(fd, SIOCSIFTXQLEN, &req);
679 break;
680 case 7:
681 req.ifr_ifru.ifru_mtu = atolx(*argv++);
682 xioctl(fd, SIOCSIFMTU, &req);
683 break;
684 case 8:
685 xioctl(fd, SIOCGIFHWADDR, &req);
686 fill_hwaddr(*argv++, IF_NAMESIZE,
687 (unsigned char *)(req.ifr_hwaddr.sa_data));
688 xioctl(fd, SIOCSIFHWADDR, &req);
689 break;
690 case 9:
691 xioctl(fd, SIOCGIFHWADDR, &req);
692 fill_hwaddr(*argv++, IF_NAMESIZE,
693 (unsigned char *)(req.ifr_hwaddr.sa_data));
694 xioctl(fd, SIOCSIFHWBROADCAST, &req);
695 break;
696 }
697 }
698 xioctl(fd, SIOCGIFFLAGS, &req);
699 req.ifr_ifru.ifru_flags |= flags;
700 req.ifr_ifru.ifru_flags &= masks;
701 xioctl(fd, SIOCSIFFLAGS, &req);
702 xclose(fd);
703 return 0;
704 }
705
print_stats(struct rtnl_link_stats * rtstat)706 static void print_stats(struct rtnl_link_stats *rtstat)
707 {
708 char *line_feed = (!TT.singleline ? "\n " : " ");
709
710 if (TT.stats > 0) {
711 xprintf(" RX: bytes packets errors "
712 "dropped overrun mcast%s%-10u %-8u %-7u %-8u %-8u %-8u\n",
713 line_feed, rtstat->rx_bytes, rtstat->rx_packets, rtstat->rx_errors,
714 rtstat->rx_dropped, rtstat->rx_over_errors, rtstat->multicast);
715 if (TT.stats > 1) {
716 xprintf(" RX: errors length crc "
717 "frame fifo missed%s%-10u %-8u %-7u %-8u %-8u %-8u\n",
718 line_feed, rtstat->rx_errors, rtstat->rx_length_errors,
719 rtstat->rx_crc_errors, rtstat->rx_frame_errors,
720 rtstat->rx_fifo_errors, rtstat->rx_missed_errors);
721 }
722 xprintf(" TX: bytes packets errors "
723 "dropped carrier collsns%s%-10u %-8u %-7u %-8u %-8u %-8u\n",
724 line_feed, rtstat->tx_bytes, rtstat->tx_packets, rtstat->tx_errors,
725 rtstat->tx_dropped, rtstat->tx_carrier_errors, rtstat->collisions);
726 if (TT.stats > 1) {
727 xprintf(" TX: errors aborted fifo window "
728 "heartbeat%s%-10u %-8u %-7u %-8u %-8u\n",
729 line_feed, rtstat->tx_errors, rtstat->tx_aborted_errors,
730 rtstat->tx_fifo_errors, rtstat->tx_window_errors,
731 rtstat->tx_heartbeat_errors);
732 }
733 }
734 }
735
print_link_output(struct linkdata * link)736 static int print_link_output(struct linkdata *link)
737 {
738 char *line_feed = " ", *flags,*peer = "brd";
739 struct arglist iface_flags[] = {{"",0},{"UP", IFF_UP},
740 {"BROADCAST", IFF_BROADCAST}, {"DEBUG", IFF_DEBUG},
741 {"LOOPBACK", IFF_LOOPBACK}, {"POINTOPOINT", IFF_POINTOPOINT},
742 {"NOTRAILERS", IFF_NOTRAILERS}, {"RUNNING", IFF_RUNNING},
743 {"NOARP", IFF_NOARP}, {"PROMISC",IFF_PROMISC},
744 {"ALLMULTI", IFF_ALLMULTI}, {"MASTER", IFF_MASTER}, {"SLAVE", IFF_SLAVE},
745 {"MULTICAST", IFF_MULTICAST}, {"PORTSEL", IFF_PORTSEL},
746 {"AUTOMEDIA", IFF_AUTOMEDIA}, {"DYNAMIC", IFF_DYNAMIC}, {NULL,-1}};
747
748 if (link->parent != -1) {
749 int fd = 0;
750 struct ifreq req;
751
752 memset(&req, 0, sizeof(req));
753 if_indextoname( link->parent,req.ifr_ifrn.ifrn_name);
754 fd = xsocket(AF_INET, SOCK_DGRAM, 0);
755 if (ioctl(fd, SIOCGIFTXQLEN, &req)) perror("");
756 else link->txqueuelen = req.ifr_ifru.ifru_ivalue;
757 xclose(fd);
758 }
759
760 if (TT.is_addr && addrinfo.label && fnmatch(addrinfo.label, link->iface, 0))
761 return 0;
762
763
764 if (!(flags = get_flag_string(iface_flags, link->flags, 1)))
765 error_exit("Invalid data.");
766 if (!TT.singleline) line_feed="\n ";
767 if (link->parent != -1) {
768 char iface[IF_NAMESIZE];
769
770 if (!if_indextoname(link->parent, iface)) perror_exit(NULL);
771 sprintf(toybuf,"%s@%s", link->iface, iface);
772 }
773 if (link->flags & IFF_POINTOPOINT) peer = "peer";
774 if (TT.is_addr && TT.singleline && TT.addressfamily)
775 xprintf("%d: %s", link->iface_idx,
776 ((link->parent == -1) ? link->iface : toybuf));
777 else xprintf("%d: %s: <%s> mtu %d qdisc %s state %s qlen %d",
778 link->iface_idx, ((link->parent == -1) ? link->iface : toybuf), flags,
779 link->mtu, link->qdiscpline, link->state, link->txqueuelen);
780
781 if (!TT.addressfamily || TT.addressfamily == AF_PACKET)
782 xprintf("%slink/%s %s %s %s",
783 line_feed, link->type, link->laddr, peer ,link->bcast);
784
785 xputc('\n');
786
787 //user can specify stats flag two times
788 //one for stats and other for erros e.g. -s and -s -s
789 print_stats(&link->rt_stat);
790 free(flags);
791
792 return 0;
793 }
794
fill_address(void * p,char * ip)795 static void fill_address(void *p, char *ip)
796 {
797 unsigned char *ptr = (unsigned char*)p;
798 snprintf(ip, 64, " %02x:%02x:%02x:%02x:%02x:%02x",
799 ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
800 }
801
get_link_info(struct nlmsghdr * h,struct linkdata * link,char ** argv)802 static int get_link_info(struct nlmsghdr* h,struct linkdata* link,char **argv)
803 {
804 struct ifinfomsg *iface = NLMSG_DATA(h);
805 struct rtattr *attr = IFLA_RTA(iface);
806 int len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*iface));
807 struct arglist hwtypes[]={{"generic",0},{"ether",ARPHRD_ETHER},
808 {"loopback", ARPHRD_LOOPBACK},{"sit",ARPHRD_SIT},
809 #ifdef ARPHRD_INFINIBAND
810 {"infiniband",ARPHRD_INFINIBAND},
811 #endif
812 #ifdef ARPHRD_IEEE802_TR
813 {"ieee802",ARPHRD_IEEE802}, {"tr",ARPHRD_IEEE802_TR},
814 #else
815 {"tr",ARPHRD_IEEE802},
816 #endif
817 #ifdef ARPHRD_IEEE80211
818 {"ieee802.11",ARPHRD_IEEE80211},
819 #endif
820 #ifdef ARPHRD_IEEE1394
821 {"ieee1394",ARPHRD_IEEE1394},
822 #endif
823 {"irda",ARPHRD_IRDA},{"slip",ARPHRD_SLIP},{"cslip",ARPHRD_CSLIP},
824 {"slip6",ARPHRD_SLIP6}, {"cslip6",ARPHRD_CSLIP6}, {"ppp",ARPHRD_PPP},
825 {"ipip",ARPHRD_TUNNEL}, {"tunnel6",ARPHRD_TUNNEL6},
826 {"gre",ARPHRD_IPGRE},
827 #ifdef ARPHRD_VOID
828 {"void",ARPHRD_VOID},
829 #endif
830 {NULL,-1}};
831 char *lname = get_flag_string(hwtypes, iface->ifi_type, 0);
832
833 link->next = link->prev = 0;
834 link->iface_type = iface->ifi_type;
835 if (!lname) error_exit("Invalid link.");
836 xstrncpy(link->type, lname, IFNAMSIZ);
837 free(lname);
838 link->iface_idx = iface->ifi_index;
839 link->flags = iface->ifi_flags;
840 if (*argv && !strcasecmp("up",*argv) && !(link->flags & IFF_UP)) return 1;
841 link->parent = -1;
842 for (; RTA_OK(attr, len); attr = RTA_NEXT(attr, len)) {
843 switch(attr->rta_type) {
844 case IFLA_IFNAME:
845 snprintf(link->iface, IFNAMSIZ, "%s",(char *) RTA_DATA(attr));
846 break;
847 case IFLA_ADDRESS:
848 if ( iface->ifi_type== ARPHRD_TUNNEL ||
849 iface->ifi_type == ARPHRD_SIT ||
850 iface->ifi_type == ARPHRD_IPGRE)
851 inet_ntop(AF_INET, RTA_DATA(attr), link->laddr, 64);
852 else fill_address(RTA_DATA(attr), link->laddr);
853 break;
854 case IFLA_BROADCAST:
855 if (iface->ifi_type== ARPHRD_TUNNEL ||
856 iface->ifi_type == ARPHRD_SIT ||
857 iface->ifi_type == ARPHRD_IPGRE)
858 inet_ntop(AF_INET, RTA_DATA(attr), link->bcast, 64);
859 else fill_address(RTA_DATA(attr), link->bcast);
860 break;
861 case IFLA_MTU:
862 link->mtu = *((int*)(RTA_DATA(attr)));
863 break;
864 case IFLA_QDISC:
865 snprintf(link->qdiscpline, IFNAMSIZ, "%s", (char *) RTA_DATA(attr));
866 break;
867 case IFLA_STATS :
868 link->rt_stat = *((struct rtnl_link_stats*) RTA_DATA(attr));
869 break;
870 case IFLA_LINK:
871 link->parent = *((int*)(RTA_DATA(attr)));
872 break;
873 case IFLA_TXQLEN:
874 link->txqueuelen = *((int*)(RTA_DATA(attr)));
875 break;
876 case IFLA_OPERSTATE:
877 {
878 struct arglist flags[]={{"UNKNOWN", 0}, {"NOTPRESENT", 1},
879 {"DOWN", 2}, {"LOWERLAYERDOWN", 3}, {"TESTING", 4},
880 {"DORMANT", 5}, {"UP", 6}, {NULL, -1}};
881 if (!(lname = get_flag_string(flags, *((int*)(RTA_DATA(attr))), 0)))
882 error_exit("Invalid state.");
883 xstrncpy(link->state, lname,IFNAMSIZ);
884 free(lname);
885 }
886 break;
887 default: break;
888 }
889 }
890 return 0;
891 }
892
display_link_info(struct nlmsghdr * mhdr,char ** argv)893 static int display_link_info(struct nlmsghdr *mhdr, char **argv)
894 {
895 struct linkdata link;
896
897 if (!get_link_info(mhdr, &link, argv)) {
898 if (TT.is_addr) {
899 struct linkdata *lnk = xzalloc(sizeof(struct linkdata));
900 memcpy(lnk, &link, sizeof(struct linkdata));
901 dlist_add_nomalloc((struct double_list **)&linfo,
902 (struct double_list *)lnk);
903 }
904 else print_link_output(&link);
905 }
906 return 0;
907 }
908
link_show(char ** argv)909 static int link_show(char **argv)
910 {
911 struct {
912 struct nlmsghdr mhdr;
913 struct ifinfomsg info;
914 } request;
915 uint32_t index = 0;
916
917 if (*argv && strcasecmp("up",*argv)) index = get_ifaceindex(*argv, 1);
918 memset(&request, 0, sizeof(request));
919 request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
920 request.mhdr.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
921 if (!index) request.mhdr.nlmsg_flags |= NLM_F_ROOT|NLM_F_MATCH;
922 else request.info.ifi_change = 0xffffffff; // used in single operation
923 request.mhdr.nlmsg_type = RTM_GETLINK;
924 request.info.ifi_index = index;
925 request.info.ifi_family = AF_UNSPEC;
926 send_nlmesg(0, 0, 0, (void*)&request, sizeof(request));
927 return (filter_nlmesg(display_link_info, argv));
928 }
929
iplink(char ** argv)930 static int iplink(char **argv)
931 {
932 int idx;
933 cmdobj ipcmd, cmdobjlist[] = {linkupdate, link_set, link_show};
934 struct arglist cmd_objectlist[] = {{"add", 0}, {"delete", 0},
935 {"set", 1}, {"show", 2}, {"list", 2}, {"lst", 2}, {NULL,-1}};
936
937 if (!*argv) idx = 2;
938 else if ((idx = substring_to_idx(*argv++, cmd_objectlist)) == -1)
939 help_exit(0);
940 ipcmd = cmdobjlist[idx];
941 return ipcmd(argv);
942 }
943
944 // ===========================================================================
945 // Code for ip addr.
946 // ===========================================================================
947
print_addrinfo(struct nlmsghdr * h,int flag_l)948 static int print_addrinfo(struct nlmsghdr *h, int flag_l)
949 {
950 struct rtattr *rta, *rta_tb[IFA_MAX+1] = {0,};
951 char *family = toybuf, *scope = toybuf+256, *label = toybuf+512,
952 *brd = toybuf+768, *peer = toybuf+1024, *any = toybuf+1280,
953 lbuf[INET6_ADDRSTRLEN] = {0,}, lbuf_ifa[INET6_ADDRSTRLEN] = {0,};
954 struct ifaddrmsg *ifa = NLMSG_DATA(h);
955 int len;
956
957 if ((len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa))) < 0) {
958 error_msg("wrong nlmsg len %d", len);
959 return 0;
960 }
961
962 for (rta = IFA_RTA(ifa); RTA_OK(rta, len); rta=RTA_NEXT(rta, len))
963 if (rta->rta_type <= IFA_MAX) rta_tb[rta->rta_type] = rta;
964
965 if (!rta_tb[IFA_LOCAL]) rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];
966 if (!rta_tb[IFA_ADDRESS]) rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL];
967 if ((addrinfo.scope ^ ifa->ifa_scope)&addrinfo.scopemask) return 0;
968 if (addrinfo.ifindex && addrinfo.ifindex != ifa->ifa_index) return 0;
969
970 if (flag_l && addrinfo.label && ifa->ifa_family == AF_INET6) return 0;
971 if ((rta_tb[IFA_LABEL])) {
972 xstrncpy(label, RTA_DATA(rta_tb[IFA_LABEL]), 256);
973 label[255] = '\0';
974 if (addrinfo.label && fnmatch(addrinfo.label, label, 0))
975 return 0;
976 }
977
978 if (TT.flush) {
979 if (ifa->ifa_index == addrinfo.ifindex) {
980 h->nlmsg_type = RTM_DELADDR;
981 h->nlmsg_flags = NLM_F_REQUEST;
982 send_nlmesg(RTM_DELADDR, 0, 0, h, h->nlmsg_len);
983 return 0;
984 }
985 }
986
987 if (h->nlmsg_type == RTM_DELADDR) printf("Deleted ");
988
989 if (TT.singleline) {
990 if (!if_indextoname(ifa->ifa_index, lbuf)) perror_exit(NULL);
991 printf("%u: %s",ifa->ifa_index, lbuf);
992 }
993
994 sprintf(scope, " scope %s ", namefromRPDB(ifa->ifa_scope, RPDB_rtscopes));
995
996 if (ifa->ifa_family == AF_INET) strcpy(family, " inet ");
997 else if (ifa->ifa_family == AF_INET6) strcpy(family, " inet6 ");
998 else sprintf(family, " family %d", ifa->ifa_family);
999
1000 if (rta_tb[IFA_LOCAL]) {
1001 if (!inet_ntop(ifa->ifa_family, RTA_DATA(rta_tb[IFA_LOCAL]),
1002 lbuf, sizeof(lbuf))) perror_exit("inet");
1003
1004 sprintf(family+strlen(family), lbuf, strlen(lbuf));
1005 if (!rta_tb[IFA_ADDRESS] || !memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]),
1006 RTA_DATA(rta_tb[IFA_LOCAL]), 4))
1007 sprintf(family+strlen(family), "/%d ", ifa->ifa_prefixlen);
1008 else {
1009 if (!inet_ntop(ifa->ifa_family, RTA_DATA(rta_tb[IFA_ADDRESS]),
1010 lbuf_ifa, sizeof(lbuf_ifa))) perror_exit("inet");
1011 sprintf(peer, " peer %s/%d ", lbuf_ifa, ifa->ifa_prefixlen);
1012 }
1013 }
1014
1015 if (addrinfo.to && strcmp(addrinfo.addr, lbuf))
1016 return 0;
1017
1018 if (rta_tb[IFA_BROADCAST]) {
1019 if (!inet_ntop(ifa->ifa_family, RTA_DATA(rta_tb[IFA_BROADCAST]),
1020 lbuf, sizeof(lbuf))) perror_exit("inet");
1021 sprintf(brd, " brd %s", lbuf);
1022 }else brd = "";
1023
1024 if (rta_tb[IFA_ANYCAST]) {
1025 if (!inet_ntop(ifa->ifa_family, RTA_DATA(rta_tb[IFA_ANYCAST]),
1026 lbuf, sizeof(lbuf))) perror_exit("inet");
1027 sprintf(any, " any %s", lbuf);
1028 }
1029
1030 if (ifa->ifa_family == AF_INET)
1031 printf("%s%s%s%s%s %c", family, brd, peer, scope, label,
1032 (TT.singleline? '\0' : '\n'));
1033 else printf("%s%s %c", family, scope, (TT.singleline? '\0' : '\n'));
1034 if (TT.singleline && (ifa->ifa_family == AF_INET)) xputc('\n');
1035
1036 if (rta_tb[IFA_CACHEINFO]) {
1037 struct ifa_cacheinfo *ci = RTA_DATA(rta_tb[IFA_CACHEINFO]);
1038
1039 printf("%c valid_lft ", (TT.singleline? '\\' : '\0'));
1040 if (ci->ifa_valid == 0xFFFFFFFFU) printf("forever");
1041 else printf("%usec", ci->ifa_valid);
1042 printf(" preferred_lft ");
1043 if (ci->ifa_prefered == 0xFFFFFFFFU) printf("forever");
1044 else printf("%dsec", ci->ifa_prefered);
1045 xputc('\n');
1046 }
1047 return 0;
1048 }
1049
ipaddrupdate(char ** argv)1050 static int ipaddrupdate(char **argv)
1051 {
1052 int length, cmd = !memcmp("add", argv[-1], strlen(argv[-1]))
1053 ? RTM_NEWADDR: RTM_DELADDR;
1054 int idx = 0,length_brd = 0, length_peer = 0,length_any = 0,length_local = 0,
1055 scoped = 0;
1056 char *dev = NULL,*label = NULL, reply[8192];
1057
1058 struct nlmsghdr *addr_ptr = NULL;
1059 struct nlmsgerr *err = NULL;
1060 struct arglist cmd_objectlist[] = {{"dev",0}, {"peer", 1},
1061 {"remote", 2}, {"broadcast", 3}, {"brd", 4}, {"label", 5},
1062 {"anycast", 6},{"scope", 7}, {"local", 8}, {NULL, -1}};
1063 struct {
1064 struct nlmsghdr nlm;
1065 struct ifaddrmsg ifadd;
1066 char buf[256];
1067 } req;
1068 typedef struct {
1069 int family, bytelen, bitlen;
1070 __u32 data[8];
1071 } option_data;
1072 option_data local;
1073
1074 memset(&req, 0, sizeof(req));
1075 req.nlm.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
1076 req.nlm.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
1077 req.nlm.nlmsg_type = cmd;
1078 req.ifadd.ifa_family = TT.addressfamily;
1079
1080 while (*argv) {
1081 idx = substring_to_idx(*argv, cmd_objectlist);
1082 if (idx >= 0)
1083 if (!*++argv)
1084 error_exit("Incomplete Command line");
1085 switch(idx) {
1086 case 0:
1087 dev = *argv;
1088 break;
1089 case 1:
1090 case 2:
1091 {
1092 uint32_t addr[4] = {0,}, netmask = 0;
1093 uint8_t len = 0;
1094 parse_prefix(addr, &netmask, &len, *argv,
1095 req.ifadd.ifa_family);
1096 if (len)
1097 req.ifadd.ifa_family = ((len == 4) ? AF_INET : AF_INET6);
1098 length_peer = len;
1099 add_string_to_rtattr(&req.nlm, sizeof(req),
1100 IFA_ADDRESS, addr, len);
1101 req.ifadd.ifa_prefixlen = netmask;
1102 }
1103 break;
1104 case 3:
1105 case 4:
1106 if (*argv[0] == '+') {
1107 length_brd = -1;
1108 } else if (*argv[0] == '-') {
1109 length_brd = -2;
1110 } else {
1111 uint32_t addr[4] = {0,};
1112 uint8_t af = AF_UNSPEC;
1113
1114 if (get_prefix(addr, &af, *argv, req.ifadd.ifa_family))
1115 error_exit("Invalid prefix");
1116
1117 length_brd = ((af == AF_INET6) ? 16 : 4);
1118 if (req.ifadd.ifa_family == AF_UNSPEC)
1119 req.ifadd.ifa_family = af;
1120 add_string_to_rtattr(&req.nlm, sizeof(req),
1121 IFA_BROADCAST, &addr, length_brd);
1122 }
1123 break;
1124 case 5:
1125 label = *argv;
1126 add_string_to_rtattr(&req.nlm, sizeof(req),
1127 IFA_LABEL, label, strlen(label) + 1);
1128 break;
1129 case 6:
1130 {
1131 uint32_t addr[4] = {0,};
1132 uint8_t af = AF_UNSPEC;
1133
1134 if (get_prefix(addr, &af, *argv, req.ifadd.ifa_family))
1135 error_exit("Invalid prefix");
1136 length_any = ((af == AF_INET6) ? 16 : 4);
1137 if (req.ifadd.ifa_family == AF_UNSPEC)
1138 req.ifadd.ifa_family = af;
1139 add_string_to_rtattr(&req.nlm, sizeof(req),
1140 IFA_ANYCAST, &addr, length_any);
1141 }
1142 break;
1143 case 7:
1144 {
1145 int scope = idxfromRPDB(*argv, RPDB_rtscopes);
1146 if (scope < 0) error_exit("wrong scope '%s'", *argv);
1147 req.ifadd.ifa_scope = scope;
1148 scoped = 1;
1149 }
1150 break;
1151 default:
1152 {
1153 //local is by default
1154 uint32_t addr[8] = {0,}, netmask = 0;
1155 uint8_t len = 0;
1156
1157 parse_prefix(addr, &netmask, &len, *argv,
1158 req.ifadd.ifa_family);
1159 if (len)
1160 req.ifadd.ifa_family = ((len == 4) ? AF_INET : AF_INET6);
1161 length_local = len;
1162 local.bitlen = netmask;
1163 local.bytelen = len;
1164 memcpy(local.data, addr, sizeof(local.data));
1165 local.family = req.ifadd.ifa_family;
1166 add_string_to_rtattr(&req.nlm, sizeof(req),
1167 IFA_LOCAL, &local.data, local.bytelen);
1168 }
1169 break;
1170 }
1171 argv++;
1172 }
1173 if (!dev) error_exit("need \"dev \" argument");
1174 if (label && strncmp(dev, label, strlen(dev)) != 0)
1175 error_exit("\"dev\" (%s) must match \"label\" (%s)", dev, label);
1176
1177 if (length_peer == 0 && length_local && cmd != RTM_DELADDR){
1178 add_string_to_rtattr(&req.nlm, sizeof(req),
1179 IFA_ADDRESS, &local.data, local.bytelen);
1180 }
1181
1182 if (length_brd < 0 && cmd != RTM_DELADDR){
1183 int i;
1184
1185 if (req.ifadd.ifa_family != AF_INET)
1186 error_exit("broadcast can be set only for IPv4 addresses");
1187
1188 if (local.bitlen <= 30) {
1189 for (i = 31; i >= local.bitlen; i--) {
1190 if (length_brd == -1)
1191 local.data[0] |= htonl(1<<(31-i));
1192 else
1193 local.data[0] &= ~htonl(1<<(31-i));
1194 }
1195 add_string_to_rtattr(&req.nlm, sizeof(req),
1196 IFA_BROADCAST, &local.data, local.bytelen);
1197 length_brd = local.bytelen;
1198 }
1199 }
1200 if (req.ifadd.ifa_prefixlen == 0)
1201 req.ifadd.ifa_prefixlen = local.bitlen;
1202 if (!scoped && (cmd != RTM_DELADDR) && (local.family == AF_INET)
1203 && (local.bytelen >= 1 && *(uint8_t*)&local.data == 127))
1204 req.ifadd.ifa_scope = RT_SCOPE_HOST;
1205 req.ifadd.ifa_index = get_ifaceindex(dev, 1);
1206
1207 send_nlmesg(RTM_NEWADDR, 0, AF_UNSPEC, (void *)&req, req.nlm.nlmsg_len);
1208 length = recv(TT.sockfd, reply, sizeof(reply), 0);
1209 addr_ptr = (struct nlmsghdr *) reply;
1210 for (; NLMSG_OK(addr_ptr, length); addr_ptr = NLMSG_NEXT(addr_ptr, length)) {
1211 if (addr_ptr->nlmsg_type == NLMSG_DONE)
1212 return 1;
1213 if (addr_ptr->nlmsg_type == NLMSG_ERROR)
1214 err = (struct nlmsgerr*) NLMSG_DATA(addr_ptr);
1215 if (err && err->error) {
1216 errno = -err->error;
1217 perror_exit("RTNETLINK answers:");
1218 }
1219 }
1220 return 0;
1221 }
1222
ipaddr_listflush(char ** argv)1223 static int ipaddr_listflush(char **argv)
1224 {
1225 int idx; uint32_t netmask = 0, found = 0;
1226 char *tmp = NULL, *name = NULL;
1227 struct double_list *dlist;
1228 struct arglist cmd_objectlist[] = {{"to", 0}, {"scope", 1}, {"up", 2},
1229 {"label", 3}, {"dev", 4}, {NULL, -1}};
1230
1231 TT.flush = *argv[-1] == 'f' ? 1 : 0;
1232 memset(&addrinfo, 0, sizeof(addrinfo));
1233
1234 if (TT.flush) {
1235 if (!*argv)
1236 error_exit("Incomplete command for \"flush\"");
1237 if (TT.addressfamily == AF_PACKET)
1238 error_exit("Can't flush link Addressess");
1239 }
1240 addrinfo.scope = -1;
1241 while (*argv) {
1242 switch (idx = substring_to_idx(*argv, cmd_objectlist)) {
1243 case 0:
1244 {// ADDR_TO
1245 if (!*++argv) error_exit("Incomplete Command line");
1246 else if (!strcmp(*argv, "0")) return 0;
1247 uint32_t addr[4] = {0,};
1248 uint8_t len = 0;
1249
1250 addrinfo.to = 1;
1251 parse_prefix(addr, &netmask, &len, *argv, TT.addressfamily);
1252 if (len)
1253 TT.addressfamily = ((len == 4) ? AF_INET : AF_INET6);
1254 addrinfo.addr = strtok(*argv, "/");
1255 }
1256 break;
1257 case 1: // ADDR_SCOPE
1258 {
1259 int scope = 0;
1260 if (!*++argv) error_exit("Incomplete Command line");
1261 name = *argv;
1262
1263 addrinfo.scopemask = -1;
1264 if (isdigit(**argv)) {
1265 int idx = atolx(*argv);
1266
1267 name = xstrdup(namefromRPDB(idx, RPDB_rtscopes));
1268 }
1269 if ((scope = idxfromRPDB(name, RPDB_rtscopes)) < 0) {
1270 if (strcmp(name, "all"))
1271 error_exit("wrong scope '%s'", name);
1272 scope = RT_SCOPE_NOWHERE;
1273 addrinfo.scopemask = 0;
1274 }
1275
1276 if (isdigit(**argv))
1277 free(name);
1278 addrinfo.scope = scope;
1279 }
1280 break;
1281 case 2: // ADDR_UP
1282 addrinfo.up = 1;
1283 break;
1284 case 3: // ADDR_LABEL
1285 if (!*++argv) error_exit("Incomplete Command line");
1286 addrinfo.label = *argv;
1287 break;
1288 case 4: // ADDR_DEV
1289 if (!*++argv) error_exit("Incomplete Command line");
1290
1291 default:
1292 if (TT.filter_dev)
1293 error_exit("Either \"dev\" is duplicate or %s is garbage",
1294 *argv);
1295 TT.filter_dev = *argv;
1296 break;
1297 }
1298 argv++;
1299 }
1300
1301 link_show(&tmp);
1302 while ( linfo && (dlist = dlist_pop(&linfo))){
1303 struct linkdata *tmp = (struct linkdata*) dlist;
1304 char *temp = &tmp->iface[0];
1305
1306 if (TT.filter_dev && strcmp(TT.filter_dev, temp))
1307 continue;
1308 found = 1;
1309 if (TT.flush && addrinfo.label) ipaddr_print( tmp, 0);
1310 if (addrinfo.up && !(tmp->flags & IFF_UP)){
1311 ipaddr_print(tmp, 0);
1312 continue;
1313 }
1314 if (addrinfo.label){
1315 if ( fnmatch(addrinfo.label, temp, 0)) {
1316 ipaddr_print(tmp, 1);
1317 continue;
1318 }
1319 }
1320 if (!TT.addressfamily && ! TT.flush ) print_link_output(tmp);
1321
1322 ipaddr_print(tmp, 0);
1323 free(tmp);
1324 }
1325 if (TT.filter_dev && !found)
1326 error_exit("Device \"%s\" doesn't exist. \n", TT.filter_dev);
1327 return 0;
1328 }
1329
ipaddr_print(struct linkdata * link,int flag_l)1330 static int ipaddr_print( struct linkdata *link, int flag_l)
1331 {
1332 struct nlmsghdr *addr_ptr;
1333 int ip_match = 0;
1334
1335 addrinfo.ifindex = link->iface_idx;
1336 send_nlmesg(RTM_GETADDR, NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST,
1337 AF_UNSPEC, NULL, 0);
1338 if (TT.addressfamily == AF_PACKET) print_link_output(link);
1339
1340 if (addrinfo.label){
1341 char *col = strchr(addrinfo.label, ':');
1342 if (!col && (fnmatch(addrinfo.label, &link->iface[0], 0)))
1343 return 0;
1344 }
1345
1346 while (1){
1347 int len = recv(TT.sockfd, TT.gbuf, sizeof(TT.gbuf), 0);
1348 addr_ptr = (struct nlmsghdr *)TT.gbuf;
1349 struct ifaddrmsg *addressInfo = NLMSG_DATA(addr_ptr);
1350 char lbuf[INET6_ADDRSTRLEN];
1351 struct rtattr *rta, *rta_tb[IFA_MAX+1] = {0,};
1352
1353 int len1 = addr_ptr->nlmsg_len - NLMSG_LENGTH(sizeof(*addressInfo));
1354 if (len1 > 0) {
1355 for (; NLMSG_OK(addr_ptr, len); addr_ptr = NLMSG_NEXT(addr_ptr, len)) {
1356 addressInfo = NLMSG_DATA(addr_ptr);
1357 if (TT.addressfamily && TT.addressfamily != addressInfo->ifa_family)
1358 continue;
1359 if (addrinfo.ifindex && addrinfo.ifindex != addressInfo->ifa_index)
1360 continue;
1361
1362 if (addrinfo.to) {
1363 memset(rta_tb, 0, sizeof(rta_tb));
1364 int rt_len = IFA_PAYLOAD(addr_ptr);
1365 for (rta = IFA_RTA(addressInfo); RTA_OK(rta, rt_len); rta=RTA_NEXT(rta, rt_len)) {
1366 if (rta->rta_type <= IFA_MAX) rta_tb[rta->rta_type] = rta;
1367 }
1368 if (!rta_tb[IFA_LOCAL]) rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];
1369 if (rta_tb[IFA_LOCAL]) {
1370 if (!inet_ntop(TT.addressfamily, RTA_DATA(rta_tb[IFA_LOCAL]),
1371 lbuf, sizeof(lbuf))) perror_exit("inet");
1372 if (strcmp(addrinfo.addr, lbuf))
1373 continue;
1374 ip_match=1;
1375 }
1376 if (!ip_match)
1377 continue;
1378 }
1379
1380 if (!TT.flush){
1381 if (addrinfo.scope != -1 && TT.addressfamily && TT.addressfamily ==
1382 addressInfo->ifa_family &&
1383 (addrinfo.ifindex == addressInfo->ifa_index)) {
1384 if ((addrinfo.scope ^ addressInfo->ifa_scope) & addrinfo.scopemask)
1385 continue;
1386 else if (addrinfo.up && (link->flags & IFF_UP))
1387 print_link_output(link);
1388 else if (!addrinfo.up) print_link_output(link);
1389 }
1390 if (TT.addressfamily &&
1391 (addrinfo.ifindex == addressInfo->ifa_index) &&
1392 (addrinfo.scope == -1)){
1393 if (addrinfo.up && (link->flags & IFF_UP))
1394 print_link_output(link);
1395 else if (!addrinfo.up) print_link_output(link);
1396 }
1397 }
1398
1399 for (; NLMSG_OK(addr_ptr, len); addr_ptr = NLMSG_NEXT(addr_ptr, len)) {
1400 if ((addr_ptr->nlmsg_type == RTM_NEWADDR))
1401 print_addrinfo(addr_ptr, flag_l);
1402 if ((addr_ptr->nlmsg_type == NLMSG_DONE) ||
1403 (addr_ptr->nlmsg_type == NLMSG_ERROR) ||
1404 (TT.flush && addrinfo.to))
1405 goto ret_stop;
1406 }
1407 if ((addr_ptr->nlmsg_type == NLMSG_DONE) ||
1408 (addr_ptr->nlmsg_type == NLMSG_ERROR))
1409 break;
1410 }
1411 }
1412 else
1413 return 0;
1414 }
1415
1416 ret_stop:
1417 return 0;
1418 }
1419
ipaddr(char ** argv)1420 static int ipaddr(char **argv)
1421 {
1422 int idx;
1423 cmdobj ipcmd, cmdobjlist[] = {ipaddrupdate, ipaddr_listflush};
1424 struct arglist cmd_objectlist[] = { {"add", 0}, {"delete", 0},
1425 {"list", 1},{"show", 1},{"lst", 1}, {"flush", 1}, {NULL,-1}};
1426
1427 TT.is_addr++;
1428 if (!*argv) idx = 1;
1429 else if ((idx = substring_to_idx(*argv++, cmd_objectlist)) == -1)
1430 help_exit(0);
1431
1432 ipcmd = cmdobjlist[idx];
1433 return ipcmd(argv);
1434 }
1435
1436 // ===========================================================================
1437 // code for ip route
1438 // ===========================================================================
1439 struct I_data {
1440 unsigned char family;
1441 uint32_t addr[8] , netmask ;
1442 uint8_t len ;
1443 };
1444
1445 struct {
1446 int tb,idev,odev,proto;
1447 struct I_data rvia, rdst, mdst, rsrc, msrc;
1448 } gfilter;
1449
show_iproute_help(void)1450 static void show_iproute_help(void)
1451 {
1452 char *errmsg = "\n\n" \
1453 "iproute { list | flush } SELECTOR\n" \
1454 "iproute get ADDRESS [from ADDRESS iif STRING]\n" \
1455 " [oif STRING]\n" \
1456 "iproute { add | del | change | append | replace | test } ROUTE\n" \
1457 " SELECTOR := [root PREFIX] [match PREFIX] [proto RTPROTO]\n" \
1458 " ROUTE := [TYPE] PREFIX [proto RTPROTO] [metric METRIC]";
1459
1460 error_exit(errmsg);
1461 }
1462
display_route_info(struct nlmsghdr * mhdr,char ** argv)1463 static int display_route_info(struct nlmsghdr *mhdr, char **argv)
1464 {
1465 char *inetval = NULL, out[1024] = {0};
1466 struct rtmsg *msg = NLMSG_DATA(mhdr);
1467 struct rtattr *rta, *attr[RTA_MAX+1] = {0,};
1468 int32_t tvar, msglen = mhdr->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
1469 int hlen = ((msg->rtm_family == AF_INET) ? 32
1470 : ((msg->rtm_family == AF_INET6) ? 128 : -1));
1471
1472 if (mhdr->nlmsg_type != RTM_NEWROUTE) return 0;
1473 if (msglen < 0) return 1;
1474
1475 if (msg->rtm_family == AF_INET6) {
1476 if (gfilter.tb) {
1477 if (gfilter.tb < 0) {
1478 if (!(msg->rtm_flags & RTM_F_CLONED)) return 0;
1479 } else {
1480 if (msg->rtm_flags & RTM_F_CLONED) return 0;
1481 if (gfilter.tb == RT_TABLE_LOCAL && msg->rtm_type != RTN_LOCAL)
1482 return 0;
1483 else if (gfilter.tb == RT_TABLE_MAIN && msg->rtm_type == RTN_LOCAL)
1484 return 0;
1485 }
1486 }
1487 }
1488 else if (gfilter.tb > 0 && gfilter.tb != msg->rtm_table) return 0;
1489
1490 if (gfilter.proto && (msg->rtm_protocol != gfilter.proto)) return 0;
1491
1492
1493 if (gfilter.rdst.family && (msg->rtm_family != gfilter.rdst.family ||
1494 gfilter.rdst.netmask > msg->rtm_dst_len)) return 0;
1495 if (gfilter.mdst.family && (msg->rtm_family != gfilter.mdst.family
1496 || (gfilter.mdst.netmask < msg->rtm_dst_len))) return 0;
1497 if (gfilter.rsrc.family && (msg->rtm_family != gfilter.rsrc.family
1498 || gfilter.rsrc.netmask > msg->rtm_src_len)) return 0;
1499 if (gfilter.msrc.family && (msg->rtm_family != gfilter.msrc.family
1500 || (gfilter.msrc.netmask < msg->rtm_src_len))) return 0;
1501 tvar = msglen;
1502
1503 for (rta = RTM_RTA(msg); RTA_OK(rta, tvar); rta=RTA_NEXT(rta, tvar))
1504 if (rta->rta_type <= RTA_MAX) attr[rta->rta_type] = rta;
1505
1506 if (msg->rtm_type != RTN_UNICAST)
1507 sprintf(out,"%s%s ", out,rtmtype_idx2str(msg->rtm_type));
1508 if (attr[RTA_DST]) {
1509 inetval = (char *)inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_DST]),
1510 toybuf, sizeof(toybuf));
1511 if (gfilter.rdst.family &&
1512 memcmp(RTA_DATA(attr[RTA_DST]), &gfilter.rdst.addr, gfilter.rdst.len))
1513 return 0;
1514 if (gfilter.mdst.family &&
1515 memcmp(RTA_DATA(attr[RTA_DST]), &gfilter.mdst.addr, gfilter.mdst.len))
1516 return 0;
1517 sprintf(out,"%s%s",out,inetval);
1518 }
1519 if (msg->rtm_dst_len) sprintf(out,"%s/%d ", out,msg->rtm_dst_len);
1520 else sprintf(out,"%s%s",out,"default ");
1521
1522 if (attr[RTA_SRC]) {
1523 inetval = (char *)inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_SRC]),
1524 toybuf, sizeof(toybuf));
1525 if (gfilter.rsrc.family &&
1526 memcmp(RTA_DATA(attr[RTA_SRC]), &gfilter.rsrc.addr, gfilter.rsrc.len))
1527 return 0;
1528 if (gfilter.msrc.family &&
1529 memcmp(RTA_DATA(attr[RTA_SRC]), &gfilter.msrc.addr, gfilter.msrc.len))
1530 return 0;
1531 sprintf(out, "%s from %s", out, inetval);
1532 }
1533 if (msg->rtm_src_len) sprintf(out, "%s/%d ", out, msg->rtm_src_len);
1534
1535 if (attr[RTA_GATEWAY]) {
1536 inetval = (char *)inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_GATEWAY]),
1537 toybuf, sizeof(toybuf));
1538 sprintf(out, "%s via %s ", out, inetval);
1539 }
1540 if (gfilter.rvia.family) {
1541 char tmp[256];
1542
1543 if (!attr[RTA_GATEWAY]) return 0;
1544 if (strcmp((char *)inet_ntop(msg->rtm_family, gfilter.rvia.addr,
1545 tmp, sizeof(tmp)), inetval)) return 0;
1546 }
1547
1548 if (gfilter.odev != 0) if (!attr[RTA_OIF]) return 0;
1549 if (attr[RTA_OIF]) {
1550 if (gfilter.odev !=0 && gfilter.odev != *(int*)RTA_DATA(attr[RTA_OIF]))
1551 return 0;
1552 sprintf(out, "%s dev %s ", out,
1553 if_indextoname(*(int*)RTA_DATA(attr[RTA_OIF]), toybuf));
1554 }
1555
1556 if (attr[RTA_PREFSRC] && hlen) {
1557 inetval = (char *)inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_PREFSRC]),
1558 toybuf, sizeof(toybuf));
1559 sprintf(out, "%s src %s ", out, inetval);
1560 }
1561 if (attr[RTA_PRIORITY])
1562 sprintf(out, "%s metric %d ", out, *(uint32_t*)RTA_DATA(attr[RTA_PRIORITY]));
1563 if (msg->rtm_family == AF_INET6) {
1564 struct rta_cacheinfo *ci = NULL;
1565 if (attr[RTA_CACHEINFO]) ci = RTA_DATA(attr[RTA_CACHEINFO]);
1566 if ((msg->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
1567 if (msg->rtm_flags & RTM_F_CLONED) sprintf(out, "%s%s cache ",
1568 out, (!TT.singleline ? "\n" : " "));
1569 if (ci && ci->rta_expires) {
1570 int hz = 0;
1571 FILE *fp = xfopen("/proc/net/psched","r");
1572
1573 if (fp) {
1574 unsigned int nom, denom;
1575
1576 if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
1577 if (nom == 1000000)
1578 hz = denom;
1579 fclose(fp);
1580 }
1581 if (!hz) hz = sysconf(_SC_CLK_TCK);
1582 sprintf(out, "%s expires %dsec", out, ci->rta_expires /hz);
1583 }
1584 if (ci && ci->rta_error) sprintf(out, "%s error %d", out, ci->rta_error);
1585 }
1586 else if (ci && ci->rta_error)
1587 sprintf(out, "%s error %d", out, ci->rta_error);
1588 }
1589 if (attr[RTA_IIF] && !gfilter.idev)
1590 sprintf(out, "%s iif %s", out,
1591 if_indextoname(*(int*)RTA_DATA(attr[RTA_IIF]), toybuf));
1592 if (TT.flush || (TT.connected && !TT.from_ok))
1593 memcpy(toybuf, (void*)mhdr,mhdr->nlmsg_len);
1594
1595 if (TT.flush) {
1596 int sockfd = 0;
1597 struct nlmsghdr* mhdr = (struct nlmsghdr*)toybuf;
1598 struct rtmsg *msg = NLMSG_DATA(mhdr);
1599 int tvar, msglen = mhdr->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
1600 struct rtattr *rta, *attr[RTA_MAX+1] = {0,};
1601
1602 tvar = msglen;
1603 for (rta = RTM_RTA(msg); RTA_OK(rta, tvar); rta=RTA_NEXT(rta, tvar))
1604 if (rta->rta_type <= RTA_MAX) attr[rta->rta_type] = rta;
1605
1606 if (msg->rtm_family == AF_INET6
1607 && !msg->rtm_dst_len
1608 && msg->rtm_type == RTN_UNREACHABLE
1609 && attr[RTA_PRIORITY]
1610 && *(int*)RTA_DATA(attr[RTA_PRIORITY]) == -1)
1611 return 0;
1612
1613 mhdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1614 mhdr->nlmsg_type = RTM_DELROUTE;
1615 mhdr->nlmsg_pid = 0;
1616 sockfd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1617 if (send(sockfd , (void*)mhdr, mhdr->nlmsg_len, 0) < 0)
1618 perror_exit("Unable to send data on socket.");
1619
1620 while (1) {
1621 struct nlmsghdr *mhdr;
1622 int msglen = recv(sockfd, toybuf, sizeof(toybuf), 0);
1623
1624 if ((msglen < 0) && (errno == EINTR || errno == EAGAIN)) continue;
1625 else if (msglen < 0) {
1626 error_msg("netlink receive error %s", strerror(errno));
1627 xclose(sockfd);
1628 return 1;
1629 } else if (!msglen) {
1630 error_msg("EOF on netlink");
1631 xclose(sockfd);
1632 return 1;
1633 }
1634
1635 for (mhdr = (struct nlmsghdr*)toybuf; NLMSG_OK(mhdr, msglen);
1636 mhdr = NLMSG_NEXT(mhdr, msglen)) {
1637 switch (mhdr->nlmsg_type) {
1638 case NLMSG_DONE:
1639 xclose(sockfd);
1640 return 0;
1641 case NLMSG_ERROR:
1642 {
1643 struct nlmsgerr *merr = (struct nlmsgerr*)NLMSG_DATA(mhdr);
1644
1645 if (merr->error == 0) { xclose(sockfd); return 0; }
1646 if (mhdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
1647 error_msg("ERROR truncated");
1648 else {
1649 errno = -merr->error;
1650 perror_msg("RTNETLINK answers");
1651 }
1652 xclose(sockfd);
1653 return 1;
1654 }
1655 default:
1656 break;
1657 }
1658 } // End of for loop.
1659 } // End of while loop.
1660
1661 xclose(sockfd);
1662 } else printf("%s\n",out);
1663 return 0;
1664 }
1665
route_get(char ** argv)1666 static int route_get(char **argv)
1667 {
1668 int idx, flag;
1669 struct arglist cmd_objectlist[] = {{"from", 0}, {"iif", 1}, {"oif", 2},
1670 {"dev", 3}, {"notify", 4}, {"connected", 5}, {"to", 6}, {NULL, -1}};
1671 char *idev = NULL, *odev = NULL;
1672 struct {
1673 struct nlmsghdr mhdr;
1674 struct rtmsg msg;
1675 char buf[1024];
1676 } request;
1677
1678 memset(&request, 0, sizeof(request));
1679 request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
1680 request.mhdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1681 request.mhdr.nlmsg_type = RTM_GETROUTE;
1682 request.msg.rtm_family = AF_UNSPEC;
1683
1684 for (; *argv; argv++) {
1685 switch(idx = substring_to_idx(*argv, cmd_objectlist)) {
1686 case 0: TT.from_ok = 1; // dst address
1687 case 6: argv++; //fallthrough
1688 default:
1689 {
1690 uint32_t addr[8] = {0,}, netmask = 0;
1691 uint8_t len = 0;
1692
1693 if (!*argv) error_exit("'%s': Missing Prefix", argv[-1]);
1694 parse_prefix(addr, &netmask, &len, *argv, request.msg.rtm_family);
1695 if (len) request.msg.rtm_family = ((len == 4) ? AF_INET : AF_INET6);
1696 netmask = (request.msg.rtm_family == AF_INET6) ? 128 : 32;
1697 if (!idx) request.msg.rtm_src_len = netmask;
1698 else request.msg.rtm_dst_len = netmask;
1699 add_string_to_rtattr(&request.mhdr, sizeof(request),
1700 (!idx ? RTA_SRC : RTA_DST), addr, len);
1701 break;
1702 }
1703 case 1:
1704 case 2:
1705 case 3:
1706 if (!*++argv) show_iproute_help();
1707 if (idx == 1) idev = *argv, flag = RTA_IIF;
1708 else odev = *argv, flag = RTA_OIF;
1709 idx = get_ifaceindex(*argv, 1);
1710 add_string_to_rtattr(&request.mhdr, sizeof(request),
1711 flag, (char*)&idx, sizeof(idx));
1712 break;
1713 case 4:
1714 request.msg.rtm_flags |= RTM_F_NOTIFY;
1715 break;
1716 case 5:
1717 TT.connected = 1;
1718 break;
1719 }
1720 }
1721 if (!request.msg.rtm_dst_len)
1722 error_exit("need at least destination address");
1723
1724 send_nlmesg(0, 0, 0, &request, sizeof(request));
1725 filter_nlmesg(display_route_info, NULL);
1726
1727 if (TT.connected && !TT.from_ok) {
1728 struct nlmsghdr *mhdr = (struct nlmsghdr*)toybuf;
1729 struct rtmsg *msg = NLMSG_DATA(mhdr);
1730 int tvar, msglen = mhdr->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
1731 struct rtattr *rta, *attr[RTA_MAX+1] = {0,};
1732
1733 if (mhdr->nlmsg_type != RTM_NEWROUTE) error_exit("not a route?");
1734 if (msglen < 0) error_exit("wrong len %d", msglen);
1735
1736 tvar = msglen;
1737 for (rta = RTM_RTA(msg); RTA_OK(rta, tvar); rta=RTA_NEXT(rta, tvar))
1738 if (rta->rta_type <= RTA_MAX) attr[rta->rta_type] = rta;
1739
1740 if (attr[RTA_PREFSRC]) {
1741 attr[RTA_PREFSRC]->rta_type = RTA_SRC;
1742 msg->rtm_src_len = 8*RTA_PAYLOAD(attr[RTA_PREFSRC]);
1743 } else if (!attr[RTA_SRC]) error_exit("can't connect the route");
1744
1745 if (!odev && attr[RTA_OIF]) attr[RTA_OIF]->rta_type = 0;
1746 if (attr[RTA_GATEWAY]) attr[RTA_GATEWAY]->rta_type = 0;
1747 if (!idev && attr[RTA_IIF]) attr[RTA_IIF]->rta_type = 0;
1748 mhdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
1749 mhdr->nlmsg_type = RTM_GETROUTE;
1750 mhdr->nlmsg_pid = 0;
1751 xclose(TT.sockfd);
1752 TT.sockfd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1753 send_nlmesg(0, 0, 0, mhdr, mhdr->nlmsg_len);
1754 filter_nlmesg(display_route_info, NULL);
1755 }
1756 return 0;
1757 }
1758
route_show_flush(char ** argv)1759 static int route_show_flush(char **argv)
1760 {
1761 struct arglist cmd_objectlist[] = {{"protocol", 0}, {"dev", 1}, {"oif", 2},
1762 {"iif", 3}, {"via", 4}, {"table", 5}, {"cache", 6}, {"from", 7},
1763 {"to", 8}, {"all", 9}, {"root", 10}, {"match", 11}, {"exact", 12},
1764 {"main", 13}, {NULL,-1}};
1765 int family = TT.addressfamily, idx;
1766 struct {
1767 struct nlmsghdr mhdr;
1768 struct rtmsg msg;
1769 } request;
1770
1771 if (*argv[-1] == 'f') TT.flush = 1;
1772 if (TT.flush && !*argv) show_iproute_help();
1773
1774 gfilter.tb = RT_TABLE_MAIN;
1775 for (; *argv; argv++) {
1776 switch (idx = substring_to_idx(*argv, cmd_objectlist)) {
1777 case 0:
1778 if (!*++argv) show_iproute_help();
1779 if ((idx = idxfromRPDB(*argv,RPDB_rtprotos)) < 0)
1780 error_exit("Invalid argument protocol.");
1781 gfilter.proto = idx;
1782 break;
1783 case 1:
1784 case 2:
1785 case 3:
1786 {
1787 if (!*++argv) show_iproute_help();
1788 int dev = get_ifaceindex(*argv, 1);
1789
1790 if (idx == 3) gfilter.idev = dev;
1791 else gfilter.odev = dev;
1792 }
1793 break;
1794 case 4:
1795 if (!*++argv) show_iproute_help();
1796 parse_prefix(gfilter.rvia.addr, &gfilter.rvia.netmask,
1797 &gfilter.rvia.len, *argv, gfilter.rvia.family);
1798 if (gfilter.rvia.len)
1799 gfilter.rvia.family = ((gfilter.rvia.len == 4) ?
1800 AF_INET : AF_INET6);
1801 break;
1802 case 5:
1803 if (!*++argv) show_iproute_help();
1804 idx = substring_to_idx(*argv, cmd_objectlist);
1805 if (idx == 6) gfilter.tb = -1;
1806 else if (idx == 9) gfilter.tb = 0;
1807 else if (idx != 13) {
1808 if ((gfilter.tb = idxfromRPDB(*argv, RPDB_rttables)) < 0)
1809 error_exit("table %s is invalid.", *argv);
1810 }
1811 break;
1812 case 6:
1813 gfilter.tb = -1;
1814 break;
1815 case 7:
1816 if (!*++argv) show_iproute_help();
1817 idx = substring_to_idx(*argv, cmd_objectlist);
1818 if (idx < 0) if (!*++argv) show_iproute_help();
1819 if (idx == 10)
1820 if (!*++argv) show_iproute_help();
1821 parse_prefix(gfilter.rsrc.addr, &gfilter.rsrc.netmask,
1822 &gfilter.rsrc.len, *argv, gfilter.rsrc.family);
1823 if (gfilter.rsrc.len)
1824 gfilter.rsrc.family = ((gfilter.rsrc.len == 4) ?
1825 AF_INET : AF_INET6);
1826 else {
1827 if ((idx == 12 ||idx == 11) && !*++argv) show_iproute_help();
1828 parse_prefix(gfilter.msrc.addr, &gfilter.msrc.netmask,
1829 &gfilter.msrc.len, *argv, gfilter.msrc.family);
1830 if (gfilter.msrc.len)
1831 gfilter.msrc.family = ((gfilter.msrc.len == 4) ?
1832 AF_INET : AF_INET6);
1833 if (idx != 11) gfilter.rsrc = gfilter.msrc;
1834 }
1835 break;
1836 case 8:
1837 idx = substring_to_idx(*argv, cmd_objectlist);
1838 if (idx != -1 && !*++argv) show_iproute_help();
1839 default: // fallthrough
1840 if (idx == 10) {
1841 if (!*++argv) show_iproute_help();
1842 parse_prefix(gfilter.rdst.addr, &gfilter.rdst.netmask,
1843 &gfilter.rdst.len, *argv, gfilter.rdst.family);
1844 if (gfilter.rdst.len)
1845 gfilter.rdst.family = ((gfilter.rdst.len == 4) ?
1846 AF_INET : AF_INET6);
1847 }
1848 else {
1849 if ((idx == 12 ||idx == 11) && !*++argv) show_iproute_help();
1850 parse_prefix(gfilter.mdst.addr, &gfilter.mdst.netmask,
1851 &gfilter.mdst.len, *argv, gfilter.mdst.family);
1852 if (gfilter.mdst.len)
1853 gfilter.mdst.family = ((gfilter.mdst.len == 4) ?
1854 AF_INET : AF_INET6);
1855 if (idx != 11) gfilter.rdst = gfilter.mdst;
1856 }
1857 break;
1858 }
1859 }
1860 if (family == AF_UNSPEC && gfilter.tb) family = AF_INET;
1861
1862 if (TT.flush) {
1863 if (gfilter.tb < 0) { // flush table cache
1864 if (family != AF_INET6) {
1865 FILE *fp = xfopen("/proc/sys/net/ipv4/route/flush", "w");
1866
1867 if (fwrite("-1",1,2,fp) < 2) error_exit("can't flush routing cache");
1868 fclose(fp);
1869 }
1870 if (family == AF_INET) return 0;
1871 }
1872 }
1873
1874 memset(&request, 0, sizeof (request));
1875 request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof (struct rtmsg));
1876 request.mhdr.nlmsg_flags = NLM_F_REQUEST;
1877 request.mhdr.nlmsg_flags |= NLM_F_ROOT | NLM_F_MATCH;
1878 request.mhdr.nlmsg_type = RTM_GETROUTE;
1879 request.msg.rtm_family = family;
1880 if (gfilter.tb < 0) request.msg.rtm_flags = RTM_F_CLONED;
1881 send_nlmesg(0, 0, 0, (void*)&request, sizeof (request));
1882 return (filter_nlmesg(display_route_info, NULL));
1883 }
1884
route_update(char ** argv,unsigned int route_flags)1885 static int route_update(char **argv, unsigned int route_flags)
1886 {
1887 char mxbuf[256], *d = NULL;
1888 struct rtattr *mxrta = (void*)mxbuf;
1889 unsigned mxlock = 0, ok = 0;
1890 int idx;
1891 uint32_t addr[8] = {0,}, netmask = 0;
1892 uint8_t len = 0;
1893
1894 struct arglist cmd_objectlist[] = {{"src", 0}, {"via", 1}, {"mtu", 2},
1895 {"lock", 3}, {"protocol", 4}, {"table", 5}, {"dev", 6}, {"oif", 7},
1896 {"to", 8}, {"metric", 9}, {NULL,-1}
1897 };
1898 enum {
1899 gtwy_ok = 1,
1900 dst_ok = 2,
1901 proto_ok = 4,
1902 type_ok = 8
1903 };
1904 struct {
1905 struct nlmsghdr hdr;
1906 struct rtmsg msg;
1907 char buf[1024];
1908 } req;
1909
1910 memset(&req, 0, sizeof(req));
1911 req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
1912 req.hdr.nlmsg_flags = NLM_F_ACK| NLM_F_REQUEST | route_flags;
1913 req.hdr.nlmsg_type = TT.route_cmd;
1914 req.msg.rtm_family = AF_UNSPEC;
1915 req.msg.rtm_table = RT_TABLE_MAIN;
1916 req.msg.rtm_scope = RT_SCOPE_NOWHERE;
1917
1918 if (TT.route_cmd != RTM_DELROUTE) {
1919 req.msg.rtm_protocol = RTPROT_BOOT;
1920 req.msg.rtm_scope = RT_SCOPE_UNIVERSE;
1921 req.msg.rtm_type = RTN_UNICAST;
1922 }
1923
1924 mxrta->rta_type = RTA_METRICS;
1925 mxrta->rta_len = RTA_LENGTH(0);
1926
1927 for (; *argv; argv++) {
1928 idx = substring_to_idx(*argv, cmd_objectlist);
1929 if (!idx) {
1930 if (!*++argv) show_iproute_help();
1931 parse_prefix(addr, &netmask, &len, *argv, req.msg.rtm_family);
1932 if (len) req.msg.rtm_family = ((len == 4) ? AF_INET : AF_INET6);
1933 add_string_to_rtattr(&req.hdr, sizeof(req), RTA_PREFSRC, addr, len);
1934 } else if (idx == 1) {
1935 ok |= gtwy_ok;
1936 if (!*++argv) show_iproute_help();
1937 parse_prefix(addr, &netmask, &len, *argv, req.msg.rtm_family);
1938 if (len) req.msg.rtm_family = ((len == 4) ? AF_INET : AF_INET6);
1939 add_string_to_rtattr(&req.hdr, sizeof(req),RTA_GATEWAY, addr, len);
1940 } else if (idx == 2) {
1941 if (!*++argv) show_iproute_help();
1942 if (substring_to_idx(*argv, cmd_objectlist ) == 3) {
1943 mxlock |= (1 << RTAX_MTU);
1944 if (!*++argv) show_iproute_help();
1945 }
1946 idx = atolx(*argv);
1947 add_string_to_rtattr(&req.hdr, sizeof(req),
1948 RTAX_MTU, (char*)&idx, sizeof(idx));
1949 } else if (idx == 4) {
1950 if (!*++argv) show_iproute_help();
1951 if ((idx = idxfromRPDB(*argv,RPDB_rtprotos)) < 0)
1952 error_exit("Invalid argument protocol %s.",*argv);
1953 req.msg.rtm_protocol = idx;
1954 ok |= proto_ok;
1955 } else if (idx == 5) {
1956 if (!*++argv) show_iproute_help();
1957 req.msg.rtm_table = idxfromRPDB(*argv, RPDB_rttables);
1958 } else if (idx == 6 || idx == 7) {
1959 if (!*++argv) show_iproute_help();
1960 d = *argv;
1961 } else if (idx == 9) {
1962 unsigned long metric;
1963 unsigned int res;
1964 char* ptr;
1965 if (!*++argv) show_iproute_help();
1966 metric = strtoul(*argv, &ptr, 0);
1967 if (!(!*ptr && metric <= 0xFFFFFFFFUL))
1968 error_exit("Invalid argument metric %s.",*argv);
1969 else
1970 res = metric;
1971 add_string_to_rtattr(&req.hdr, sizeof(req),
1972 RTA_PRIORITY, (char*)&res, sizeof(res));
1973 } else {
1974 if (idx == 8)
1975 if (!*++argv) show_iproute_help();
1976 idx = substring_to_idx(*argv,rtmtypes);
1977 if (idx != -1) {
1978 if (!*++argv) show_iproute_help();
1979 req.msg.rtm_type = idx;
1980 ok |= type_ok;
1981 }
1982 if (ok & dst_ok) error_exit("Duplicate argument 'to'");
1983 parse_prefix(addr, &netmask, &len, *argv, req.msg.rtm_family);
1984 if (len) req.msg.rtm_family = ((len == 4) ? AF_INET : AF_INET6);
1985 req.msg.rtm_dst_len = netmask;
1986 ok |= dst_ok;
1987 if (len) add_string_to_rtattr(&req.hdr, sizeof(req),RTA_DST, addr, len);
1988 }
1989 }
1990
1991 if (d) {
1992 idx = get_ifaceindex(d,1);
1993 add_string_to_rtattr(&req.hdr, sizeof(req),
1994 RTA_OIF, (char*)&idx, sizeof(idx));
1995 }
1996 if (mxrta->rta_len > RTA_LENGTH(0)) {
1997 if (mxlock)
1998 add_string_to_rtattr(&req.hdr, sizeof(req),
1999 RTAX_LOCK, (char*)&mxlock, sizeof(mxlock));
2000 add_string_to_rtattr(&req.hdr, sizeof(req),
2001 RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
2002 }
2003
2004 if (req.msg.rtm_type == RTN_LOCAL || req.msg.rtm_type == RTN_NAT)
2005 req.msg.rtm_scope = RT_SCOPE_HOST;
2006 else if (req.msg.rtm_type == RTN_BROADCAST||req.msg.rtm_type == RTN_MULTICAST
2007 || req.msg.rtm_type == RTN_ANYCAST)
2008 req.msg.rtm_scope = RT_SCOPE_LINK;
2009 else if (req.msg.rtm_type == RTN_UNICAST || req.msg.rtm_type == RTN_UNSPEC) {
2010 if (TT.route_cmd == RTM_DELROUTE)
2011 req.msg.rtm_scope = RT_SCOPE_NOWHERE;
2012 else if (!(ok & gtwy_ok))
2013 req.msg.rtm_scope = RT_SCOPE_LINK;
2014 }
2015 if (req.msg.rtm_family == AF_UNSPEC) req.msg.rtm_family = AF_INET;
2016 send_nlmesg(0, 0, 0, &req, sizeof(req));
2017 filter_nlmesg(NULL, NULL);
2018 return 0;
2019 }
2020
iproute(char ** argv)2021 static int iproute(char **argv)
2022 {
2023 int idx = 1;
2024 struct arglist cmd_objectlist1[] = {{"add", 0}, {"append", 1},{"change", 2},
2025 {"chg", 3},{"delete",4}, {"get", 5}, {"list", 6}, {"show", 7},
2026 {"prepend", 8},{"replace", 9},{"test", 10}, {"flush", 11},{NULL,-1}};
2027
2028 TT.route_cmd = RTM_NEWROUTE;
2029 switch (idx = substring_to_idx(*argv , cmd_objectlist1)) {
2030 case 0: // add
2031 return route_update(++argv , NLM_F_CREATE|NLM_F_EXCL);
2032 case 1: // append
2033 return route_update(++argv , NLM_F_CREATE|NLM_F_APPEND);
2034 case 2: // change
2035 case 3: // chg
2036 return route_update(++argv , NLM_F_REPLACE);
2037 case 4: // delete
2038 TT.route_cmd = RTM_DELROUTE;
2039 return route_update(++argv , RTM_DELROUTE);
2040 case 5:
2041 return route_get(++argv);
2042 case 6:
2043 case 7:
2044 return route_show_flush(++argv);
2045 case 8: // prepend
2046 return route_update(++argv , NLM_F_CREATE);
2047 case 9: // replace
2048 return route_update(++argv , NLM_F_CREATE|NLM_F_REPLACE);
2049 case 10: // test
2050 return route_update(++argv , NLM_F_EXCL);
2051 case 11: // flush
2052 return route_show_flush(++argv);
2053 default:
2054 if (!*argv) return route_show_flush(argv);
2055 else show_iproute_help();
2056 }
2057 return 0; // non reachable code.
2058 }
2059
2060
2061 // ===========================================================================
2062 // code for ip rule.
2063 // ===========================================================================
show_iprule_help(void)2064 static void show_iprule_help(void)
2065 {
2066 char *errmsg = "Usage: ip rule [ list | add | del ] SELECTOR ACTION\n"
2067 "SELECTOR := [ from PREFIX ] [ to PREFIX ] [pref NUMBER] [ tos TOS ]\n"
2068 " [ fwmark FWMARK] [ dev/iif STRING ] [type TYPE]\n"
2069 "ACTION := [ table TABLE_ID ] [ realms [SRCREALM/]DSTREALM ]";
2070
2071 error_exit(errmsg);
2072 }
2073
ruleupdate(char ** argv)2074 static int ruleupdate(char **argv)
2075 {
2076 int8_t idx, tflag = 0, opt = (*argv[-1] == 'a') ? RTM_NEWRULE : RTM_DELRULE;
2077 struct arglist options[] = {{"from", 0}, {"to", 1}, {"preference", 2},
2078 {"order", 2}, {"priority", 2}, {"tos", 3}, {"dsfield", 3}, {"fwmark", 4},
2079 {"realms", 5}, {"table", 6}, {"lookup", 6}, {"dev", 7}, {"iif", 7},
2080 {"nat", 8}, {"map-to", 8}, {"type", 9}, {"help", 10}, {NULL, -1}};
2081 struct {
2082 struct nlmsghdr mhdr;
2083 struct rtmsg msg;
2084 char buf[1024];
2085 } request;
2086
2087 memset(&request, 0, sizeof(request));
2088 request.mhdr.nlmsg_type = opt;
2089 request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
2090 request.mhdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK |
2091 ((opt == RTM_DELRULE) ? 0 : NLM_F_CREATE | NLM_F_EXCL);
2092 request.msg.rtm_family = TT.addressfamily;
2093 request.msg.rtm_protocol = RTPROT_BOOT;
2094 request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
2095 request.msg.rtm_table = 0;
2096 request.msg.rtm_type = ((opt == RTM_DELRULE) ? RTN_UNSPEC : RTN_UNICAST);
2097
2098 for (; *argv; argv++) {
2099 switch ((idx = substring_to_idx(*argv, options))) {
2100 case 0:
2101 case 1:
2102 { // e.g. from IP/Netmask and to IP/Netmask.
2103 uint32_t addr[4] = {0,}, netmask = 0;
2104 uint8_t len = 0, *tmp;
2105
2106 if (!*++argv) error_exit("'%s': Missing Prefix", argv[-1]);
2107 parse_prefix(addr, &netmask, &len, *argv, request.msg.rtm_family);
2108
2109 tmp = idx ? &request.msg.rtm_dst_len : &request.msg.rtm_src_len;
2110 if (!netmask) *tmp = 0;
2111 else *tmp = netmask;
2112
2113 add_string_to_rtattr(&request.mhdr, sizeof(request),
2114 (idx ? RTA_DST : RTA_SRC), addr, len);
2115 }
2116 break;
2117 case 2:
2118 case 4:
2119 { // e.g. Preference p# and fwmark MARK
2120 uint32_t pref;
2121 char *ptr;
2122
2123 if (!*++argv)
2124 error_exit("Missing %s", (idx == 2) ? "Preference" : "fwmark");
2125 pref = strtoul(*argv, &ptr, 0);
2126 if (!ptr || (ptr == *argv) || *ptr || pref > 0xFFFFFFFFUL)
2127 error_exit("Invalid %s", (idx == 2) ? "Preference" : "fwmark");
2128 add_string_to_rtattr(&request.mhdr, sizeof(request),
2129 ((idx == 2) ? RTA_PRIORITY : RTA_PROTOINFO),
2130 (void *)&pref, sizeof(uint32_t));
2131 }
2132 break;
2133 case 3:
2134 {
2135 uint32_t tos;
2136 if (!*++argv) error_exit("Missing TOS key");
2137 if ((tos = idxfromRPDB(*argv, RPDB_rtdsfield)) < 0)
2138 error_exit("Invalid TOS");
2139 request.msg.rtm_tos = tos;
2140 }
2141 break;
2142 case 5:
2143 { // e.g. realms FROM_realm/TO_realm
2144 uint32_t realms = 0;
2145 int ret;
2146 char *ptr;
2147
2148 if (!*++argv) error_exit("Missing REALMSID");
2149 if ((ptr = strchr(*argv, '/'))) {
2150 *ptr = 0;
2151 if ((ret = idxfromRPDB(*argv, RPDB_rtrealms)) < 0)
2152 error_exit("Invalid realms");
2153 realms = ret;
2154 realms <<= 16;
2155 *ptr++ = '/';
2156 } else ptr = *argv;
2157 if ((ret = idxfromRPDB(ptr, RPDB_rtrealms)) < 0)
2158 error_exit("Invalid realms");
2159 realms |= ret;
2160 add_string_to_rtattr(&request.mhdr, sizeof(request),
2161 RTA_FLOW, (void *)&realms, sizeof(uint32_t));
2162 }
2163 break;
2164 case 6:
2165 { // e.g. table tid/tableName
2166 int tid;
2167 if (!*++argv) error_exit("Missing TableID");
2168 if ((tid = idxfromRPDB(*argv, RPDB_rttables)) < 0)
2169 error_exit("Invalid TID");
2170 request.msg.rtm_table = tid;
2171 tflag = 1;
2172 }
2173 break;
2174 case 7:
2175 {
2176 if (!*++argv) error_exit("Missing dev/iif NAME");
2177 add_string_to_rtattr(&request.mhdr, sizeof(request),
2178 RTA_IIF, *argv, strlen(*argv)+1);
2179 }
2180 break;
2181 case 8:
2182 {
2183 uint32_t addr[4] = {0,};
2184 uint8_t af = AF_UNSPEC;
2185
2186 if (!*++argv) error_exit("Missing nat/map-to ADDRESS");
2187 if (get_prefix(addr, &af /* Un-used variable */, *argv, AF_INET))
2188 error_exit("Invalid mapping Address");
2189
2190 add_string_to_rtattr(&request.mhdr, sizeof(request),
2191 RTA_GATEWAY, addr, sizeof(uint32_t));
2192 request.msg.rtm_type = RTN_NAT;
2193 }
2194 break;
2195 case 9:
2196 {
2197 if (!*++argv) error_exit("TYPE Missing");
2198 request.msg.rtm_type = rtmtype_str2idx(*argv);
2199 }
2200 break;
2201 case 10:
2202 show_iprule_help();
2203 break; // Unreachable code.
2204 default:
2205 error_exit("Invalid argument '%s'", *argv);
2206 break; // Unreachable code.
2207 }
2208 }
2209
2210 if (!request.msg.rtm_family) request.msg.rtm_family = AF_INET;
2211 if (!tflag && opt == RTM_NEWRULE) request.msg.rtm_table = RT_TABLE_MAIN;
2212
2213 send_nlmesg(0, 0, 0, &request, sizeof(request));
2214 return (filter_nlmesg(NULL, NULL));
2215 }
2216
show_rules(struct nlmsghdr * mhdr,char ** argv)2217 static int show_rules(struct nlmsghdr *mhdr,
2218 char **argv __attribute__ ((__unused__)))
2219 {
2220 struct rtmsg *msg = NLMSG_DATA(mhdr);
2221 struct rtattr *rta, *attr[RTA_MAX+1] = {0,};
2222 int32_t tvar, msglen = mhdr->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
2223 int hlen = ((msg->rtm_family == AF_INET) ? 32
2224 : ((msg->rtm_family == AF_INET6) ? 128 : -1));
2225
2226 if (mhdr->nlmsg_type != RTM_NEWRULE) return 0;
2227 if (msglen < 0) return 1;
2228
2229 tvar = msglen;
2230 for (rta = RTM_RTA(msg); RTA_OK(rta, tvar); rta=RTA_NEXT(rta, tvar))
2231 if (rta->rta_type <= RTA_MAX) attr[rta->rta_type] = rta;
2232
2233 if (tvar) error_msg("deficit %d, rtalen = %d!", tvar, rta->rta_len);
2234
2235 printf("%u:\tfrom ", attr[RTA_PRIORITY] ?
2236 *(unsigned *)RTA_DATA(attr[RTA_PRIORITY]) : 0);
2237
2238 if (attr[RTA_SRC]) {
2239 printf("%s", (msg->rtm_family == AF_INET || msg->rtm_family == AF_INET6)
2240 ? inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_SRC]),
2241 toybuf, sizeof(toybuf))
2242 : "???");
2243 (msg->rtm_src_len != hlen) ? printf("/%u", msg->rtm_src_len) : 0;
2244 } else msg->rtm_src_len ? printf("0/%d", msg->rtm_src_len) : printf("all");
2245
2246 xputc(' ');
2247 if (attr[RTA_DST]) {
2248 printf("to %s", (msg->rtm_family == AF_INET || msg->rtm_family == AF_INET6)
2249 ? inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_DST]),
2250 toybuf, sizeof(toybuf)) : "???");
2251 (msg->rtm_dst_len != hlen) ? printf("/%u", msg->rtm_dst_len) : xputc(' ');
2252 } else if (msg->rtm_dst_len)
2253 printf("to 0/%d ", msg->rtm_dst_len);
2254
2255 if (msg->rtm_tos)
2256 printf("tos %s ", namefromRPDB(msg->rtm_tos, RPDB_rtdsfield));
2257
2258 if (attr[RTA_PROTOINFO])
2259 printf("fwmark %#x ", *(uint32_t*)RTA_DATA(attr[RTA_PROTOINFO]));
2260
2261 if (attr[RTA_IIF]) printf("iif %s ", (char*)RTA_DATA(attr[RTA_IIF]));
2262
2263 if (msg->rtm_table)
2264 printf("lookup %s ", namefromRPDB(msg->rtm_table, RPDB_rttables));
2265
2266 if (attr[RTA_FLOW]) {
2267 u_int32_t from, to = *(u_int32_t *)RTA_DATA(attr[RTA_FLOW]);
2268 char *format = "realms %s/";
2269
2270 to = (from = (to >> 16)) & 0xFFFF;
2271 format = (from ? format: "%s");
2272 printf(format, namefromRPDB((from ? from : to), RPDB_rtrealms));
2273 }
2274
2275 if (msg->rtm_type == RTN_NAT) {
2276 if (!attr[RTA_GATEWAY]) printf("masquerade");
2277 else printf("map-to %s ", inet_ntop(msg->rtm_family,
2278 RTA_DATA(attr[RTA_GATEWAY]), toybuf, sizeof(toybuf)));
2279 } else if (msg->rtm_type != RTN_UNICAST)
2280 printf("%s", rtmtype_idx2str(msg->rtm_type));
2281
2282 xputc('\n');
2283 return 0;
2284 }
2285
rulelist(char ** argv)2286 static int rulelist(char **argv)
2287 {
2288 if (*argv) {
2289 error_msg("'ip rule show' does not take any arguments.");
2290 return 1;
2291 }
2292 send_nlmesg(RTM_GETRULE, NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST,
2293 ((TT.addressfamily != AF_UNSPEC) ? TT.addressfamily : AF_INET), NULL, 0);
2294 return filter_nlmesg(show_rules, argv);
2295 }
2296
iprule(char ** argv)2297 static int iprule(char **argv)
2298 {
2299 int idx;
2300 struct arglist options[] = {{"add", 0}, {"delete", 0}, {"list", 1},
2301 {"show", 1}, {NULL, -1}};
2302 cmdobj ipcmd, cmdobjlist[] = {ruleupdate, rulelist};
2303
2304 if (!*argv) idx = 1;
2305 else if ((idx = substring_to_idx(*argv++, options)) == -1)
2306 show_iprule_help();
2307 ipcmd = cmdobjlist[idx];
2308 return ipcmd(argv);
2309 }
2310 //============================================================================
2311 // code for ip tunnel.
2312 //============================================================================
show_iptunnel_help(void)2313 static void show_iptunnel_help(void)
2314 {
2315 char *errmsg = "Usage: iptunnel { add | change | del | show } [NAME]\n"
2316 " [mode { ipip | gre | sit }] [remote ADDR] [local ADDR]\n"
2317 " [[i|o]seq] [[i|o]key KEY] [[i|o]csum] [ttl TTL]\n"
2318 " [tos TOS] [[no]pmtudisc] [dev PHYS_DEV]";
2319
2320 error_exit(errmsg);
2321 }
2322
tnl_ioctl(char * dev,int rtype,struct ip_tunnel_parm * ptnl)2323 static int tnl_ioctl(char *dev, int rtype, struct ip_tunnel_parm *ptnl)
2324 {
2325 struct ifreq req;
2326 int fd, ret = 0;
2327
2328 if ((rtype == SIOCCHGTUNNEL || rtype == SIOCDELTUNNEL) && *ptnl->name)
2329 xstrncpy(req.ifr_name, ptnl->name, IF_NAMESIZE);
2330 else xstrncpy(req.ifr_name, dev, IF_NAMESIZE);
2331
2332 if (rtype != SIOCGIFHWADDR) req.ifr_ifru.ifru_data = (void*)ptnl;
2333 fd = xsocket(AF_INET, SOCK_DGRAM, 0);
2334
2335 if (rtype == SIOCGETTUNNEL) ret = ioctl(fd, rtype, &req);
2336 else if (rtype == SIOCGIFHWADDR)
2337 ret = (ioctl(fd, rtype, &req) < 0) ? -1 : req.ifr_addr.sa_family;
2338 else xioctl(fd, rtype, &req);
2339
2340 close(fd);
2341 return ret;
2342 }
2343
display_tunnel(struct ip_tunnel_parm * ptnl)2344 static int display_tunnel(struct ip_tunnel_parm *ptnl)
2345 {
2346 char rmt_addr[64], lcl_addr[64], ikey_str[64], okey_str[64];
2347
2348 printf("%s: %s/ip", ptnl->name, ptnl->iph.protocol == IPPROTO_IPIP ? "ip" :
2349 (ptnl->iph.protocol == IPPROTO_GRE ? "gre" :
2350 (ptnl->iph.protocol == IPPROTO_IPV6 ? "ipv6" : "unknown")));
2351 printf(" remote %s local %s ", ptnl->iph.daddr ?
2352 inet_ntop(AF_INET, &ptnl->iph.daddr, rmt_addr, sizeof(rmt_addr)) : "any",
2353 ptnl->iph.saddr ? inet_ntop(AF_INET, &ptnl->iph.saddr, lcl_addr,
2354 sizeof(lcl_addr)) : "any");
2355 if (ptnl->link) {
2356 struct ifreq req;
2357 int fd;
2358
2359 req.ifr_ifindex = ptnl->link;
2360 fd = xsocket(AF_INET, SOCK_DGRAM, 0);
2361 if (ioctl(fd, SIOCGIFNAME, &req) < 0) perror_msg("SIOCGIFNAME");
2362 else printf(" dev %s ", req.ifr_name);
2363 close(fd);
2364 }
2365 if (ptnl->iph.ttl) printf(" ttl %d ", ptnl->iph.ttl);
2366 else printf(" ttl inherit ");
2367
2368 if (ptnl->iph.tos) {
2369 printf(" tos");
2370 if (ptnl->iph.tos & 1) printf(" inherit");
2371 if (ptnl->iph.tos & ~1) printf("%c%s ", ptnl->iph.tos & 1 ? '/' : ' ',
2372 namefromRPDB((ptnl->iph.tos & ~1), RPDB_rtdsfield));
2373 }
2374 if (!(ptnl->iph.frag_off & htons(IP_DF))) printf(" nopmtudisc");
2375 inet_ntop(AF_INET, &ptnl->i_key, ikey_str, sizeof(ikey_str));
2376 if ((ptnl->i_flags & GRE_KEY) && (ptnl->o_flags & GRE_KEY)
2377 && ptnl->o_key == ptnl->i_key) printf(" key %s", ikey_str);
2378 else if ((ptnl->i_flags | ptnl->o_flags) & GRE_KEY) {
2379 inet_ntop(AF_INET, &ptnl->o_key, okey_str, sizeof(okey_str));
2380 if (ptnl->i_flags & GRE_KEY) printf(" ikey %s ", ikey_str);
2381 if (ptnl->o_flags & GRE_KEY) printf(" okey %s ", okey_str);
2382 }
2383 if (ptnl->i_flags & GRE_SEQ) printf("\n Drop packets out of sequence.\n");
2384 if (ptnl->i_flags & GRE_CSUM)
2385 printf("\n Checksum in received packet is required.");
2386 if (ptnl->o_flags & GRE_SEQ) printf("\n Sequence packets on output.");
2387 if (ptnl->o_flags & GRE_CSUM) printf("\n Checksum output packets.");
2388 xputc('\n');
2389 return 0;
2390 }
2391
read_tunnel(struct ip_tunnel_parm * ptnl)2392 static int read_tunnel(struct ip_tunnel_parm *ptnl)
2393 {
2394 int count = 0;
2395 char iface[IF_NAMESIZE];
2396 struct ip_tunnel_parm iptnl;
2397 FILE *fp = xfopen("/proc/net/dev", "r");
2398
2399 while (fgets(toybuf, sizeof(toybuf), fp)) {
2400 char *ptr;
2401 int ret;
2402
2403 if (count++ < 2) continue; // 1st two lines are header.
2404
2405 ptr = strchr(toybuf, ':');
2406 if (!ptr || (*ptr++ = 0, sscanf(toybuf, "%s", iface) != 1))
2407 error_exit("invalid format of '/proc/net/dev'");
2408 if (*ptnl->name && strcmp(ptnl->name, iface)) continue;
2409 if ((ret = tnl_ioctl(iface, SIOCGIFHWADDR, &iptnl)) < 0) {
2410 error_msg("failed to get type of '%s'", iface);
2411 continue;
2412 }
2413 if (ret != ARPHRD_TUNNEL && ret != ARPHRD_SIT &&
2414 ret != ARPHRD_IPGRE) continue;
2415
2416 memset(&iptnl, 0, sizeof(iptnl));
2417 if (tnl_ioctl(iface, SIOCGETTUNNEL, &iptnl) < 0) continue;
2418 if ((ptnl->link && iptnl.link != ptnl->link) || (*ptnl->name &&
2419 strcmp(iptnl.name, ptnl->name)) || (ptnl->iph.daddr &&
2420 iptnl.iph.daddr != ptnl->iph.daddr) || (ptnl->iph.saddr &&
2421 iptnl.iph.saddr != ptnl->iph.saddr) || (ptnl->i_key &&
2422 iptnl.i_key != ptnl->i_key)) continue;
2423 display_tunnel(&iptnl);
2424 }
2425 fclose(fp);
2426 return 0;
2427 }
2428
parse_iptunnel_args(struct ip_tunnel_parm * ptnl,char ** argv,int ipt_opt_idx)2429 static void parse_iptunnel_args(struct ip_tunnel_parm *ptnl, char **argv,
2430 int ipt_opt_idx)
2431 {
2432 int idx;
2433 uint8_t af = AF_INET;
2434 uint32_t addr = 0;
2435 struct arglist opts[] = { {"mode", 0}, {"key", 1}, {"ikey", 2},
2436 {"okey", 3}, {"seq", 4}, {"iseq", 5}, {"oseq", 6}, {"csum", 7},
2437 {"icsum", 8}, {"ocsum", 9}, {"nopmtudisc", 10}, {"pmtudisc", 11},
2438 {"remote", 12}, {"local", 13},{"dev", 14}, {"ttl", 15}, {"tos", 16},
2439 {"dsfield", 17}, {"name", 18}, {NULL, -1}
2440 };
2441
2442 ptnl->iph.version = 4; // The value indicates the version of IP (4 or 6)
2443 ptnl->iph.ihl = 5; // Minimum Internet Header Length
2444 // frag_off is measured in units of 8 octets (64 bits)
2445 ptnl->iph.frag_off = htons(IP_DF);
2446 if (*argv && ipt_opt_idx <= 2 && string_to_idx(*argv, opts) == -1) {
2447 xstrncpy(ptnl->name, *argv, IF_NAMESIZE);
2448 if (ipt_opt_idx == 1) {
2449 struct ip_tunnel_parm iptnl_old;
2450
2451 memset(&iptnl_old, 0, sizeof(iptnl_old));
2452 tnl_ioctl(ptnl->name, SIOCGETTUNNEL, &iptnl_old);
2453 *ptnl = iptnl_old;
2454 }
2455 argv++;
2456 }
2457 for (; *argv; argv++, addr = 0) {
2458 switch (idx = string_to_idx(*argv, opts)) {
2459 case 0:
2460 if (!*++argv) error_exit("mode is missing");
2461 if ((!strcmp("ipip", *argv) || !strcmp("ip/ip", *argv)))
2462 ptnl->iph.protocol = IPPROTO_IPIP;
2463 else if ((!strcmp("gre", *argv) || !strcmp("gre/ip", *argv)))
2464 ptnl->iph.protocol = IPPROTO_GRE;
2465 else if ((!strcmp("sit", *argv) || !strcmp("ipv6/ip", *argv)))
2466 ptnl->iph.protocol = IPPROTO_IPV6;
2467 else show_iptunnel_help();
2468 break;
2469 case 1:
2470 case 2:
2471 case 3:
2472 {
2473 struct addrinfo *info, hint;
2474 int ret;
2475
2476 if (!*++argv) error_exit("key value is missing");
2477 memset(&hint, 0, sizeof(hint));
2478 hint.ai_family = AF_INET;
2479 ret = getaddrinfo(*argv, NULL, &hint, &info);
2480 if (ret || !info) error_exit("invalid argument to key");
2481 freeaddrinfo(info);
2482
2483 if (strchr(*argv, '.')) {
2484 if (get_prefix(&addr, &af, *argv, AF_INET))
2485 error_exit("invalid key '%s'", *argv);
2486 } else {
2487 unsigned key_val;
2488
2489 sscanf(*argv, "%u", &key_val);
2490 addr = htonl(key_val);
2491 }
2492 if (idx == 1) {
2493 ptnl->i_flags |= GRE_KEY;
2494 ptnl->o_flags |= GRE_KEY;
2495 ptnl->i_key = ptnl->o_key = addr;
2496 } else if (idx == 2) {
2497 ptnl->i_flags |= GRE_KEY;
2498 ptnl->i_key = addr;
2499 } else {
2500 ptnl->o_flags |= GRE_KEY;
2501 ptnl->o_key = addr;
2502 }
2503 }
2504 break;
2505 case 4:
2506 ptnl->i_flags |= GRE_SEQ;
2507 ptnl->o_flags |= GRE_SEQ;
2508 break;
2509 case 5:
2510 ptnl->i_flags |= GRE_SEQ;
2511 break;
2512 case 6:
2513 ptnl->o_flags |= GRE_SEQ;
2514 break;
2515 case 7:
2516 ptnl->i_flags |= GRE_CSUM;
2517 ptnl->o_flags |= GRE_CSUM;
2518 break;
2519 case 8:
2520 ptnl->i_flags |= GRE_CSUM;
2521 break;
2522 case 9:
2523 ptnl->o_flags |= GRE_CSUM;
2524 break;
2525 case 10:
2526 ptnl->iph.frag_off = 0;
2527 break;
2528 case 11:
2529 ptnl->iph.frag_off = htons(IP_DF);
2530 break;
2531 case 12:
2532 case 13:
2533 if (!*++argv) error_exit("remote/local address is missing");
2534 if (get_prefix(&addr, &af, *argv, AF_INET))
2535 error_exit("invalid remote/local address '%s'", *argv);
2536 (idx == 12) ? (ptnl->iph.daddr = addr) : (ptnl->iph.saddr = addr);
2537 break;
2538 case 14:
2539 if (!*++argv) error_exit("device name is missing");
2540 else {
2541 struct ifreq req;
2542 int fd;
2543
2544 xstrncpy(req.ifr_name, *argv, IFNAMSIZ);
2545 fd = xsocket(AF_INET, SOCK_DGRAM, 0);
2546 xioctl(fd, SIOCGIFINDEX, &req);
2547 close(fd);
2548 ptnl->link = req.ifr_ifindex;
2549 }
2550 break;
2551 case 15:
2552 if (!*++argv) error_exit("ttl value is missing");
2553 if (strcmp(*argv, "inherit"))
2554 ptnl->iph.ttl = atolx_range(*argv, 0, 255);
2555 break;
2556 case 16:
2557 case 17:
2558 if (!*++argv) error_exit("tos value is missing");
2559 if (strcmp(*argv, "inherit")) {
2560 char *ptr;
2561 unsigned long tval = strtoul(*argv, &ptr, 16);
2562
2563 if (tval > 255) error_exit("invalid tos value '%s'", *argv);
2564 if (*ptr) {
2565 int ret;
2566
2567 if ((ret = idxfromRPDB(*argv, RPDB_rtdsfield)) < 0)
2568 error_exit("invalid tos value");
2569 ptnl->iph.tos = ret;
2570 } else ptnl->iph.tos = tval;
2571 } else ptnl->iph.tos = 1;
2572 break;
2573 case 18:
2574 if (*ptnl->name) error_exit("invalid tunnel");
2575 else {
2576 if (!*++argv) error_exit("name is missing");
2577 xstrncpy(ptnl->name, *argv, IF_NAMESIZE);
2578 }
2579 break;
2580 default:
2581 if (*ptnl->name) error_exit("invalid tunnel");
2582 xstrncpy(ptnl->name, *argv, IF_NAMESIZE);
2583 break;
2584 }
2585 }
2586 if (ptnl->iph.protocol == IPPROTO_IPIP ||
2587 ptnl->iph.protocol == IPPROTO_IPV6) {
2588 if ((ptnl->i_flags & GRE_KEY) || (ptnl->o_flags & GRE_KEY))
2589 error_exit("[i|o]key is allowed with gre only");
2590 if ((ptnl->i_flags & GRE_SEQ) || (ptnl->o_flags & GRE_SEQ))
2591 error_exit("[i|o]seq is allowed with gre only");
2592 if ((ptnl->i_flags & GRE_CSUM) || (ptnl->o_flags & GRE_CSUM))
2593 error_exit("[i|o]csum is allowed with gre only");
2594 }
2595 if (!ptnl->i_key && IN_MULTICAST(ntohl(ptnl->iph.daddr))) {
2596 ptnl->i_key = ptnl->iph.daddr;
2597 ptnl->i_flags |= GRE_KEY;
2598 }
2599 if (!ptnl->o_key && IN_MULTICAST(ntohl(ptnl->iph.daddr))) {
2600 ptnl->o_key = ptnl->iph.daddr;
2601 ptnl->o_flags |= GRE_KEY;
2602 }
2603 if (IN_MULTICAST(ntohl(ptnl->iph.daddr)) && !ptnl->iph.saddr)
2604 error_exit("broadcast tunnel requires a source address");
2605 }
2606
tunnellist(char ** argv)2607 static int tunnellist(char **argv)
2608 {
2609 struct ip_tunnel_parm iptnl;
2610 int ret = 0;
2611
2612 memset(&iptnl, 0, sizeof(iptnl));
2613 parse_iptunnel_args(&iptnl, argv, 3);
2614
2615 if (iptnl.iph.protocol == IPPROTO_IPIP)
2616 ret = tnl_ioctl(*iptnl.name ? iptnl.name : "tunl0", SIOCGETTUNNEL, &iptnl);
2617 else if (iptnl.iph.protocol == IPPROTO_GRE)
2618 ret = tnl_ioctl(*iptnl.name ? iptnl.name : "gre0", SIOCGETTUNNEL, &iptnl);
2619 else if (iptnl.iph.protocol == IPPROTO_IPV6)
2620 ret = tnl_ioctl(*iptnl.name ? iptnl.name : "sit0", SIOCGETTUNNEL, &iptnl);
2621 else return read_tunnel(&iptnl);
2622
2623 if (ret < 0) {
2624 perror_msg("SIOCGETTUNNEL");
2625 return ret;
2626 } else return display_tunnel(&iptnl);
2627 }
2628
2629 // Performing add, change, & delete tunnel action, according to passed req_type
tunnelupdate(char ** argv)2630 static int tunnelupdate(char **argv)
2631 {
2632 struct ip_tunnel_parm iptnl;
2633 int idx = 2, rtype = SIOCDELTUNNEL;
2634
2635 if (*argv[-1] == 'a') {
2636 idx = 0;
2637 rtype = SIOCADDTUNNEL;
2638 } else if (*argv[-1] == 'c') {
2639 idx = 1;
2640 rtype = SIOCCHGTUNNEL;
2641 }
2642
2643 memset(&iptnl, 0, sizeof(iptnl));
2644 parse_iptunnel_args(&iptnl, argv, idx);
2645 if (idx != 2 && iptnl.iph.ttl && !(iptnl.iph.frag_off))
2646 error_exit("ttl > 0 and nopmtudisc are incompatible");
2647 if (iptnl.iph.protocol == IPPROTO_IPIP)
2648 return (tnl_ioctl("tunl0", rtype, &iptnl) < 0) ? 1 : 0;
2649 else if (iptnl.iph.protocol == IPPROTO_GRE)
2650 return (tnl_ioctl("gre0", rtype, &iptnl) < 0) ? 1 : 0;
2651 else if (iptnl.iph.protocol == IPPROTO_IPV6)
2652 return (tnl_ioctl("sit0", rtype, &iptnl) < 0) ? 1 : 0;
2653 else {
2654 if (idx != 2) error_exit("invalid tunnel mode");
2655 return (tnl_ioctl(iptnl.name, rtype, &iptnl) < 0) ? 1 : 0;
2656 }
2657 }
2658
iptunnel(char ** argv)2659 static int iptunnel(char **argv)
2660 {
2661 int idx;
2662 struct arglist opts[] = {{"add", 0}, {"change", 0}, {"del", 0},
2663 {"delete", 0}, {"show", 1}, {"list", 1}, {"lst", 1}, {NULL, -1}
2664 };
2665 cmdobj ipcmd, cmdobjlist[] = {tunnelupdate, tunnellist};
2666
2667 if (!*argv) idx = 1;
2668 else if ((idx = substring_to_idx(*argv++, opts)) == -1)
2669 show_iptunnel_help();
2670 ipcmd = cmdobjlist[idx];
2671 return ipcmd(argv);
2672 }
2673
2674 // ===========================================================================
2675 // Common code, which is used for all ip options.
2676 // ===========================================================================
2677
2678 // Parse netlink messages and call input callback handler for action
filter_nlmesg(int (* fun)(struct nlmsghdr * mhdr,char ** argv),char ** argv)2679 static int filter_nlmesg(int (*fun)(struct nlmsghdr *mhdr, char **argv),
2680 char **argv)
2681 {
2682 while (1) {
2683 struct nlmsghdr *mhdr;
2684 int msglen = recv(TT.sockfd, TT.gbuf, MESG_LEN, 0);
2685
2686 if ((msglen < 0) && (errno == EINTR || errno == EAGAIN)) continue;
2687 else if (msglen < 0) {
2688 error_msg("netlink receive error %s", strerror(errno));
2689 return 1;
2690 } else if (!msglen) {
2691 error_msg("EOF on netlink");
2692 return 1;
2693 }
2694
2695 for (mhdr = (struct nlmsghdr*)TT.gbuf; NLMSG_OK(mhdr, msglen);
2696 mhdr = NLMSG_NEXT(mhdr, msglen)) {
2697 int err;
2698 if (mhdr->nlmsg_pid != getpid())
2699 continue;
2700 switch (mhdr->nlmsg_type) {
2701 case NLMSG_DONE:
2702 return 0;
2703 case NLMSG_ERROR:
2704 {
2705 struct nlmsgerr *merr = (struct nlmsgerr*)NLMSG_DATA(mhdr);
2706
2707 if (merr->error == 0) return 0;
2708 if (mhdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
2709 error_msg("ERROR truncated");
2710 else {
2711 errno = -merr->error;
2712 perror_msg("RTNETLINK answers");
2713 }
2714 return 1;
2715 }
2716 default:
2717 if (fun && (err = fun(mhdr, argv))) return err;
2718 break;
2719 }
2720 } // End of for loop.
2721 } // End of while loop.
2722 return 0;
2723 }
2724
ip_main(void)2725 void ip_main(void)
2726 {
2727 char **optargv = toys.argv;
2728 int idx, isip = !(toys.which->name[2]); //1 -> if only ip
2729 cmdobj ipcmd, cmdobjlist[] = {ipaddr, iplink, iproute, iprule, iptunnel};
2730
2731 for (++optargv; *optargv; ++optargv) {
2732 char *ptr = *optargv;
2733 struct arglist ip_options[] = {{"oneline", 0}, {"family", 1},
2734 {"4", 1}, {"6", 1}, {"0", 1}, {"stats", 2}, {NULL, -1}};
2735
2736 if (*ptr != '-') break;
2737 else if ((*(ptr+1) == '-') && (*(ptr+2))) ptr +=2;
2738 //escape "--" and stop ip arg parsing.
2739 else if ((*(ptr+1) == '-') && (!*(ptr+2))) {
2740 *ptr +=1;
2741 break;
2742 } else ptr +=1;
2743 switch (substring_to_idx(ptr, ip_options)) {
2744 case 0: TT.singleline = 1;
2745 break;
2746 case 1: {
2747 if (isdigit(*ptr)) {
2748 long num = atolx(ptr);
2749 if (num == 4) TT.addressfamily = AF_INET;
2750 else if (num == 6) TT.addressfamily = AF_INET6;
2751 else TT.addressfamily = AF_PACKET;
2752 } else {
2753 struct arglist ip_aflist[] = {{"inet", AF_INET},
2754 {"inet6", AF_INET6}, {"link", AF_PACKET}, {NULL, -1}};
2755
2756 if (!*++optargv) help_exit(0);
2757 if ((TT.addressfamily = string_to_idx(*optargv, ip_aflist)) == -1)
2758 error_exit("wrong family '%s'", *optargv);
2759 }
2760 }
2761 break;
2762 case 2:
2763 TT.stats++;
2764 break;
2765 default: help_exit(0);
2766 break; // unreachable code.
2767 }
2768 }
2769
2770 TT.sockfd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
2771
2772 if (isip) {// only for ip
2773 if (*optargv) {
2774 struct arglist ip_objectlist[] = { {"address", 0}, {"link", 1},
2775 {"route", 2}, {"rule", 3}, {"tunnel", 4}, {"tunl", 4}, {NULL, -1}};
2776
2777 if ((idx = substring_to_idx(*optargv, ip_objectlist)) == -1) help_exit(0);
2778 ipcmd = cmdobjlist[idx];
2779 toys.exitval = ipcmd(++optargv);
2780 } else help_exit(0);
2781 } else {
2782 struct arglist ip_objectlist[] = { {"ipaddr", 0}, {"iplink", 1},
2783 {"iproute", 2}, {"iprule", 3}, {"iptunnel", 4}, {NULL, -1}};
2784 if ((idx = string_to_idx(toys.which->name, ip_objectlist)) == -1)
2785 help_exit(0);
2786 ipcmd = cmdobjlist[idx];
2787 toys.exitval = ipcmd(optargv);
2788 }
2789 xclose(TT.sockfd);
2790 if (rtdsfield_init) free_alist(rt_dsfield);
2791 if (rtrealms_init) free_alist(rt_realms);
2792 if (rtscope_init) free_alist(rt_scope);
2793 if (rttable_init) free_alist(rt_tables);
2794 if (rtprotos_init) free_alist(rt_protos);
2795 }
2796