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.
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
20 #include <sys/socket.h>
21 #include <netinet/in.h>
24 #include <arpa/inet.h>
25 #include <asm/types.h>
26 #include <linux/pkt_sched.h>
27 #include <linux/param.h>
28 #include <linux/if_arp.h>
29 #include <linux/mpls.h>
36 #include "namespace.h"
42 if (c
>= 'A' && c
<= 'F')
44 if (c
>= 'a' && c
<= 'f')
46 if (c
>= '0' && c
<= '9')
52 int get_integer(int *val
, const char *arg
, int base
)
60 res
= strtol(arg
, &ptr
, base
);
62 /* If there were no digits at all, strtol() stores
63 * the original value of nptr in *endptr (and returns 0).
64 * In particular, if *nptr is not '\0' but **endptr is '\0' on return,
65 * the entire string is valid.
67 if (!ptr
|| ptr
== arg
|| *ptr
)
70 /* If an underflow occurs, strtol() returns LONG_MIN.
71 * If an overflow occurs, strtol() returns LONG_MAX.
72 * In both cases, errno is set to ERANGE.
74 if ((res
== LONG_MAX
|| res
== LONG_MIN
) && errno
== ERANGE
)
77 /* Outside range of int */
78 if (res
< INT_MIN
|| res
> INT_MAX
)
85 int mask2bits(__u32 netmask
)
87 unsigned int bits
= 0;
88 __u32 mask
= ntohl(netmask
);
91 /* a valid netmask must be 2^n - 1 */
92 if ((host
& (host
+ 1)) != 0)
95 for (; mask
; mask
<<= 1)
100 static int get_netmask(unsigned int *val
, const char *arg
, int base
)
104 if (!get_unsigned(val
, arg
, base
))
107 /* try coverting dotted quad to CIDR */
108 if (!get_addr_1(&addr
, arg
, AF_INET
) && addr
.family
== AF_INET
) {
109 int b
= mask2bits(addr
.data
[0]);
120 int get_unsigned(unsigned int *val
, const char *arg
, int base
)
128 res
= strtoul(arg
, &ptr
, base
);
130 /* empty string or trailing non-digits */
131 if (!ptr
|| ptr
== arg
|| *ptr
)
135 if (res
== ULONG_MAX
&& errno
== ERANGE
)
138 /* out side range of unsigned */
147 * get_time_rtt is "translated" from a similar routine "get_time" in
148 * tc_util.c. We don't use the exact same routine because tc passes
149 * microseconds to the kernel and the callers of get_time_rtt want to
150 * pass milliseconds (standard unit for rtt values since 2.6.27), and
151 * have a different assumption for the units of a "raw" number.
153 int get_time_rtt(unsigned int *val
, const char *arg
, int *raw
)
159 if (strchr(arg
, '.') != NULL
) {
169 if ((t
== HUGE_VALF
|| t
== HUGE_VALL
) && errno
== ERANGE
)
172 res
= strtoul(arg
, &p
, 0);
179 if (res
== ULONG_MAX
&& errno
== ERANGE
)
191 if (strcasecmp(p
, "s") == 0 ||
192 strcasecmp(p
, "sec") == 0 ||
193 strcasecmp(p
, "secs") == 0)
195 else if (strcasecmp(p
, "ms") == 0 ||
196 strcasecmp(p
, "msec") == 0 ||
197 strcasecmp(p
, "msecs") == 0)
198 t
*= 1.0; /* allow suffix, do nothing */
203 /* emulate ceil() without having to bring-in -lm and always be >= 1 */
212 int get_u64(__u64
*val
, const char *arg
, int base
)
214 unsigned long long res
;
220 res
= strtoull(arg
, &ptr
, base
);
222 /* empty string or trailing non-digits */
223 if (!ptr
|| ptr
== arg
|| *ptr
)
227 if (res
== ULLONG_MAX
&& errno
== ERANGE
)
230 /* in case ULL is 128 bits */
231 if (res
> 0xFFFFFFFFFFFFFFFFULL
)
238 int get_u32(__u32
*val
, const char *arg
, int base
)
245 res
= strtoul(arg
, &ptr
, base
);
247 /* empty string or trailing non-digits */
248 if (!ptr
|| ptr
== arg
|| *ptr
)
252 if (res
== ULONG_MAX
&& errno
== ERANGE
)
255 /* in case UL > 32 bits */
256 if (res
> 0xFFFFFFFFUL
)
263 int get_u16(__u16
*val
, const char *arg
, int base
)
270 res
= strtoul(arg
, &ptr
, base
);
272 /* empty string or trailing non-digits */
273 if (!ptr
|| ptr
== arg
|| *ptr
)
277 if (res
== ULONG_MAX
&& errno
== ERANGE
)
287 int get_u8(__u8
*val
, const char *arg
, int base
)
295 res
= strtoul(arg
, &ptr
, base
);
296 /* empty string or trailing non-digits */
297 if (!ptr
|| ptr
== arg
|| *ptr
)
301 if (res
== ULONG_MAX
&& errno
== ERANGE
)
311 int get_s32(__s32
*val
, const char *arg
, int base
)
320 res
= strtol(arg
, &ptr
, base
);
321 if (!ptr
|| ptr
== arg
|| *ptr
)
323 if ((res
== LONG_MIN
|| res
== LONG_MAX
) && errno
== ERANGE
)
325 if (res
> INT32_MAX
|| res
< INT32_MIN
)
332 int get_s16(__s16
*val
, const char *arg
, int base
)
339 res
= strtol(arg
, &ptr
, base
);
340 if (!ptr
|| ptr
== arg
|| *ptr
)
342 if ((res
== LONG_MIN
|| res
== LONG_MAX
) && errno
== ERANGE
)
344 if (res
> 0x7FFF || res
< -0x8000)
351 int get_s8(__s8
*val
, const char *arg
, int base
)
358 res
= strtol(arg
, &ptr
, base
);
359 if (!ptr
|| ptr
== arg
|| *ptr
)
361 if ((res
== LONG_MIN
|| res
== LONG_MAX
) && errno
== ERANGE
)
363 if (res
> 0x7F || res
< -0x80)
369 int get_be64(__be64
*val
, const char *arg
, int base
)
372 int ret
= get_u64(&v
, arg
, base
);
380 int get_be32(__be32
*val
, const char *arg
, int base
)
383 int ret
= get_u32(&v
, arg
, base
);
391 int get_be16(__be16
*val
, const char *arg
, int base
)
394 int ret
= get_u16(&v
, arg
, base
);
402 /* This uses a non-standard parsing (ie not inet_aton, or inet_pton)
403 * because of legacy choice to parse 10.8 as 10.8.0.0 not 10.0.0.8
405 static int get_addr_ipv4(__u8
*ap
, const char *cp
)
409 for (i
= 0; i
< 4; i
++) {
413 n
= strtoul(cp
, &endp
, 0);
415 return -1; /* bogus network value */
417 if (endp
== cp
) /* no digits */
425 if (i
== 3 || *endp
!= '.')
426 return -1; /* extra characters */
433 int get_addr64(__u64
*ap
, const char *cp
)
442 for (i
= 0; i
< 4; i
++) {
446 n
= strtoul(cp
, &endp
, 16);
448 return -1; /* bogus network value */
450 if (endp
== cp
) /* no digits */
453 val
.v16
[i
] = htons(n
);
458 if (i
== 3 || *endp
!= ':')
459 return -1; /* extra characters */
468 int get_addr_1(inet_prefix
*addr
, const char *name
, int family
)
470 memset(addr
, 0, sizeof(*addr
));
472 if (strcmp(name
, "default") == 0 ||
473 strcmp(name
, "all") == 0 ||
474 strcmp(name
, "any") == 0) {
475 if ((family
== AF_DECnet
) || (family
== AF_MPLS
))
477 addr
->family
= family
;
478 addr
->bytelen
= (family
== AF_INET6
? 16 : 4);
483 if (family
== AF_PACKET
) {
486 len
= ll_addr_a2n((char *) &addr
->data
, sizeof(addr
->data
),
491 addr
->family
= AF_PACKET
;
493 addr
->bitlen
= len
* 8;
497 if (strchr(name
, ':')) {
498 addr
->family
= AF_INET6
;
499 if (family
!= AF_UNSPEC
&& family
!= AF_INET6
)
501 if (inet_pton(AF_INET6
, name
, addr
->data
) <= 0)
508 if (family
== AF_DECnet
) {
511 addr
->family
= AF_DECnet
;
512 if (dnet_pton(AF_DECnet
, name
, &dna
) <= 0)
514 memcpy(addr
->data
, dna
.a_addr
, 2);
520 if (family
== AF_MPLS
) {
523 addr
->family
= AF_MPLS
;
524 if (mpls_pton(AF_MPLS
, name
, addr
->data
) <= 0)
528 /* How many bytes do I need? */
529 for (i
= 0; i
< 8; i
++) {
530 if (ntohl(addr
->data
[i
]) & MPLS_LS_S_MASK
) {
531 addr
->bytelen
= (i
+ 1)*4;
538 addr
->family
= AF_INET
;
539 if (family
!= AF_UNSPEC
&& family
!= AF_INET
)
542 if (get_addr_ipv4((__u8
*)addr
->data
, name
) <= 0)
550 int af_bit_len(int af
)
568 int af_byte_len(int af
)
570 return af_bit_len(af
) / 8;
573 int get_prefix_1(inet_prefix
*dst
, char *arg
, int family
)
579 memset(dst
, 0, sizeof(*dst
));
581 if (strcmp(arg
, "default") == 0 ||
582 strcmp(arg
, "any") == 0 ||
583 strcmp(arg
, "all") == 0) {
584 if ((family
== AF_DECnet
) || (family
== AF_MPLS
))
586 dst
->family
= family
;
592 slash
= strchr(arg
, '/');
596 err
= get_addr_1(dst
, arg
, family
);
598 dst
->bitlen
= af_bit_len(dst
->family
);
601 if (get_netmask(&plen
, slash
+1, 0)
602 || plen
> dst
->bitlen
) {
606 dst
->flags
|= PREFIXLEN_SPECIFIED
;
616 int get_addr(inet_prefix
*dst
, const char *arg
, int family
)
618 if (get_addr_1(dst
, arg
, family
)) {
620 "Error: %s address is expected rather than \"%s\".\n",
621 family_name(dst
->family
), arg
);
627 int get_prefix(inet_prefix
*dst
, char *arg
, int family
)
629 if (family
== AF_PACKET
) {
631 "Error: \"%s\" may be inet prefix, but it is not allowed in this context.\n",
636 if (get_prefix_1(dst
, arg
, family
)) {
638 "Error: %s prefix is expected rather than \"%s\".\n",
639 family_name(dst
->family
), arg
);
645 __u32
get_addr32(const char *name
)
649 if (get_addr_1(&addr
, name
, AF_INET
)) {
651 "Error: an IP address is expected rather than \"%s\"\n",
658 void incomplete_command(void)
660 fprintf(stderr
, "Command line is not complete. Try option \"help\"\n");
664 void missarg(const char *key
)
666 fprintf(stderr
, "Error: argument \"%s\" is required\n", key
);
670 void invarg(const char *msg
, const char *arg
)
672 fprintf(stderr
, "Error: argument \"%s\" is wrong: %s\n", arg
, msg
);
676 void duparg(const char *key
, const char *arg
)
679 "Error: duplicate \"%s\": \"%s\" is the second value.\n",
684 void duparg2(const char *key
, const char *arg
)
687 "Error: either \"%s\" is duplicate, or \"%s\" is a garbage.\n",
692 int matches(const char *cmd
, const char *pattern
)
694 int len
= strlen(cmd
);
696 if (len
> strlen(pattern
))
698 return memcmp(pattern
, cmd
, len
);
701 int inet_addr_match(const inet_prefix
*a
, const inet_prefix
*b
, int bits
)
703 const __u32
*a1
= a
->data
;
704 const __u32
*a2
= b
->data
;
705 int words
= bits
>> 0x05;
710 if (memcmp(a1
, a2
, words
<< 2))
720 mask
= htonl((0xffffffff) << (0x20 - bits
));
722 if ((w1
^ w2
) & mask
)
729 int __iproute2_hz_internal
;
738 return atoi(getenv("HZ")) ? : HZ
;
740 if (getenv("PROC_NET_PSCHED"))
741 snprintf(name
, sizeof(name
)-1,
742 "%s", getenv("PROC_NET_PSCHED"));
743 else if (getenv("PROC_ROOT"))
744 snprintf(name
, sizeof(name
)-1,
745 "%s/net/psched", getenv("PROC_ROOT"));
747 strcpy(name
, "/proc/net/psched");
749 fp
= fopen(name
, "r");
752 unsigned int nom
, denom
;
754 if (fscanf(fp
, "%*08x%*08x%08x%08x", &nom
, &denom
) == 2)
764 int __iproute2_user_hz_internal
;
766 int __get_user_hz(void)
768 return sysconf(_SC_CLK_TCK
);
771 const char *rt_addr_n2a_r(int af
, int len
,
772 const void *addr
, char *buf
, int buflen
)
777 return inet_ntop(af
, addr
, buf
, buflen
);
779 return mpls_ntop(af
, addr
, buf
, buflen
);
781 return ipx_ntop(af
, addr
, buf
, buflen
);
784 struct dn_naddr dna
= { 2, { 0, 0, } };
786 memcpy(dna
.a_addr
, addr
, 2);
787 return dnet_ntop(af
, &dna
, buf
, buflen
);
790 return ll_addr_n2a(addr
, len
, ARPHRD_VOID
, buf
, buflen
);
796 const char *rt_addr_n2a(int af
, int len
, const void *addr
)
798 static char buf
[256];
800 return rt_addr_n2a_r(af
, len
, addr
, buf
, 256);
803 int read_family(const char *name
)
805 int family
= AF_UNSPEC
;
807 if (strcmp(name
, "inet") == 0)
809 else if (strcmp(name
, "inet6") == 0)
811 else if (strcmp(name
, "dnet") == 0)
813 else if (strcmp(name
, "link") == 0)
815 else if (strcmp(name
, "ipx") == 0)
817 else if (strcmp(name
, "mpls") == 0)
819 else if (strcmp(name
, "bridge") == 0)
824 const char *family_name(int family
)
826 if (family
== AF_INET
)
828 if (family
== AF_INET6
)
830 if (family
== AF_DECnet
)
832 if (family
== AF_PACKET
)
834 if (family
== AF_IPX
)
836 if (family
== AF_MPLS
)
838 if (family
== AF_BRIDGE
)
843 #ifdef RESOLVE_HOSTNAMES
845 struct namerec
*next
;
851 static struct namerec
*nht
[NHASH
];
853 static const char *resolve_address(const void *addr
, int len
, int af
)
856 struct hostent
*h_ent
;
861 if (af
== AF_INET6
&& ((__u32
*)addr
)[0] == 0 &&
862 ((__u32
*)addr
)[1] == 0 && ((__u32
*)addr
)[2] == htonl(0xffff)) {
868 hash
= *(__u32
*)(addr
+ len
- 4) % NHASH
;
870 for (n
= nht
[hash
]; n
; n
= n
->next
) {
871 if (n
->addr
.family
== af
&&
872 n
->addr
.bytelen
== len
&&
873 memcmp(n
->addr
.data
, addr
, len
) == 0)
876 n
= malloc(sizeof(*n
));
880 n
->addr
.bytelen
= len
;
882 memcpy(n
->addr
.data
, addr
, len
);
889 h_ent
= gethostbyaddr(addr
, len
, af
);
891 n
->name
= strdup(h_ent
->h_name
);
893 /* Even if we fail, "negative" entry is remembered. */
898 const char *format_host_r(int af
, int len
, const void *addr
,
899 char *buf
, int buflen
)
901 #ifdef RESOLVE_HOSTNAMES
905 len
= len
<= 0 ? af_byte_len(af
) : len
;
908 (n
= resolve_address(addr
, len
, af
)) != NULL
)
912 return rt_addr_n2a_r(af
, len
, addr
, buf
, buflen
);
915 const char *format_host(int af
, int len
, const void *addr
)
917 static char buf
[256];
919 return format_host_r(af
, len
, addr
, buf
, 256);
923 char *hexstring_n2a(const __u8
*str
, int len
, char *buf
, int blen
)
928 for (i
= 0; i
< len
; i
++) {
931 sprintf(ptr
, "%02x", str
[i
]);
938 __u8
*hexstring_a2n(const char *str
, __u8
*buf
, int blen
, unsigned int *len
)
940 unsigned int cnt
= 0;
945 while (cnt
< blen
&& strlen(str
) > 1) {
949 strncpy(tmpstr
, str
, 2);
952 tmp
= strtoul(tmpstr
, &endptr
, 16);
953 if (errno
!= 0 || tmp
> 0xFF || *endptr
!= '\0')
965 int addr64_n2a(__u64 addr
, char *buff
, size_t len
)
967 __u16
*words
= (__u16
*)&addr
;
973 for (i
= 0; i
< 4; i
++) {
979 ret
= snprintf(&buff
[written
], len
- written
, "%x%s", v
, sep
);
989 int print_timestamp(FILE *fp
)
994 gettimeofday(&tv
, NULL
);
995 tm
= localtime(&tv
.tv_sec
);
997 if (timestamp_short
) {
1000 strftime(tshort
, sizeof(tshort
), "%Y-%m-%dT%H:%M:%S", tm
);
1001 fprintf(fp
, "[%s.%06ld] ", tshort
, tv
.tv_usec
);
1003 char *tstr
= asctime(tm
);
1005 tstr
[strlen(tstr
)-1] = 0;
1006 fprintf(fp
, "Timestamp: %s %ld usec\n",
1015 /* Like glibc getline but handle continuation lines and comments */
1016 ssize_t
getcmdline(char **linep
, size_t *lenp
, FILE *in
)
1021 cc
= getline(linep
, lenp
, in
);
1023 return cc
; /* eof or error */
1026 cp
= strchr(*linep
, '#');
1030 while ((cp
= strstr(*linep
, "\\\n")) != NULL
) {
1035 cc1
= getline(&line1
, &len1
, in
);
1037 fprintf(stderr
, "Missing continuation line\n");
1044 cp
= strchr(line1
, '#');
1048 *lenp
= strlen(*linep
) + strlen(line1
) + 1;
1049 *linep
= realloc(*linep
, *lenp
);
1051 fprintf(stderr
, "Out of memory\n");
1056 strcat(*linep
, line1
);
1062 /* split command line into argument vector */
1063 int makeargs(char *line
, char *argv
[], int maxargs
)
1065 static const char ws
[] = " \t\r\n";
1069 for (cp
= line
+ strspn(line
, ws
); *cp
; cp
+= strspn(cp
, ws
)) {
1070 if (argc
>= (maxargs
- 1)) {
1071 fprintf(stderr
, "Too many arguments to command\n");
1075 /* word begins with quote */
1076 if (*cp
== '\'' || *cp
== '"') {
1080 /* find ending quote */
1081 cp
= strchr(cp
, quote
);
1083 fprintf(stderr
, "Unterminated quoted string\n");
1091 /* find end of word */
1092 cp
+= strcspn(cp
, ws
);
1100 int inet_get_addr(const char *src
, __u32
*dst
, struct in6_addr
*dst6
)
1102 if (strchr(src
, ':'))
1103 return inet_pton(AF_INET6
, src
, dst6
);
1105 return inet_pton(AF_INET
, src
, dst
);
1108 void print_nlmsg_timestamp(FILE *fp
, const struct nlmsghdr
*n
)
1111 time_t secs
= ((__u32
*)NLMSG_DATA(n
))[0];
1112 long usecs
= ((__u32
*)NLMSG_DATA(n
))[1];
1114 tstr
= asctime(localtime(&secs
));
1115 tstr
[strlen(tstr
)-1] = 0;
1116 fprintf(fp
, "Timestamp: %s %lu us\n", tstr
, usecs
);
1119 static int on_netns(char *nsname
, void *arg
)
1121 struct netns_func
*f
= arg
;
1123 if (netns_switch(nsname
))
1126 return f
->func(nsname
, f
->arg
);
1129 static int on_netns_label(char *nsname
, void *arg
)
1131 printf("\nnetns: %s\n", nsname
);
1132 return on_netns(nsname
, arg
);
1135 int do_each_netns(int (*func
)(char *nsname
, void *arg
), void *arg
,
1138 struct netns_func nsf
= { .func
= func
, .arg
= arg
};
1141 return netns_foreach(on_netns_label
, &nsf
);
1143 return netns_foreach(on_netns
, &nsf
);
1146 char *int_to_str(int val
, char *buf
)
1148 sprintf(buf
, "%d", val
);
1152 int get_guid(__u64
*guid
, const char *arg
)
1154 unsigned long int tmp
;
1158 #define GUID_STR_LEN 23
1159 /* Verify strict format: format string must be
1160 * xx:xx:xx:xx:xx:xx:xx:xx where xx can be an arbitrary
1164 if (strlen(arg
) != GUID_STR_LEN
)
1167 /* make sure columns are in place */
1168 for (i
= 0; i
< 7; i
++)
1169 if (arg
[2 + i
* 3] != ':')
1173 for (i
= 0; i
< 8; i
++) {
1174 tmp
= strtoul(arg
+ i
* 3, &endptr
, 16);
1175 if (endptr
!= arg
+ i
* 3 + 2)
1181 *guid
|= tmp
<< (56 - 8 * i
);
1187 /* This is a necessary workaround for multicast route dumps */
1188 int get_real_family(int rtm_type
, int rtm_family
)
1190 if (rtm_type
!= RTN_MULTICAST
)
1193 return rtm_family
== RTNL_FAMILY_IPMR
? AF_INET
: AF_INET6
;