1 /*
2  * utils.c
3  *
4  *		This program is free software; you can redistribute it and/or
5  *		modify it under the terms of the GNU General Public License
6  *		as published by the Free Software Foundation; either version
7  *		2 of the License, or (at your option) any later version.
8  *
9  * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10  *
11  */
12 
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <math.h>
16 #include <unistd.h>
17 #include <syslog.h>
18 #include <fcntl.h>
19 #include <limits.h>
20 #include <sys/socket.h>
21 #include <netinet/in.h>
22 #include <string.h>
23 #include <ctype.h>
24 #include <netdb.h>
25 #include <arpa/inet.h>
26 #include <asm/types.h>
27 #include <linux/pkt_sched.h>
28 #include <linux/param.h>
29 #include <linux/if_arp.h>
30 #include <linux/mpls.h>
31 #include <time.h>
32 #include <sys/time.h>
33 #include <errno.h>
34 
35 #include "rt_names.h"
36 #include "utils.h"
37 #include "namespace.h"
38 
39 int resolve_hosts;
40 int timestamp_short;
41 
get_hex(char c)42 int get_hex(char c)
43 {
44 	if (c >= 'A' && c <= 'F')
45 		return c - 'A' + 10;
46 	if (c >= 'a' && c <= 'f')
47 		return c - 'a' + 10;
48 	if (c >= '0' && c <= '9')
49 		return c - '0';
50 
51 	return -1;
52 }
53 
get_integer(int * val,const char * arg,int base)54 int get_integer(int *val, const char *arg, int base)
55 {
56 	long res;
57 	char *ptr;
58 
59 	if (!arg || !*arg)
60 		return -1;
61 
62 	res = strtol(arg, &ptr, base);
63 
64 	/* If there were no digits at all, strtol()  stores
65 	 * the original value of nptr in *endptr (and returns 0).
66 	 * In particular, if *nptr is not '\0' but **endptr is '\0' on return,
67 	 * the entire string is valid.
68 	 */
69 	if (!ptr || ptr == arg || *ptr)
70 		return -1;
71 
72 	/* If an underflow occurs, strtol() returns LONG_MIN.
73 	 * If an overflow occurs,  strtol() returns LONG_MAX.
74 	 * In both cases, errno is set to ERANGE.
75 	 */
76 	if ((res == LONG_MAX || res == LONG_MIN) && errno == ERANGE)
77 		return -1;
78 
79 	/* Outside range of int */
80 	if (res < INT_MIN || res > INT_MAX)
81 		return -1;
82 
83 	*val = res;
84 	return 0;
85 }
86 
mask2bits(__u32 netmask)87 int mask2bits(__u32 netmask)
88 {
89 	unsigned int bits = 0;
90 	__u32 mask = ntohl(netmask);
91 	__u32 host = ~mask;
92 
93 	/* a valid netmask must be 2^n - 1 */
94 	if ((host & (host + 1)) != 0)
95 		return -1;
96 
97 	for (; mask; mask <<= 1)
98 		++bits;
99 	return bits;
100 }
101 
get_netmask(unsigned int * val,const char * arg,int base)102 static int get_netmask(unsigned int *val, const char *arg, int base)
103 {
104 	inet_prefix addr;
105 
106 	if (!get_unsigned(val, arg, base))
107 		return 0;
108 
109 	/* try coverting dotted quad to CIDR */
110 	if (!get_addr_1(&addr, arg, AF_INET) && addr.family == AF_INET) {
111 		int b = mask2bits(addr.data[0]);
112 
113 		if (b >= 0) {
114 			*val = b;
115 			return 0;
116 		}
117 	}
118 
119 	return -1;
120 }
121 
get_unsigned(unsigned int * val,const char * arg,int base)122 int get_unsigned(unsigned int *val, const char *arg, int base)
123 {
124 	unsigned long res;
125 	char *ptr;
126 
127 	if (!arg || !*arg)
128 		return -1;
129 
130 	res = strtoul(arg, &ptr, base);
131 
132 	/* empty string or trailing non-digits */
133 	if (!ptr || ptr == arg || *ptr)
134 		return -1;
135 
136 	/* overflow */
137 	if (res == ULONG_MAX && errno == ERANGE)
138 		return -1;
139 
140 	/* out side range of unsigned */
141 	if (res > UINT_MAX)
142 		return -1;
143 
144 	*val = res;
145 	return 0;
146 }
147 
148 /*
149  * get_time_rtt is "translated" from a similar routine "get_time" in
150  * tc_util.c.  We don't use the exact same routine because tc passes
151  * microseconds to the kernel and the callers of get_time_rtt want to
152  * pass milliseconds (standard unit for rtt values since 2.6.27), and
153  * have a different assumption for the units of a "raw" number.
154  */
get_time_rtt(unsigned int * val,const char * arg,int * raw)155 int get_time_rtt(unsigned int *val, const char *arg, int *raw)
156 {
157 	double t;
158 	unsigned long res;
159 	char *p;
160 
161 	if (strchr(arg, '.') != NULL) {
162 		t = strtod(arg, &p);
163 		if (t < 0.0)
164 			return -1;
165 
166 		/* no digits? */
167 		if (!p || p == arg)
168 			return -1;
169 
170 		/* over/underflow */
171 		if ((t == HUGE_VALF || t == HUGE_VALL) && errno == ERANGE)
172 			return -1;
173 	} else {
174 		res = strtoul(arg, &p, 0);
175 
176 		/* empty string? */
177 		if (!p || p == arg)
178 			return -1;
179 
180 		/* overflow */
181 		if (res == ULONG_MAX && errno == ERANGE)
182 			return -1;
183 
184 		t = (double)res;
185 	}
186 
187 	if (p == arg)
188 		return -1;
189 	*raw = 1;
190 
191 	if (*p) {
192 		*raw = 0;
193 		if (strcasecmp(p, "s") == 0 ||
194 		    strcasecmp(p, "sec") == 0 ||
195 		    strcasecmp(p, "secs") == 0)
196 			t *= 1000;
197 		else if (strcasecmp(p, "ms") == 0 ||
198 			 strcasecmp(p, "msec") == 0 ||
199 			 strcasecmp(p, "msecs") == 0)
200 			t *= 1.0; /* allow suffix, do nothing */
201 		else
202 			return -1;
203 	}
204 
205 	/* emulate ceil() without having to bring-in -lm and always be >= 1 */
206 	*val = t;
207 	if (*val < t)
208 		*val += 1;
209 
210 	return 0;
211 
212 }
213 
get_u64(__u64 * val,const char * arg,int base)214 int get_u64(__u64 *val, const char *arg, int base)
215 {
216 	unsigned long long res;
217 	char *ptr;
218 
219 	if (!arg || !*arg)
220 		return -1;
221 
222 	res = strtoull(arg, &ptr, base);
223 
224 	/* empty string or trailing non-digits */
225 	if (!ptr || ptr == arg || *ptr)
226 		return -1;
227 
228 	/* overflow */
229 	if (res == ULLONG_MAX && errno == ERANGE)
230 		return -1;
231 
232 	/* in case ULL is 128 bits */
233 	if (res > 0xFFFFFFFFFFFFFFFFULL)
234 		return -1;
235 
236 	*val = res;
237 	return 0;
238 }
239 
get_u32(__u32 * val,const char * arg,int base)240 int get_u32(__u32 *val, const char *arg, int base)
241 {
242 	unsigned long res;
243 	char *ptr;
244 
245 	if (!arg || !*arg)
246 		return -1;
247 	res = strtoul(arg, &ptr, base);
248 
249 	/* empty string or trailing non-digits */
250 	if (!ptr || ptr == arg || *ptr)
251 		return -1;
252 
253 	/* overflow */
254 	if (res == ULONG_MAX && errno == ERANGE)
255 		return -1;
256 
257 	/* in case UL > 32 bits */
258 	if (res > 0xFFFFFFFFUL)
259 		return -1;
260 
261 	*val = res;
262 	return 0;
263 }
264 
get_u16(__u16 * val,const char * arg,int base)265 int get_u16(__u16 *val, const char *arg, int base)
266 {
267 	unsigned long res;
268 	char *ptr;
269 
270 	if (!arg || !*arg)
271 		return -1;
272 	res = strtoul(arg, &ptr, base);
273 
274 	/* empty string or trailing non-digits */
275 	if (!ptr || ptr == arg || *ptr)
276 		return -1;
277 
278 	/* overflow */
279 	if (res == ULONG_MAX && errno == ERANGE)
280 		return -1;
281 
282 	if (res > 0xFFFFUL)
283 		return -1;
284 
285 	*val = res;
286 	return 0;
287 }
288 
get_u8(__u8 * val,const char * arg,int base)289 int get_u8(__u8 *val, const char *arg, int base)
290 {
291 	unsigned long res;
292 	char *ptr;
293 
294 	if (!arg || !*arg)
295 		return -1;
296 
297 	res = strtoul(arg, &ptr, base);
298 	/* empty string or trailing non-digits */
299 	if (!ptr || ptr == arg || *ptr)
300 		return -1;
301 
302 	/* overflow */
303 	if (res == ULONG_MAX && errno == ERANGE)
304 		return -1;
305 
306 	if (res > 0xFFUL)
307 		return -1;
308 
309 	*val = res;
310 	return 0;
311 }
312 
get_s32(__s32 * val,const char * arg,int base)313 int get_s32(__s32 *val, const char *arg, int base)
314 {
315 	long res;
316 	char *ptr;
317 
318 	errno = 0;
319 
320 	if (!arg || !*arg)
321 		return -1;
322 	res = strtol(arg, &ptr, base);
323 	if (!ptr || ptr == arg || *ptr)
324 		return -1;
325 	if ((res == LONG_MIN || res == LONG_MAX) && errno == ERANGE)
326 		return -1;
327 	if (res > INT32_MAX || res < INT32_MIN)
328 		return -1;
329 
330 	*val = res;
331 	return 0;
332 }
333 
get_s16(__s16 * val,const char * arg,int base)334 int get_s16(__s16 *val, const char *arg, int base)
335 {
336 	long res;
337 	char *ptr;
338 
339 	if (!arg || !*arg)
340 		return -1;
341 	res = strtol(arg, &ptr, base);
342 	if (!ptr || ptr == arg || *ptr)
343 		return -1;
344 	if ((res == LONG_MIN || res == LONG_MAX) && errno == ERANGE)
345 		return -1;
346 	if (res > 0x7FFF || res < -0x8000)
347 		return -1;
348 
349 	*val = res;
350 	return 0;
351 }
352 
get_s8(__s8 * val,const char * arg,int base)353 int get_s8(__s8 *val, const char *arg, int base)
354 {
355 	long res;
356 	char *ptr;
357 
358 	if (!arg || !*arg)
359 		return -1;
360 	res = strtol(arg, &ptr, base);
361 	if (!ptr || ptr == arg || *ptr)
362 		return -1;
363 	if ((res == LONG_MIN || res == LONG_MAX) && errno == ERANGE)
364 		return -1;
365 	if (res > 0x7F || res < -0x80)
366 		return -1;
367 	*val = res;
368 	return 0;
369 }
370 
get_be64(__be64 * val,const char * arg,int base)371 int get_be64(__be64 *val, const char *arg, int base)
372 {
373 	__u64 v;
374 	int ret = get_u64(&v, arg, base);
375 
376 	if (!ret)
377 		*val = htonll(v);
378 
379 	return ret;
380 }
381 
get_be32(__be32 * val,const char * arg,int base)382 int get_be32(__be32 *val, const char *arg, int base)
383 {
384 	__u32 v;
385 	int ret = get_u32(&v, arg, base);
386 
387 	if (!ret)
388 		*val = htonl(v);
389 
390 	return ret;
391 }
392 
get_be16(__be16 * val,const char * arg,int base)393 int get_be16(__be16 *val, const char *arg, int base)
394 {
395 	__u16 v;
396 	int ret = get_u16(&v, arg, base);
397 
398 	if (!ret)
399 		*val = htons(v);
400 
401 	return ret;
402 }
403 
404 /* This uses a non-standard parsing (ie not inet_aton, or inet_pton)
405  * because of legacy choice to parse 10.8 as 10.8.0.0 not 10.0.0.8
406  */
get_addr_ipv4(__u8 * ap,const char * cp)407 static int get_addr_ipv4(__u8 *ap, const char *cp)
408 {
409 	int i;
410 
411 	for (i = 0; i < 4; i++) {
412 		unsigned long n;
413 		char *endp;
414 
415 		n = strtoul(cp, &endp, 0);
416 		if (n > 255)
417 			return -1;	/* bogus network value */
418 
419 		if (endp == cp) /* no digits */
420 			return -1;
421 
422 		ap[i] = n;
423 
424 		if (*endp == '\0')
425 			break;
426 
427 		if (i == 3 || *endp != '.')
428 			return -1;	/* extra characters */
429 		cp = endp + 1;
430 	}
431 
432 	return 1;
433 }
434 
get_addr64(__u64 * ap,const char * cp)435 int get_addr64(__u64 *ap, const char *cp)
436 {
437 	int i;
438 
439 	union {
440 		__u16 v16[4];
441 		__u64 v64;
442 	} val;
443 
444 	for (i = 0; i < 4; i++) {
445 		unsigned long n;
446 		char *endp;
447 
448 		n = strtoul(cp, &endp, 16);
449 		if (n > 0xffff)
450 			return -1;	/* bogus network value */
451 
452 		if (endp == cp) /* no digits */
453 			return -1;
454 
455 		val.v16[i] = htons(n);
456 
457 		if (*endp == '\0')
458 			break;
459 
460 		if (i == 3 || *endp != ':')
461 			return -1;	/* extra characters */
462 		cp = endp + 1;
463 	}
464 
465 	*ap = val.v64;
466 
467 	return 1;
468 }
469 
get_addr_1(inet_prefix * addr,const char * name,int family)470 int get_addr_1(inet_prefix *addr, const char *name, int family)
471 {
472 	memset(addr, 0, sizeof(*addr));
473 
474 	if (strcmp(name, "default") == 0 ||
475 	    strcmp(name, "all") == 0 ||
476 	    strcmp(name, "any") == 0) {
477 		if ((family == AF_DECnet) || (family == AF_MPLS))
478 			return -1;
479 		addr->family = family;
480 		addr->bytelen = (family == AF_INET6 ? 16 : 4);
481 		addr->bitlen = -1;
482 		return 0;
483 	}
484 
485 	if (family == AF_PACKET) {
486 		int len;
487 
488 		len = ll_addr_a2n((char *) &addr->data, sizeof(addr->data),
489 				  name);
490 		if (len < 0)
491 			return -1;
492 
493 		addr->family = AF_PACKET;
494 		addr->bytelen = len;
495 		addr->bitlen = len * 8;
496 		return 0;
497 	}
498 
499 	if (strchr(name, ':')) {
500 		addr->family = AF_INET6;
501 		if (family != AF_UNSPEC && family != AF_INET6)
502 			return -1;
503 		if (inet_pton(AF_INET6, name, addr->data) <= 0)
504 			return -1;
505 		addr->bytelen = 16;
506 		addr->bitlen = -1;
507 		return 0;
508 	}
509 
510 #ifndef ANDROID
511 	if (family == AF_DECnet) {
512 		struct dn_naddr dna;
513 
514 		addr->family = AF_DECnet;
515 		if (dnet_pton(AF_DECnet, name, &dna) <= 0)
516 			return -1;
517 		memcpy(addr->data, dna.a_addr, 2);
518 		addr->bytelen = 2;
519 		addr->bitlen = -1;
520 		return 0;
521 	}
522 #endif
523 
524 	if (family == AF_MPLS) {
525 		unsigned int maxlabels;
526 		int i;
527 
528 		addr->family = AF_MPLS;
529 		if (mpls_pton(AF_MPLS, name, addr->data,
530 			      sizeof(addr->data)) <= 0)
531 			return -1;
532 		addr->bytelen = 4;
533 		addr->bitlen = 20;
534 		/* How many bytes do I need? */
535 		maxlabels = sizeof(addr->data) / sizeof(struct mpls_label);
536 		for (i = 0; i < maxlabels; i++) {
537 			if (ntohl(addr->data[i]) & MPLS_LS_S_MASK) {
538 				addr->bytelen = (i + 1)*4;
539 				break;
540 			}
541 		}
542 		return 0;
543 	}
544 
545 	addr->family = AF_INET;
546 	if (family != AF_UNSPEC && family != AF_INET)
547 		return -1;
548 
549 	if (get_addr_ipv4((__u8 *)addr->data, name) <= 0)
550 		return -1;
551 
552 	addr->bytelen = 4;
553 	addr->bitlen = -1;
554 	return 0;
555 }
556 
af_bit_len(int af)557 int af_bit_len(int af)
558 {
559 	switch (af) {
560 	case AF_INET6:
561 		return 128;
562 	case AF_INET:
563 		return 32;
564 	case AF_DECnet:
565 		return 16;
566 	case AF_IPX:
567 		return 80;
568 	case AF_MPLS:
569 		return 20;
570 	}
571 
572 	return 0;
573 }
574 
af_byte_len(int af)575 int af_byte_len(int af)
576 {
577 	return af_bit_len(af) / 8;
578 }
579 
get_prefix_1(inet_prefix * dst,char * arg,int family)580 int get_prefix_1(inet_prefix *dst, char *arg, int family)
581 {
582 	int err;
583 	unsigned int plen;
584 	char *slash;
585 
586 	memset(dst, 0, sizeof(*dst));
587 
588 	if (strcmp(arg, "default") == 0 ||
589 	    strcmp(arg, "any") == 0 ||
590 	    strcmp(arg, "all") == 0) {
591 		if ((family == AF_DECnet) || (family == AF_MPLS))
592 			return -1;
593 		dst->family = family;
594 		dst->bytelen = 0;
595 		dst->bitlen = 0;
596 		return 0;
597 	}
598 
599 	slash = strchr(arg, '/');
600 	if (slash)
601 		*slash = 0;
602 
603 	err = get_addr_1(dst, arg, family);
604 	if (err == 0) {
605 		dst->bitlen = af_bit_len(dst->family);
606 
607 		if (slash) {
608 			if (get_netmask(&plen, slash+1, 0)
609 			    || plen > dst->bitlen) {
610 				err = -1;
611 				goto done;
612 			}
613 			dst->flags |= PREFIXLEN_SPECIFIED;
614 			dst->bitlen = plen;
615 		}
616 	}
617 done:
618 	if (slash)
619 		*slash = '/';
620 	return err;
621 }
622 
family_name_verbose(int family)623 static const char *family_name_verbose(int family)
624 {
625 	if (family == AF_UNSPEC)
626 		return "any valid";
627 	return family_name(family);
628 }
629 
get_addr(inet_prefix * dst,const char * arg,int family)630 int get_addr(inet_prefix *dst, const char *arg, int family)
631 {
632 	if (get_addr_1(dst, arg, family)) {
633 		fprintf(stderr,
634 			"Error: %s address is expected rather than \"%s\".\n",
635 			family_name_verbose(family), arg);
636 		exit(1);
637 	}
638 	return 0;
639 }
640 
get_prefix(inet_prefix * dst,char * arg,int family)641 int get_prefix(inet_prefix *dst, char *arg, int family)
642 {
643 	if (family == AF_PACKET) {
644 		fprintf(stderr,
645 			"Error: \"%s\" may be inet prefix, but it is not allowed in this context.\n",
646 			arg);
647 		exit(1);
648 	}
649 
650 	if (get_prefix_1(dst, arg, family)) {
651 		fprintf(stderr,
652 			"Error: %s prefix is expected rather than \"%s\".\n",
653 			family_name_verbose(family), arg);
654 		exit(1);
655 	}
656 	return 0;
657 }
658 
get_addr32(const char * name)659 __u32 get_addr32(const char *name)
660 {
661 	inet_prefix addr;
662 
663 	if (get_addr_1(&addr, name, AF_INET)) {
664 		fprintf(stderr,
665 			"Error: an IP address is expected rather than \"%s\"\n",
666 			name);
667 		exit(1);
668 	}
669 	return addr.data[0];
670 }
671 
incomplete_command(void)672 void incomplete_command(void)
673 {
674 	fprintf(stderr, "Command line is not complete. Try option \"help\"\n");
675 	exit(-1);
676 }
677 
missarg(const char * key)678 void missarg(const char *key)
679 {
680 	fprintf(stderr, "Error: argument \"%s\" is required\n", key);
681 	exit(-1);
682 }
683 
invarg(const char * msg,const char * arg)684 void invarg(const char *msg, const char *arg)
685 {
686 	fprintf(stderr, "Error: argument \"%s\" is wrong: %s\n", arg, msg);
687 	exit(-1);
688 }
689 
duparg(const char * key,const char * arg)690 void duparg(const char *key, const char *arg)
691 {
692 	fprintf(stderr,
693 		"Error: duplicate \"%s\": \"%s\" is the second value.\n",
694 		key, arg);
695 	exit(-1);
696 }
697 
duparg2(const char * key,const char * arg)698 void duparg2(const char *key, const char *arg)
699 {
700 	fprintf(stderr,
701 		"Error: either \"%s\" is duplicate, or \"%s\" is a garbage.\n",
702 		key, arg);
703 	exit(-1);
704 }
705 
check_ifname(const char * name)706 int check_ifname(const char *name)
707 {
708 	/* These checks mimic kernel checks in dev_valid_name */
709 	if (*name == '\0')
710 		return -1;
711 	if (strlen(name) >= IFNAMSIZ)
712 		return -1;
713 
714 	while (*name) {
715 		if (*name == '/' || isspace(*name))
716 			return -1;
717 		++name;
718 	}
719 	return 0;
720 }
721 
722 /* buf is assumed to be IFNAMSIZ */
get_ifname(char * buf,const char * name)723 int get_ifname(char *buf, const char *name)
724 {
725 	int ret;
726 
727 	ret = check_ifname(name);
728 	if (ret == 0)
729 		strncpy(buf, name, IFNAMSIZ);
730 
731 	return ret;
732 }
733 
matches(const char * cmd,const char * pattern)734 int matches(const char *cmd, const char *pattern)
735 {
736 	int len = strlen(cmd);
737 
738 	if (len > strlen(pattern))
739 		return -1;
740 	return memcmp(pattern, cmd, len);
741 }
742 
inet_addr_match(const inet_prefix * a,const inet_prefix * b,int bits)743 int inet_addr_match(const inet_prefix *a, const inet_prefix *b, int bits)
744 {
745 	const __u32 *a1 = a->data;
746 	const __u32 *a2 = b->data;
747 	int words = bits >> 0x05;
748 
749 	bits &= 0x1f;
750 
751 	if (words)
752 		if (memcmp(a1, a2, words << 2))
753 			return -1;
754 
755 	if (bits) {
756 		__u32 w1, w2;
757 		__u32 mask;
758 
759 		w1 = a1[words];
760 		w2 = a2[words];
761 
762 		mask = htonl((0xffffffff) << (0x20 - bits));
763 
764 		if ((w1 ^ w2) & mask)
765 			return 1;
766 	}
767 
768 	return 0;
769 }
770 
771 int __iproute2_hz_internal;
772 
__get_hz(void)773 int __get_hz(void)
774 {
775 	char name[1024];
776 	int hz = 0;
777 	FILE *fp;
778 
779 	if (getenv("HZ"))
780 		return atoi(getenv("HZ")) ? : HZ;
781 
782 	if (getenv("PROC_NET_PSCHED"))
783 		snprintf(name, sizeof(name)-1,
784 			 "%s", getenv("PROC_NET_PSCHED"));
785 	else if (getenv("PROC_ROOT"))
786 		snprintf(name, sizeof(name)-1,
787 			 "%s/net/psched", getenv("PROC_ROOT"));
788 	else
789 		strcpy(name, "/proc/net/psched");
790 
791 	fp = fopen(name, "r");
792 
793 	if (fp) {
794 		unsigned int nom, denom;
795 
796 		if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
797 			if (nom == 1000000)
798 				hz = denom;
799 		fclose(fp);
800 	}
801 	if (hz)
802 		return hz;
803 	return HZ;
804 }
805 
806 int __iproute2_user_hz_internal;
807 
__get_user_hz(void)808 int __get_user_hz(void)
809 {
810 	return sysconf(_SC_CLK_TCK);
811 }
812 
rt_addr_n2a_r(int af,int len,const void * addr,char * buf,int buflen)813 const char *rt_addr_n2a_r(int af, int len,
814 			  const void *addr, char *buf, int buflen)
815 {
816 	switch (af) {
817 	case AF_INET:
818 	case AF_INET6:
819 		return inet_ntop(af, addr, buf, buflen);
820 #ifndef ANDROID
821 	case AF_MPLS:
822 		return mpls_ntop(af, addr, buf, buflen);
823 	case AF_IPX:
824 		return ipx_ntop(af, addr, buf, buflen);
825 	case AF_DECnet:
826 	{
827 		struct dn_naddr dna = { 2, { 0, 0, } };
828 
829 		memcpy(dna.a_addr, addr, 2);
830 		return dnet_ntop(af, &dna, buf, buflen);
831 	}
832 #endif
833 	case AF_PACKET:
834 		return ll_addr_n2a(addr, len, ARPHRD_VOID, buf, buflen);
835 	default:
836 		return "???";
837 	}
838 }
839 
rt_addr_n2a(int af,int len,const void * addr)840 const char *rt_addr_n2a(int af, int len, const void *addr)
841 {
842 	static char buf[256];
843 
844 	return rt_addr_n2a_r(af, len, addr, buf, 256);
845 }
846 
read_family(const char * name)847 int read_family(const char *name)
848 {
849 	int family = AF_UNSPEC;
850 
851 	if (strcmp(name, "inet") == 0)
852 		family = AF_INET;
853 	else if (strcmp(name, "inet6") == 0)
854 		family = AF_INET6;
855 	else if (strcmp(name, "dnet") == 0)
856 		family = AF_DECnet;
857 	else if (strcmp(name, "link") == 0)
858 		family = AF_PACKET;
859 	else if (strcmp(name, "ipx") == 0)
860 		family = AF_IPX;
861 	else if (strcmp(name, "mpls") == 0)
862 		family = AF_MPLS;
863 	else if (strcmp(name, "bridge") == 0)
864 		family = AF_BRIDGE;
865 	return family;
866 }
867 
family_name(int family)868 const char *family_name(int family)
869 {
870 	if (family == AF_INET)
871 		return "inet";
872 	if (family == AF_INET6)
873 		return "inet6";
874 	if (family == AF_DECnet)
875 		return "dnet";
876 	if (family == AF_PACKET)
877 		return "link";
878 	if (family == AF_IPX)
879 		return "ipx";
880 	if (family == AF_MPLS)
881 		return "mpls";
882 	if (family == AF_BRIDGE)
883 		return "bridge";
884 	return "???";
885 }
886 
887 #ifdef RESOLVE_HOSTNAMES
888 struct namerec {
889 	struct namerec *next;
890 	const char *name;
891 	inet_prefix addr;
892 };
893 
894 #define NHASH 257
895 static struct namerec *nht[NHASH];
896 
resolve_address(const void * addr,int len,int af)897 static const char *resolve_address(const void *addr, int len, int af)
898 {
899 	struct namerec *n;
900 	struct hostent *h_ent;
901 	unsigned int hash;
902 	static int notfirst;
903 
904 
905 	if (af == AF_INET6 && ((__u32 *)addr)[0] == 0 &&
906 	    ((__u32 *)addr)[1] == 0 && ((__u32 *)addr)[2] == htonl(0xffff)) {
907 		af = AF_INET;
908 		addr += 12;
909 		len = 4;
910 	}
911 
912 	hash = *(__u32 *)(addr + len - 4) % NHASH;
913 
914 	for (n = nht[hash]; n; n = n->next) {
915 		if (n->addr.family == af &&
916 		    n->addr.bytelen == len &&
917 		    memcmp(n->addr.data, addr, len) == 0)
918 			return n->name;
919 	}
920 	n = malloc(sizeof(*n));
921 	if (n == NULL)
922 		return NULL;
923 	n->addr.family = af;
924 	n->addr.bytelen = len;
925 	n->name = NULL;
926 	memcpy(n->addr.data, addr, len);
927 	n->next = nht[hash];
928 	nht[hash] = n;
929 	if (++notfirst == 1)
930 		sethostent(1);
931 	fflush(stdout);
932 
933 	h_ent = gethostbyaddr(addr, len, af);
934 	if (h_ent != NULL)
935 		n->name = strdup(h_ent->h_name);
936 
937 	/* Even if we fail, "negative" entry is remembered. */
938 	return n->name;
939 }
940 #endif
941 
format_host_r(int af,int len,const void * addr,char * buf,int buflen)942 const char *format_host_r(int af, int len, const void *addr,
943 			char *buf, int buflen)
944 {
945 #ifdef RESOLVE_HOSTNAMES
946 	if (resolve_hosts) {
947 		const char *n;
948 
949 		len = len <= 0 ? af_byte_len(af) : len;
950 
951 		if (len > 0 &&
952 		    (n = resolve_address(addr, len, af)) != NULL)
953 			return n;
954 	}
955 #endif
956 	return rt_addr_n2a_r(af, len, addr, buf, buflen);
957 }
958 
format_host(int af,int len,const void * addr)959 const char *format_host(int af, int len, const void *addr)
960 {
961 	static char buf[256];
962 
963 	return format_host_r(af, len, addr, buf, 256);
964 }
965 
966 
hexstring_n2a(const __u8 * str,int len,char * buf,int blen)967 char *hexstring_n2a(const __u8 *str, int len, char *buf, int blen)
968 {
969 	char *ptr = buf;
970 	int i;
971 
972 	for (i = 0; i < len; i++) {
973 		if (blen < 3)
974 			break;
975 		sprintf(ptr, "%02x", str[i]);
976 		ptr += 2;
977 		blen -= 2;
978 	}
979 	return buf;
980 }
981 
hexstring_a2n(const char * str,__u8 * buf,int blen,unsigned int * len)982 __u8 *hexstring_a2n(const char *str, __u8 *buf, int blen, unsigned int *len)
983 {
984 	unsigned int cnt = 0;
985 	char *endptr;
986 
987 	if (strlen(str) % 2)
988 		return NULL;
989 	while (cnt < blen && strlen(str) > 1) {
990 		unsigned int tmp;
991 		char tmpstr[3];
992 
993 		strncpy(tmpstr, str, 2);
994 		tmpstr[2] = '\0';
995 		errno = 0;
996 		tmp = strtoul(tmpstr, &endptr, 16);
997 		if (errno != 0 || tmp > 0xFF || *endptr != '\0')
998 			return NULL;
999 		buf[cnt++] = tmp;
1000 		str += 2;
1001 	}
1002 
1003 	if (len)
1004 		*len = cnt;
1005 
1006 	return buf;
1007 }
1008 
hex2mem(const char * buf,uint8_t * mem,int count)1009 int hex2mem(const char *buf, uint8_t *mem, int count)
1010 {
1011 	int i, j;
1012 	int c;
1013 
1014 	for (i = 0, j = 0; i < count; i++, j += 2) {
1015 		c = get_hex(buf[j]);
1016 		if (c < 0)
1017 			return -1;
1018 
1019 		mem[i] = c << 4;
1020 
1021 		c = get_hex(buf[j + 1]);
1022 		if (c < 0)
1023 			return -1;
1024 
1025 		mem[i] |= c;
1026 	}
1027 
1028 	return 0;
1029 }
1030 
addr64_n2a(__u64 addr,char * buff,size_t len)1031 int addr64_n2a(__u64 addr, char *buff, size_t len)
1032 {
1033 	__u16 *words = (__u16 *)&addr;
1034 	__u16 v;
1035 	int i, ret;
1036 	size_t written = 0;
1037 	char *sep = ":";
1038 
1039 	for (i = 0; i < 4; i++) {
1040 		v = ntohs(words[i]);
1041 
1042 		if (i == 3)
1043 			sep = "";
1044 
1045 		ret = snprintf(&buff[written], len - written, "%x%s", v, sep);
1046 		if (ret < 0)
1047 			return ret;
1048 
1049 		written += ret;
1050 	}
1051 
1052 	return written;
1053 }
1054 
1055 /* Print buffer and escape bytes that are !isprint or among 'escape' */
print_escape_buf(const __u8 * buf,size_t len,const char * escape)1056 void print_escape_buf(const __u8 *buf, size_t len, const char *escape)
1057 {
1058 	size_t i;
1059 
1060 	for (i = 0; i < len; ++i) {
1061 		if (isprint(buf[i]) && buf[i] != '\\' &&
1062 		    !strchr(escape, buf[i]))
1063 			printf("%c", buf[i]);
1064 		else
1065 			printf("\\%03o", buf[i]);
1066 	}
1067 }
1068 
print_timestamp(FILE * fp)1069 int print_timestamp(FILE *fp)
1070 {
1071 	struct timeval tv;
1072 	struct tm *tm;
1073 
1074 	gettimeofday(&tv, NULL);
1075 	tm = localtime(&tv.tv_sec);
1076 
1077 	if (timestamp_short) {
1078 		char tshort[40];
1079 
1080 		strftime(tshort, sizeof(tshort), "%Y-%m-%dT%H:%M:%S", tm);
1081 		fprintf(fp, "[%s.%06ld] ", tshort, tv.tv_usec);
1082 	} else {
1083 		char *tstr = asctime(tm);
1084 
1085 		tstr[strlen(tstr)-1] = 0;
1086 		fprintf(fp, "Timestamp: %s %ld usec\n",
1087 			tstr, tv.tv_usec);
1088 	}
1089 
1090 	return 0;
1091 }
1092 
1093 int cmdlineno;
1094 
1095 /* Like glibc getline but handle continuation lines and comments */
getcmdline(char ** linep,size_t * lenp,FILE * in)1096 ssize_t getcmdline(char **linep, size_t *lenp, FILE *in)
1097 {
1098 	ssize_t cc;
1099 	char *cp;
1100 
1101 	cc = getline(linep, lenp, in);
1102 	if (cc < 0)
1103 		return cc;	/* eof or error */
1104 	++cmdlineno;
1105 
1106 	cp = strchr(*linep, '#');
1107 	if (cp)
1108 		*cp = '\0';
1109 
1110 	while ((cp = strstr(*linep, "\\\n")) != NULL) {
1111 		char *line1 = NULL;
1112 		size_t len1 = 0;
1113 		ssize_t cc1;
1114 
1115 		cc1 = getline(&line1, &len1, in);
1116 		if (cc1 < 0) {
1117 			fprintf(stderr, "Missing continuation line\n");
1118 			return cc1;
1119 		}
1120 
1121 		++cmdlineno;
1122 		*cp = 0;
1123 
1124 		cp = strchr(line1, '#');
1125 		if (cp)
1126 			*cp = '\0';
1127 
1128 		*lenp = strlen(*linep) + strlen(line1) + 1;
1129 		*linep = realloc(*linep, *lenp);
1130 		if (!*linep) {
1131 			fprintf(stderr, "Out of memory\n");
1132 			*lenp = 0;
1133 			return -1;
1134 		}
1135 		cc += cc1 - 2;
1136 		strcat(*linep, line1);
1137 		free(line1);
1138 	}
1139 	return cc;
1140 }
1141 
1142 /* split command line into argument vector */
makeargs(char * line,char * argv[],int maxargs)1143 int makeargs(char *line, char *argv[], int maxargs)
1144 {
1145 	static const char ws[] = " \t\r\n";
1146 	char *cp;
1147 	int argc = 0;
1148 
1149 	for (cp = line + strspn(line, ws); *cp; cp += strspn(cp, ws)) {
1150 		if (argc >= (maxargs - 1)) {
1151 			fprintf(stderr, "Too many arguments to command\n");
1152 			exit(1);
1153 		}
1154 
1155 		/* word begins with quote */
1156 		if (*cp == '\'' || *cp == '"') {
1157 			char quote = *cp++;
1158 
1159 			argv[argc++] = cp;
1160 			/* find ending quote */
1161 			cp = strchr(cp, quote);
1162 			if (cp == NULL) {
1163 				fprintf(stderr, "Unterminated quoted string\n");
1164 				exit(1);
1165 			}
1166 			*cp++ = 0;
1167 			continue;
1168 		}
1169 
1170 		argv[argc++] = cp;
1171 		/* find end of word */
1172 		cp += strcspn(cp, ws);
1173 		*cp++ = 0;
1174 	}
1175 	argv[argc] = NULL;
1176 
1177 	return argc;
1178 }
1179 
inet_get_addr(const char * src,__u32 * dst,struct in6_addr * dst6)1180 int inet_get_addr(const char *src, __u32 *dst, struct in6_addr *dst6)
1181 {
1182 	if (strchr(src, ':'))
1183 		return inet_pton(AF_INET6, src, dst6);
1184 	else
1185 		return inet_pton(AF_INET, src, dst);
1186 }
1187 
print_nlmsg_timestamp(FILE * fp,const struct nlmsghdr * n)1188 void print_nlmsg_timestamp(FILE *fp, const struct nlmsghdr *n)
1189 {
1190 	char *tstr;
1191 	time_t secs = ((__u32 *)NLMSG_DATA(n))[0];
1192 	long usecs = ((__u32 *)NLMSG_DATA(n))[1];
1193 
1194 	tstr = asctime(localtime(&secs));
1195 	tstr[strlen(tstr)-1] = 0;
1196 	fprintf(fp, "Timestamp: %s %lu us\n", tstr, usecs);
1197 }
1198 
on_netns(char * nsname,void * arg)1199 static int on_netns(char *nsname, void *arg)
1200 {
1201 	struct netns_func *f = arg;
1202 
1203 	if (netns_switch(nsname))
1204 		return -1;
1205 
1206 	return f->func(nsname, f->arg);
1207 }
1208 
on_netns_label(char * nsname,void * arg)1209 static int on_netns_label(char *nsname, void *arg)
1210 {
1211 	printf("\nnetns: %s\n", nsname);
1212 	return on_netns(nsname, arg);
1213 }
1214 
do_each_netns(int (* func)(char * nsname,void * arg),void * arg,bool show_label)1215 int do_each_netns(int (*func)(char *nsname, void *arg), void *arg,
1216 		bool show_label)
1217 {
1218 	struct netns_func nsf = { .func = func, .arg = arg };
1219 
1220 	if (show_label)
1221 		return netns_foreach(on_netns_label, &nsf);
1222 
1223 	return netns_foreach(on_netns, &nsf);
1224 }
1225 
int_to_str(int val,char * buf)1226 char *int_to_str(int val, char *buf)
1227 {
1228 	sprintf(buf, "%d", val);
1229 	return buf;
1230 }
1231 
get_guid(__u64 * guid,const char * arg)1232 int get_guid(__u64 *guid, const char *arg)
1233 {
1234 	unsigned long int tmp;
1235 	char *endptr;
1236 	int i;
1237 
1238 #define GUID_STR_LEN 23
1239 	/* Verify strict format: format string must be
1240 	 * xx:xx:xx:xx:xx:xx:xx:xx where xx can be an arbitrary
1241 	 * hex digit
1242 	 */
1243 
1244 	if (strlen(arg) != GUID_STR_LEN)
1245 		return -1;
1246 
1247 	/* make sure columns are in place */
1248 	for (i = 0; i < 7; i++)
1249 		if (arg[2 + i * 3] != ':')
1250 			return -1;
1251 
1252 	*guid = 0;
1253 	for (i = 0; i < 8; i++) {
1254 		tmp = strtoul(arg + i * 3, &endptr, 16);
1255 		if (endptr != arg + i * 3 + 2)
1256 			return -1;
1257 
1258 		if (tmp > 255)
1259 			return -1;
1260 
1261 		 *guid |= tmp << (56 - 8 * i);
1262 	}
1263 
1264 	return 0;
1265 }
1266 
1267 /* This is a necessary workaround for multicast route dumps */
get_real_family(int rtm_type,int rtm_family)1268 int get_real_family(int rtm_type, int rtm_family)
1269 {
1270 	if (rtm_type != RTN_MULTICAST)
1271 		return rtm_family;
1272 
1273 	if (rtm_family == RTNL_FAMILY_IPMR)
1274 		return AF_INET;
1275 
1276 	if (rtm_family == RTNL_FAMILY_IP6MR)
1277 		return AF_INET6;
1278 
1279 	return rtm_family;
1280 }
1281 
1282 #ifdef NEED_STRLCPY
strlcpy(char * dst,const char * src,size_t size)1283 size_t strlcpy(char *dst, const char *src, size_t size)
1284 {
1285 	size_t srclen = strlen(src);
1286 
1287 	if (size) {
1288 		size_t minlen = min(srclen, size - 1);
1289 
1290 		memcpy(dst, src, minlen);
1291 		dst[minlen] = '\0';
1292 	}
1293 	return srclen;
1294 }
1295 
strlcat(char * dst,const char * src,size_t size)1296 size_t strlcat(char *dst, const char *src, size_t size)
1297 {
1298 	size_t dlen = strlen(dst);
1299 
1300 	if (dlen >= size)
1301 		return dlen + strlen(src);
1302 
1303 	return dlen + strlcpy(dst + dlen, src, size - dlen);
1304 }
1305 #endif
1306