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 (at) 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 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 575 int af_byte_len(int af) 576 { 577 return af_bit_len(af) / 8; 578 } 579 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 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 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 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 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 672 void incomplete_command(void) 673 { 674 fprintf(stderr, "Command line is not complete. Try option \"help\"\n"); 675 exit(-1); 676 } 677 678 void missarg(const char *key) 679 { 680 fprintf(stderr, "Error: argument \"%s\" is required\n", key); 681 exit(-1); 682 } 683 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 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 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 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 */ 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 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 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 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 808 int __get_user_hz(void) 809 { 810 return sysconf(_SC_CLK_TCK); 811 } 812 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 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 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 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 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 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 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 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 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 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 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' */ 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 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 */ 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 */ 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 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 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 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 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 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 1226 char *int_to_str(int val, char *buf) 1227 { 1228 sprintf(buf, "%d", val); 1229 return buf; 1230 } 1231 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 */ 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 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 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
