lib/utils.c

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