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 <unistd.h>
  16 #include <syslog.h>
  17 #include <fcntl.h>
  18 #include <sys/socket.h>
  19 #include <netinet/in.h>
  20 #include <string.h>
  21 #include <netdb.h>
  22 #include <arpa/inet.h>
  23 #include <resolv.h>
  24 #include <asm/types.h>
  25 #include <linux/pkt_sched.h>
  26 #include <time.h>
  27 #include <sys/time.h>
  28 #include <errno.h>
  29
  30
  31 #include "utils.h"
  32
  33 int get_integer(int *val, const char *arg, int base)
  34 {
  35         long res;
  36         char *ptr;
  37
  38         if (!arg || !*arg)
  39                 return -1;
  40         res = strtol(arg, &ptr, base);
  41         if (!ptr || ptr == arg || *ptr || res > INT_MAX || res < INT_MIN)
  42                 return -1;
  43         *val = res;
  44         return 0;
  45 }
  46
  47 int mask2bits(__u32 netmask)
  48 {
  49         unsigned bits = 0;
  50         __u32 mask = ntohl(netmask);
  51         __u32 host = ~mask;
  52
  53         /* a valid netmask must be 2^n - 1 */
  54         if ((host & (host + 1)) != 0)
  55                 return -1;
  56
  57         for (; mask; mask <<= 1)
  58                 ++bits;
  59         return bits;
  60 }
  61
  62 static int get_netmask(unsigned *val, const char *arg, int base)
  63 {
  64         inet_prefix addr;
  65
  66         if (!get_unsigned(val, arg, base))
  67                 return 0;
  68
  69         /* try coverting dotted quad to CIDR */
  70         if (!get_addr_1(&addr, arg, AF_INET) && addr.family == AF_INET) {
  71                 int b = mask2bits(addr.data[0]);
  72
  73                 if (b >= 0) {
  74                         *val = b;
  75                         return 0;
  76                 }
  77         }
  78
  79         return -1;
  80 }
  81
  82 int get_unsigned(unsigned *val, const char *arg, int base)
  83 {
  84         unsigned long res;
  85         char *ptr;
  86
  87         if (!arg || !*arg)
  88                 return -1;
  89         res = strtoul(arg, &ptr, base);
  90         if (!ptr || ptr == arg || *ptr || res > UINT_MAX)
  91                 return -1;
  92         *val = res;
  93         return 0;
  94 }
  95
  96 /*
  97  * get_time_rtt is "translated" from a similar routine "get_time" in
  98  * tc_util.c.  We don't use the exact same routine because tc passes
  99  * microseconds to the kernel and the callers of get_time_rtt want to
 100  * pass milliseconds (standard unit for rtt values since 2.6.27), and
 101  * have a different assumption for the units of a "raw" number.
 102  */
 103 int get_time_rtt(unsigned *val, const char *arg, int *raw)
 104 {
 105         double t;
 106         unsigned long res;
 107         char *p;
 108
 109         if (strchr(arg,'.') != NULL) {
 110                 t = strtod(arg,&p);
 111                 if (t < 0.0)
 112                         return -1;
 113         }
 114         else {
 115                 res = strtoul(arg, &p, 0);
 116                 if (res > UINT_MAX)
 117                         return -1;
 118                 t = (double)res;
 119         }
 120         if (p == arg)
 121                 return -1;
 122         *raw = 1;
 123
 124         if (*p) {
 125                 *raw = 0;
 126                 if (strcasecmp(p, "s") == 0 || strcasecmp(p, "sec")==0 ||
 127                     strcasecmp(p, "secs")==0)
 128                         t *= 1000;
 129                 else if (strcasecmp(p, "ms") == 0 || strcasecmp(p, "msec")==0 ||
 130                          strcasecmp(p, "msecs") == 0)
 131                         t *= 1.0; /* allow suffix, do nothing */
 132                 else
 133                         return -1;
 134         }
 135
 136         /* emulate ceil() without having to bring-in -lm and always be >= 1 */
 137
 138         *val = t;
 139         if (*val < t)
 140                 *val += 1;
 141
 142         return 0;
 143
 144 }
 145
 146 int get_u64(__u64 *val, const char *arg, int base)
 147 {
 148         unsigned long long res;
 149         char *ptr;
 150
 151         if (!arg || !*arg)
 152                 return -1;
 153         res = strtoull(arg, &ptr, base);
 154         if (!ptr || ptr == arg || *ptr || res == 0xFFFFFFFFULL)
 155                 return -1;
 156         *val = res;
 157         return 0;
 158 }
 159
 160 int get_u32(__u32 *val, const char *arg, int base)
 161 {
 162         unsigned long res;
 163         char *ptr;
 164
 165         if (!arg || !*arg)
 166                 return -1;
 167         res = strtoul(arg, &ptr, base);
 168         if (!ptr || ptr == arg || *ptr || res > 0xFFFFFFFFUL)
 169                 return -1;
 170         *val = res;
 171         return 0;
 172 }
 173
 174 int get_u16(__u16 *val, const char *arg, int base)
 175 {
 176         unsigned long res;
 177         char *ptr;
 178
 179         if (!arg || !*arg)
 180                 return -1;
 181         res = strtoul(arg, &ptr, base);
 182         if (!ptr || ptr == arg || *ptr || res > 0xFFFF)
 183                 return -1;
 184         *val = res;
 185         return 0;
 186 }
 187
 188 int get_u8(__u8 *val, const char *arg, int base)
 189 {
 190         unsigned long res;
 191         char *ptr;
 192
 193         if (!arg || !*arg)
 194                 return -1;
 195         res = strtoul(arg, &ptr, base);
 196         if (!ptr || ptr == arg || *ptr || res > 0xFF)
 197                 return -1;
 198         *val = res;
 199         return 0;
 200 }
 201
 202 int get_s32(__s32 *val, const char *arg, int base)
 203 {
 204         long res;
 205         char *ptr;
 206
 207         errno = 0;
 208
 209         if (!arg || !*arg)
 210                 return -1;
 211         res = strtol(arg, &ptr, base);
 212         if (ptr == arg || *ptr ||
 213             ((res ==  LONG_MIN || res == LONG_MAX) && errno == ERANGE) ||
 214             res > INT32_MAX || res < INT32_MIN)
 215                 return -1;
 216         *val = res;
 217         return 0;
 218 }
 219
 220 int get_s16(__s16 *val, const char *arg, int base)
 221 {
 222         long res;
 223         char *ptr;
 224
 225         if (!arg || !*arg)
 226                 return -1;
 227         res = strtol(arg, &ptr, base);
 228         if (!ptr || ptr == arg || *ptr || res > 0x7FFF || res < -0x8000)
 229                 return -1;
 230         *val = res;
 231         return 0;
 232 }
 233
 234 int get_s8(__s8 *val, const char *arg, int base)
 235 {
 236         long res;
 237         char *ptr;
 238
 239         if (!arg || !*arg)
 240                 return -1;
 241         res = strtol(arg, &ptr, base);
 242         if (!ptr || ptr == arg || *ptr || res > 0x7F || res < -0x80)
 243                 return -1;
 244         *val = res;
 245         return 0;
 246 }
 247
 248 /* This uses a non-standard parsing (ie not inet_aton, or inet_pton)
 249  * because of legacy choice to parse 10.8 as 10.8.0.0 not 10.0.0.8
 250  */
 251 static int get_addr_ipv4(__u8 *ap, const char *cp)
 252 {
 253         int i;
 254
 255         for (i = 0; i < 4; i++) {
 256                 unsigned long n;
 257                 char *endp;
 258
 259                 n = strtoul(cp, &endp, 0);
 260                 if (n > 255)
 261                         return -1;      /* bogus network value */
 262
 263                 if (endp == cp) /* no digits */
 264                         return -1;
 265
 266                 ap[i] = n;
 267
 268                 if (*endp == '\0')
 269                         break;
 270
 271                 if (i == 3 || *endp != '.')
 272                         return -1;      /* extra characters */
 273                 cp = endp + 1;
 274         }
 275
 276         return 1;
 277 }
 278
 279 int get_addr_1(inet_prefix *addr, const char *name, int family)
 280 {
 281         memset(addr, 0, sizeof(*addr));
 282
 283         if (strcmp(name, "default") == 0 ||
 284             strcmp(name, "all") == 0 ||
 285             strcmp(name, "any") == 0) {
 286                 if (family == AF_DECnet)
 287                         return -1;
 288                 addr->family = family;
 289                 addr->bytelen = (family == AF_INET6 ? 16 : 4);
 290                 addr->bitlen = -1;
 291                 return 0;
 292         }
 293
 294         if (strchr(name, ':')) {
 295                 addr->family = AF_INET6;
 296                 if (family != AF_UNSPEC && family != AF_INET6)
 297                         return -1;
 298                 if (inet_pton(AF_INET6, name, addr->data) <= 0)
 299                         return -1;
 300                 addr->bytelen = 16;
 301                 addr->bitlen = -1;
 302                 return 0;
 303         }
 304
 305         if (family == AF_DECnet) {
 306                 struct dn_naddr dna;
 307                 addr->family = AF_DECnet;
 308                 if (dnet_pton(AF_DECnet, name, &dna) <= 0)
 309                         return -1;
 310                 memcpy(addr->data, dna.a_addr, 2);
 311                 addr->bytelen = 2;
 312                 addr->bitlen = -1;
 313                 return 0;
 314         }
 315
 316         addr->family = AF_INET;
 317         if (family != AF_UNSPEC && family != AF_INET)
 318                 return -1;
 319
 320         if (get_addr_ipv4((__u8 *)addr->data, name) <= 0)
 321                 return -1;
 322
 323         addr->bytelen = 4;
 324         addr->bitlen = -1;
 325         return 0;
 326 }
 327
 328 int get_prefix_1(inet_prefix *dst, char *arg, int family)
 329 {
 330         int err;
 331         unsigned plen;
 332         char *slash;
 333
 334         memset(dst, 0, sizeof(*dst));
 335
 336         if (strcmp(arg, "default") == 0 ||
 337             strcmp(arg, "any") == 0 ||
 338             strcmp(arg, "all") == 0) {
 339                 if (family == AF_DECnet)
 340                         return -1;
 341                 dst->family = family;
 342                 dst->bytelen = 0;
 343                 dst->bitlen = 0;
 344                 return 0;
 345         }
 346
 347         slash = strchr(arg, '/');
 348         if (slash)
 349                 *slash = 0;
 350
 351         err = get_addr_1(dst, arg, family);
 352         if (err == 0) {
 353                 switch(dst->family) {
 354                         case AF_INET6:
 355                                 dst->bitlen = 128;
 356                                 break;
 357                         case AF_DECnet:
 358                                 dst->bitlen = 16;
 359                                 break;
 360                         default:
 361                         case AF_INET:
 362                                 dst->bitlen = 32;
 363                 }
 364                 if (slash) {
 365                         if (get_netmask(&plen, slash+1, 0)
 366                                         || plen > dst->bitlen) {
 367                                 err = -1;
 368                                 goto done;
 369                         }
 370                         dst->flags |= PREFIXLEN_SPECIFIED;
 371                         dst->bitlen = plen;
 372                 }
 373         }
 374 done:
 375         if (slash)
 376                 *slash = '/';
 377         return err;
 378 }
 379
 380 int get_addr(inet_prefix *dst, const char *arg, int family)
 381 {
 382         if (family == AF_PACKET) {
 383                 fprintf(stderr, "Error: \"%s\" may be inet address, but it is not allowed in this context.\n", arg);
 384                 exit(1);
 385         }
 386         if (get_addr_1(dst, arg, family)) {
 387                 fprintf(stderr, "Error: an inet address is expected rather than \"%s\".\n", arg);
 388                 exit(1);
 389         }
 390         return 0;
 391 }
 392
 393 int get_prefix(inet_prefix *dst, char *arg, int family)
 394 {
 395         if (family == AF_PACKET) {
 396                 fprintf(stderr, "Error: \"%s\" may be inet prefix, but it is not allowed in this context.\n", arg);
 397                 exit(1);
 398         }
 399         if (get_prefix_1(dst, arg, family)) {
 400                 fprintf(stderr, "Error: an inet prefix is expected rather than \"%s\".\n", arg);
 401                 exit(1);
 402         }
 403         return 0;
 404 }
 405
 406 __u32 get_addr32(const char *name)
 407 {
 408         inet_prefix addr;
 409         if (get_addr_1(&addr, name, AF_INET)) {
 410                 fprintf(stderr, "Error: an IP address is expected rather than \"%s\"\n", name);
 411                 exit(1);
 412         }
 413         return addr.data[0];
 414 }
 415
 416 void incomplete_command(void)
 417 {
 418         fprintf(stderr, "Command line is not complete. Try option \"help\"\n");
 419         exit(-1);
 420 }
 421
 422 void missarg(const char *key)
 423 {
 424         fprintf(stderr, "Error: argument \"%s\" is required\n", key);
 425         exit(-1);
 426 }
 427
 428 void invarg(const char *msg, const char *arg)
 429 {
 430         fprintf(stderr, "Error: argument \"%s\" is wrong: %s\n", arg, msg);
 431         exit(-1);
 432 }
 433
 434 void duparg(const char *key, const char *arg)
 435 {
 436         fprintf(stderr, "Error: duplicate \"%s\": \"%s\" is the second value.\n", key, arg);
 437         exit(-1);
 438 }
 439
 440 void duparg2(const char *key, const char *arg)
 441 {
 442         fprintf(stderr, "Error: either \"%s\" is duplicate, or \"%s\" is a garbage.\n", key, arg);
 443         exit(-1);
 444 }
 445
 446 int matches(const char *cmd, const char *pattern)
 447 {
 448         int len = strlen(cmd);
 449         if (len > strlen(pattern))
 450                 return -1;
 451         return memcmp(pattern, cmd, len);
 452 }
 453
 454 int inet_addr_match(const inet_prefix *a, const inet_prefix *b, int bits)
 455 {
 456         const __u32 *a1 = a->data;
 457         const __u32 *a2 = b->data;
 458         int words = bits >> 0x05;
 459
 460         bits &= 0x1f;
 461
 462         if (words)
 463                 if (memcmp(a1, a2, words << 2))
 464                         return -1;
 465
 466         if (bits) {
 467                 __u32 w1, w2;
 468                 __u32 mask;
 469
 470                 w1 = a1[words];
 471                 w2 = a2[words];
 472
 473                 mask = htonl((0xffffffff) << (0x20 - bits));
 474
 475                 if ((w1 ^ w2) & mask)
 476                         return 1;
 477         }
 478
 479         return 0;
 480 }
 481
 482 int __iproute2_hz_internal;
 483
 484 int __get_hz(void)
 485 {
 486         char name[1024];
 487         int hz = 0;
 488         FILE *fp;
 489
 490         if (getenv("HZ"))
 491                 return atoi(getenv("HZ")) ? : HZ;
 492
 493         if (getenv("PROC_NET_PSCHED")) {
 494                 snprintf(name, sizeof(name)-1, "%s", getenv("PROC_NET_PSCHED"));
 495         } else if (getenv("PROC_ROOT")) {
 496                 snprintf(name, sizeof(name)-1, "%s/net/psched", getenv("PROC_ROOT"));
 497         } else {
 498                 strcpy(name, "/proc/net/psched");
 499         }
 500         fp = fopen(name, "r");
 501
 502         if (fp) {
 503                 unsigned nom, denom;
 504                 if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
 505                         if (nom == 1000000)
 506                                 hz = denom;
 507                 fclose(fp);
 508         }
 509         if (hz)
 510                 return hz;
 511         return HZ;
 512 }
 513
 514 int __iproute2_user_hz_internal;
 515
 516 int __get_user_hz(void)
 517 {
 518         return sysconf(_SC_CLK_TCK);
 519 }
 520
 521 const char *rt_addr_n2a(int af, int len, const void *addr, char *buf, int buflen)
 522 {
 523         switch (af) {
 524         case AF_INET:
 525         case AF_INET6:
 526                 return inet_ntop(af, addr, buf, buflen);
 527         case AF_IPX:
 528                 return ipx_ntop(af, addr, buf, buflen);
 529         case AF_DECnet:
 530         {
 531                 struct dn_naddr dna = { 2, { 0, 0, }};
 532                 memcpy(dna.a_addr, addr, 2);
 533                 return dnet_ntop(af, &dna, buf, buflen);
 534         }
 535         default:
 536                 return "???";
 537         }
 538 }
 539
 540 #ifdef RESOLVE_HOSTNAMES
 541 struct namerec
 542 {
 543         struct namerec *next;
 544         const char *name;
 545         inet_prefix addr;
 546 };
 547
 548 #define NHASH 257
 549 static struct namerec *nht[NHASH];
 550
 551 static const char *resolve_address(const void *addr, int len, int af)
 552 {
 553         struct namerec *n;
 554         struct hostent *h_ent;
 555         unsigned hash;
 556         static int notfirst;
 557
 558
 559         if (af == AF_INET6 && ((__u32*)addr)[0] == 0 &&
 560             ((__u32*)addr)[1] == 0 && ((__u32*)addr)[2] == htonl(0xffff)) {
 561                 af = AF_INET;
 562                 addr += 12;
 563                 len = 4;
 564         }
 565
 566         hash = *(__u32 *)(addr + len - 4) % NHASH;
 567
 568         for (n = nht[hash]; n; n = n->next) {
 569                 if (n->addr.family == af &&
 570                     n->addr.bytelen == len &&
 571                     memcmp(n->addr.data, addr, len) == 0)
 572                         return n->name;
 573         }
 574         if ((n = malloc(sizeof(*n))) == NULL)
 575                 return NULL;
 576         n->addr.family = af;
 577         n->addr.bytelen = len;
 578         n->name = NULL;
 579         memcpy(n->addr.data, addr, len);
 580         n->next = nht[hash];
 581         nht[hash] = n;
 582         if (++notfirst == 1)
 583                 sethostent(1);
 584         fflush(stdout);
 585
 586         if ((h_ent = gethostbyaddr(addr, len, af)) != NULL)
 587                 n->name = strdup(h_ent->h_name);
 588
 589         /* Even if we fail, "negative" entry is remembered. */
 590         return n->name;
 591 }
 592 #endif
 593
 594
 595 const char *format_host(int af, int len, const void *addr,
 596                         char *buf, int buflen)
 597 {
 598 #ifdef RESOLVE_HOSTNAMES
 599         if (resolve_hosts) {
 600                 const char *n;
 601
 602                 if (len <= 0) {
 603                         switch (af) {
 604                         case AF_INET:
 605                                 len = 4;
 606                                 break;
 607                         case AF_INET6:
 608                                 len = 16;
 609                                 break;
 610                         case AF_IPX:
 611                                 len = 10;
 612                                 break;
 613 #ifdef AF_DECnet
 614                         /* I see no reasons why gethostbyname
 615                            may not work for DECnet */
 616                         case AF_DECnet:
 617                                 len = 2;
 618                                 break;
 619 #endif
 620                         default: ;
 621                         }
 622                 }
 623                 if (len > 0 &&
 624                     (n = resolve_address(addr, len, af)) != NULL)
 625                         return n;
 626         }
 627 #endif
 628         return rt_addr_n2a(af, len, addr, buf, buflen);
 629 }
 630
 631
 632 char *hexstring_n2a(const __u8 *str, int len, char *buf, int blen)
 633 {
 634         char *ptr = buf;
 635         int i;
 636
 637         for (i=0; i<len; i++) {
 638                 if (blen < 3)
 639                         break;
 640                 sprintf(ptr, "%02x", str[i]);
 641                 ptr += 2;
 642                 blen -= 2;
 643                 if (i != len-1 && blen > 1) {
 644                         *ptr++ = ':';
 645                         blen--;
 646                 }
 647         }
 648         return buf;
 649 }
 650
 651 __u8* hexstring_a2n(const char *str, __u8 *buf, int blen)
 652 {
 653         int cnt = 0;
 654
 655         for (;;) {
 656                 unsigned acc;
 657                 char ch;
 658
 659                 acc = 0;
 660
 661                 while ((ch = *str) != ':' && ch != 0) {
 662                         if (ch >= '0' && ch <= '9')
 663                                 ch -= '0';
 664                         else if (ch >= 'a' && ch <= 'f')
 665                                 ch -= 'a'-10;
 666                         else if (ch >= 'A' && ch <= 'F')
 667                                 ch -= 'A'-10;
 668                         else
 669                                 return NULL;
 670                         acc = (acc<<4) + ch;
 671                         str++;
 672                 }
 673
 674                 if (acc > 255)
 675                         return NULL;
 676                 if (cnt < blen) {
 677                         buf[cnt] = acc;
 678                         cnt++;
 679                 }
 680                 if (ch == 0)
 681                         break;
 682                 ++str;
 683         }
 684         if (cnt < blen)
 685                 memset(buf+cnt, 0, blen-cnt);
 686         return buf;
 687 }
 688
 689 int print_timestamp(FILE *fp)
 690 {
 691         struct timeval tv;
 692         char *tstr;
 693
 694         memset(&tv, 0, sizeof(tv));
 695         gettimeofday(&tv, NULL);
 696
 697         tstr = asctime(localtime(&tv.tv_sec));
 698         tstr[strlen(tstr)-1] = 0;
 699         fprintf(fp, "Timestamp: %s %lu usec\n", tstr, tv.tv_usec);
 700         return 0;
 701 }
 702
 703 int cmdlineno;
 704
 705 /* Like glibc getline but handle continuation lines and comments */
 706 ssize_t getcmdline(char **linep, size_t *lenp, FILE *in)
 707 {
 708         ssize_t cc;
 709         char *cp;
 710
 711         if ((cc = getline(linep, lenp, in)) < 0)
 712                 return cc;      /* eof or error */
 713         ++cmdlineno;
 714
 715         cp = strchr(*linep, '#');
 716         if (cp)
 717                 *cp = '\0';
 718
 719         while ((cp = strstr(*linep, "\\\n")) != NULL) {
 720                 char *line1 = NULL;
 721                 size_t len1 = 0;
 722                 ssize_t cc1;
 723
 724                 if ((cc1 = getline(&line1, &len1, in)) < 0) {
 725                         fprintf(stderr, "Missing continuation line\n");
 726                         return cc1;
 727                 }
 728
 729                 ++cmdlineno;
 730                 *cp = 0;
 731
 732                 cp = strchr(line1, '#');
 733                 if (cp)
 734                         *cp = '\0';
 735
 736                 *lenp = strlen(*linep) + strlen(line1) + 1;
 737                 *linep = realloc(*linep, *lenp);
 738                 if (!*linep) {
 739                         fprintf(stderr, "Out of memory\n");
 740                         *lenp = 0;
 741                         return -1;
 742                 }
 743                 cc += cc1 - 2;
 744                 strcat(*linep, line1);
 745                 free(line1);
 746         }
 747         return cc;
 748 }
 749
 750 /* split command line into argument vector */
 751 int makeargs(char *line, char *argv[], int maxargs)
 752 {
 753         static const char ws[] = " \t\r\n";
 754         char *cp;
 755         int argc = 0;
 756
 757         for (cp = strtok(line, ws); cp; cp = strtok(NULL, ws)) {
 758                 if (argc >= (maxargs - 1)) {
 759                         fprintf(stderr, "Too many arguments to command\n");
 760                         exit(1);
 761                 }
 762                 argv[argc++] = cp;
 763         }
 764         argv[argc] = NULL;
 765
 766         return argc;
 767 }