release/src/router/ppp/pppoecd/utils.c

   1 /*
   2  * utils.c - various utility functions used in pppd.
   3  *
   4  * Copyright (c) 1999 The Australian National University.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms are permitted
   8  * provided that the above copyright notice and this paragraph are
   9  * duplicated in all such forms and that any documentation,
  10  * advertising materials, and other materials related to such
  11  * distribution and use acknowledge that the software was developed
  12  * by the Australian National University.  The name of the University
  13  * may not be used to endorse or promote products derived from this
  14  * software without specific prior written permission.
  15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18  */
  19
  20 #define RCSID   "$Id: utils.c,v 1.6 2004/09/23 06:42:31 tallest Exp $"
  21
  22 #include <stdio.h>
  23 #include <ctype.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <signal.h>
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #include <syslog.h>
  31 #include <netdb.h>
  32 #include <utmp.h>
  33 #include <pwd.h>
  34 #include <sys/param.h>
  35 #include <sys/types.h>
  36 #include <sys/wait.h>
  37 #include <sys/time.h>
  38 #include <sys/resource.h>
  39 #include <sys/stat.h>
  40 #include <sys/socket.h>
  41 #include <net/ethernet.h>
  42 #include <netinet/in.h>
  43 #ifdef SVR4
  44 #include <sys/mkdev.h>
  45 #endif
  46 #include <time.h>
  47
  48 #include "pppd.h"
  49
  50 #include <sys/sysinfo.h>
  51
  52 static const char rcsid[] = RCSID;
  53
  54 #if defined(SUNOS4)
  55 extern char *strerror();
  56 #endif
  57
  58 //      static void logit __P((int, char *, va_list));
  59 //      static void log_write __P((int, char *));
  60 static void vslp_printer __P((void *, char *, ...));
  61 static void format_packet __P((u_char *, int, void (*) (void *, char *, ...),
  62                                void *));
  63
  64 struct buffer_info {
  65     char *ptr;
  66     int len;
  67 };
  68
  69 /*
  70  * strlcpy - like strcpy/strncpy, doesn't overflow destination buffer,
  71  * always leaves destination null-terminated (for len > 0).
  72  */
  73 size_t
  74 strlcpy(dest, src, len)
  75     char *dest;
  76     const char *src;
  77     size_t len;
  78 {
  79     size_t ret = strlen(src);
  80
  81     if (len != 0) {
  82         if (ret < len)
  83             strcpy(dest, src);
  84         else {
  85             strncpy(dest, src, len - 1);
  86             dest[len-1] = 0;
  87         }
  88     }
  89     return ret;
  90 }
  91
  92 /*
  93  * strlcat - like strcat/strncat, doesn't overflow destination buffer,
  94  * always leaves destination null-terminated (for len > 0).
  95  */
  96 size_t
  97 strlcat(dest, src, len)
  98     char *dest;
  99     const char *src;
 100     size_t len;
 101 {
 102     size_t dlen = strlen(dest);
 103
 104     return dlen + strlcpy(dest + dlen, src, (len > dlen? len - dlen: 0));
 105 }
 106
 107
 108 /*
 109  * slprintf - format a message into a buffer.  Like sprintf except we
 110  * also specify the length of the output buffer, and we handle
 111  * %r (recursive format), %m (error message), %v (visible string),
 112  * %q (quoted string), %t (current time) and %I (IP address) formats.
 113  * Doesn't do floating-point formats.
 114  * Returns the number of chars put into buf.
 115  */
 116 int
 117 slprintf __V((char *buf, int buflen, char *fmt, ...))
 118 {
 119     va_list args;
 120     int n;
 121
 122 #if defined(__STDC__)
 123     va_start(args, fmt);
 124 #else
 125     char *buf;
 126     int buflen;
 127     char *fmt;
 128     va_start(args);
 129     buf = va_arg(args, char *);
 130     buflen = va_arg(args, int);
 131     fmt = va_arg(args, char *);
 132 #endif
 133     n = vslprintf(buf, buflen, fmt, args);
 134     va_end(args);
 135     return n;
 136 }
 137
 138 /*
 139  * vslprintf - like slprintf, takes a va_list instead of a list of args.
 140  */
 141 #define OUTCHAR(c)      (buflen > 0? (--buflen, *buf++ = (c)): 0)
 142
 143 int
 144 vslprintf(buf, buflen, fmt, args)
 145     char *buf;
 146     int buflen;
 147     char *fmt;
 148     va_list args;
 149 {
 150     int c, i, n;
 151     int width, prec, fillch;
 152     int base, len, neg, quoted;
 153     unsigned long val = 0;
 154     char *str, *f, *buf0;
 155     unsigned char *p;
 156     char num[32];
 157     time_t t;
 158     u_int32_t ip;
 159     static char hexchars[] = "0123456789abcdef";
 160     struct buffer_info bufinfo;
 161
 162     buf0 = buf;
 163     --buflen;
 164     while (buflen > 0) {
 165         for (f = fmt; *f != '%' && *f != 0; ++f)
 166             ;
 167         if (f > fmt) {
 168             len = f - fmt;
 169             if (len > buflen)
 170                 len = buflen;
 171             memcpy(buf, fmt, len);
 172             buf += len;
 173             buflen -= len;
 174             fmt = f;
 175         }
 176         if (*fmt == 0)
 177             break;
 178         c = *++fmt;
 179         width = 0;
 180         prec = -1;
 181         fillch = ' ';
 182         if (c == '0') {
 183             fillch = '0';
 184             c = *++fmt;
 185         }
 186         if (c == '*') {
 187             width = va_arg(args, int);
 188             c = *++fmt;
 189         } else {
 190             while (isdigit(c)) {
 191                 width = width * 10 + c - '0';
 192                 c = *++fmt;
 193             }
 194         }
 195         if (c == '.') {
 196             c = *++fmt;
 197             if (c == '*') {
 198                 prec = va_arg(args, int);
 199                 c = *++fmt;
 200             } else {
 201                 prec = 0;
 202                 while (isdigit(c)) {
 203                     prec = prec * 10 + c - '0';
 204                     c = *++fmt;
 205                 }
 206             }
 207         }
 208         str = 0;
 209         base = 0;
 210         neg = 0;
 211         ++fmt;
 212         switch (c) {
 213         case 'd':
 214             i = va_arg(args, int);
 215             if (i < 0) {
 216                 neg = 1;
 217                 val = -i;
 218             } else
 219                 val = i;
 220             base = 10;
 221             break;
 222         case 'u':
 223             val = va_arg(args, unsigned int);
 224             base = 10;
 225             break;
 226         case 'o':
 227             val = va_arg(args, unsigned int);
 228             base = 8;
 229             break;
 230         case 'x':
 231         case 'X':
 232             val = va_arg(args, unsigned int);
 233             base = 16;
 234             break;
 235         case 'p':
 236             val = (unsigned long) va_arg(args, void *);
 237             base = 16;
 238             neg = 2;
 239             break;
 240         case 's':
 241             str = va_arg(args, char *);
 242             break;
 243         case 'c':
 244             num[0] = va_arg(args, int);
 245             num[1] = 0;
 246             str = num;
 247             break;
 248         case 'm':
 249             str = strerror(errno);
 250             break;
 251         case 'I':
 252             ip = va_arg(args, u_int32_t);
 253             ip = ntohl(ip);
 254             slprintf(num, sizeof(num), "%d.%d.%d.%d", (ip >> 24) & 0xff,
 255                      (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
 256             str = num;
 257             break;
 258         case 'E':
 259             p = va_arg (args, unsigned char *);
 260             for (n = ETH_ALEN; n > 0; --n) {
 261                 c = *p++;
 262                 OUTCHAR (hexchars[(c >> 4) & 0xf]);
 263                 OUTCHAR (hexchars[c & 0xf]);
 264                 if (n > 1)
 265                     OUTCHAR (':');
 266             }
 267             continue;
 268         case 'r':
 269             f = va_arg(args, char *);
 270 #ifndef __powerpc__
 271             n = vslprintf(buf, buflen + 1, f, va_arg(args, va_list));
 272 #else
 273             /* On the powerpc, a va_list is an array of 1 structure */
 274             n = vslprintf(buf, buflen + 1, f, va_arg(args, void *));
 275 #endif
 276             buf += n;
 277             buflen -= n;
 278             continue;
 279         case 't':
 280             time(&t);
 281             str = ctime(&t);
 282             str += 4;           /* chop off the day name */
 283             str[15] = 0;        /* chop off year and newline */
 284             break;
 285         case 'v':               /* "visible" string */
 286         case 'q':               /* quoted string */
 287             quoted = c == 'q';
 288             p = va_arg(args, unsigned char *);
 289             if (fillch == '0' && prec >= 0) {
 290                 n = prec;
 291             } else {
 292                 n = strlen((char *)p);
 293                 if (prec >= 0 && n > prec)
 294                     n = prec;
 295             }
 296             while (n > 0 && buflen > 0) {
 297                 c = *p++;
 298                 --n;
 299                 if (!quoted && c >= 0x80) {
 300                     OUTCHAR('M');
 301                     OUTCHAR('-');
 302                     c -= 0x80;
 303                 }
 304                 if (quoted && (c == '"' || c == '\\'))
 305                     OUTCHAR('\\');
 306                 if (c < 0x20 || (0x7f <= c && c < 0xa0)) {
 307                     if (quoted) {
 308                         OUTCHAR('\\');
 309                         switch (c) {
 310                         case '\t':      OUTCHAR('t');   break;
 311                         case '\n':      OUTCHAR('n');   break;
 312                         case '\b':      OUTCHAR('b');   break;
 313                         case '\f':      OUTCHAR('f');   break;
 314                         default:
 315                             OUTCHAR('x');
 316                             OUTCHAR(hexchars[c >> 4]);
 317                             OUTCHAR(hexchars[c & 0xf]);
 318                         }
 319                     } else {
 320                         if (c == '\t')
 321                             OUTCHAR(c);
 322                         else {
 323                             OUTCHAR('^');
 324                             OUTCHAR(c ^ 0x40);
 325                         }
 326                     }
 327                 } else
 328                     OUTCHAR(c);
 329             }
 330             continue;
 331         case 'P':               /* print PPP packet */
 332             bufinfo.ptr = buf;
 333             bufinfo.len = buflen + 1;
 334             p = va_arg(args, unsigned char *);
 335             n = va_arg(args, int);
 336             format_packet(p, n, vslp_printer, &bufinfo);
 337             buf = bufinfo.ptr;
 338             buflen = bufinfo.len - 1;
 339             continue;
 340         case 'B':
 341             p = va_arg(args, unsigned char *);
 342             for (n = prec; n > 0; --n) {
 343                 c = *p++;
 344                 if (fillch == ' ')
 345                     OUTCHAR(' ');
 346                 OUTCHAR(hexchars[(c >> 4) & 0xf]);
 347                 OUTCHAR(hexchars[c & 0xf]);
 348             }
 349             continue;
 350         default:
 351             *buf++ = '%';
 352             if (c != '%')
 353                 --fmt;          /* so %z outputs %z etc. */
 354             --buflen;
 355             continue;
 356         }
 357         if (base != 0) {
 358             str = num + sizeof(num);
 359             *--str = 0;
 360             while (str > num + neg) {
 361                 *--str = hexchars[val % base];
 362                 val = val / base;
 363                 if (--prec <= 0 && val == 0)
 364                     break;
 365             }
 366             switch (neg) {
 367             case 1:
 368                 *--str = '-';
 369                 break;
 370             case 2:
 371                 *--str = 'x';
 372                 *--str = '0';
 373                 break;
 374             }
 375             len = num + sizeof(num) - 1 - str;
 376         } else {
 377             len = strlen(str);
 378             if (prec >= 0 && len > prec)
 379                 len = prec;
 380         }
 381         if (width > 0) {
 382             if (width > buflen)
 383                 width = buflen;
 384             if ((n = width - len) > 0) {
 385                 buflen -= n;
 386                 for (; n > 0; --n)
 387                     *buf++ = fillch;
 388             }
 389         }
 390         if (len > buflen)
 391             len = buflen;
 392         memcpy(buf, str, len);
 393         buf += len;
 394         buflen -= len;
 395     }
 396     *buf = 0;
 397     return buf - buf0;
 398 }
 399
 400 /*
 401  * vslp_printer - used in processing a %P format
 402  */
 403 static void
 404 vslp_printer __V((void *arg, char *fmt, ...))
 405 {
 406     int n;
 407     va_list pvar;
 408     struct buffer_info *bi;
 409
 410 #if defined(__STDC__)
 411     va_start(pvar, fmt);
 412 #else
 413     void *arg;
 414     char *fmt;
 415     va_start(pvar);
 416     arg = va_arg(pvar, void *);
 417     fmt = va_arg(pvar, char *);
 418 #endif
 419
 420     bi = (struct buffer_info *) arg;
 421     n = vslprintf(bi->ptr, bi->len, fmt, pvar);
 422     va_end(pvar);
 423
 424     bi->ptr += n;
 425     bi->len -= n;
 426 }
 427
 428 #ifdef unused
 429 /*
 430  * log_packet - format a packet and log it.
 431  */
 432
 433 void
 434 log_packet(p, len, prefix, level)
 435     u_char *p;
 436     int len;
 437     char *prefix;
 438     int level;
 439 {
 440         init_pr_log(prefix, level);
 441         format_packet(p, len, pr_log, &level);
 442         end_pr_log();
 443 }
 444 #endif /* unused */
 445
 446 /*
 447  * format_packet - make a readable representation of a packet,
 448  * calling `printer(arg, format, ...)' to output it.
 449  */
 450 static void
 451 format_packet(p, len, printer, arg)
 452     u_char *p;
 453     int len;
 454     void (*printer) __P((void *, char *, ...));
 455     void *arg;
 456 {
 457     int i, n;
 458     u_short proto;
 459     struct protent *protp;
 460
 461     if (len >= PPP_HDRLEN && p[0] == PPP_ALLSTATIONS && p[1] == PPP_UI) {
 462         p += 2;
 463         GETSHORT(proto, p);
 464         len -= PPP_HDRLEN;
 465         for (i = 0; (protp = protocols[i]) != NULL; ++i)
 466             if (proto == protp->protocol)
 467                 break;
 468         if (protp != NULL) {
 469             printer(arg, "[%s", protp->name);
 470             n = (*protp->printpkt)(p, len, printer, arg);
 471             printer(arg, "]");
 472             p += n;
 473             len -= n;
 474         } else {
 475             for (i = 0; (protp = protocols[i]) != NULL; ++i)
 476                 if (proto == (protp->protocol & ~0x8000))
 477                     break;
 478             if (protp != 0 && protp->data_name != 0) {
 479                 printer(arg, "[%s data]", protp->data_name);
 480                 if (len > 8)
 481                     printer(arg, "%.8B ...", p);
 482                 else
 483                     printer(arg, "%.*B", len, p);
 484                 len = 0;
 485             } else
 486                 printer(arg, "[proto=0x%x]", proto);
 487         }
 488     }
 489
 490     if (len > 32)
 491         printer(arg, "%.32B ...", p);
 492     else
 493         printer(arg, "%.*B", len, p);
 494 }
 495
 496 #ifdef DEBUG
 497
 498 /*
 499  * init_pr_log, end_pr_log - initialize and finish use of pr_log.
 500  */
 501
 502 static char line[256];          /* line to be logged accumulated here */
 503 static char *linep;             /* current pointer within line */
 504 static int llevel;              /* level for logging */
 505
 506 void
 507 init_pr_log(prefix, level)
 508      char *prefix;
 509      int level;
 510 {
 511         linep = line;
 512         if (prefix != NULL) {
 513                 strlcpy(line, prefix, sizeof(line));
 514                 linep = line + strlen(line);
 515         }
 516         llevel = level;
 517 }
 518
 519 void
 520 end_pr_log()
 521 {
 522         if (linep != line) {
 523                 *linep = 0;
 524                 log_write(llevel, line);
 525         }
 526 }
 527
 528 /*
 529  * pr_log - printer routine for outputting to syslog
 530  */
 531 void
 532 pr_log __V((void *arg, char *fmt, ...))
 533 {
 534         int l, n;
 535         va_list pvar;
 536         char *p, *eol;
 537         char buf[256];
 538
 539 #if defined(__STDC__)
 540         va_start(pvar, fmt);
 541 #else
 542         void *arg;
 543         char *fmt;
 544         va_start(pvar);
 545         arg = va_arg(pvar, void *);
 546         fmt = va_arg(pvar, char *);
 547 #endif
 548
 549         n = vslprintf(buf, sizeof(buf), fmt, pvar);
 550         va_end(pvar);
 551
 552         p = buf;
 553         eol = strchr(buf, '\n');
 554         if (linep != line) {
 555                 l = (eol == NULL)? n: eol - buf;
 556                 if (linep + l < line + sizeof(line)) {
 557                         if (l > 0) {
 558                                 memcpy(linep, buf, l);
 559                                 linep += l;
 560                         }
 561                         if (eol == NULL)
 562                                 return;
 563                         p = eol + 1;
 564                         eol = strchr(p, '\n');
 565                 }
 566                 *linep = 0;
 567                 log_write(llevel, line);
 568                 linep = line;
 569         }
 570
 571         while (eol != NULL) {
 572                 *eol = 0;
 573                 log_write(llevel, p);
 574                 p = eol + 1;
 575                 eol = strchr(p, '\n');
 576         }
 577
 578         /* assumes sizeof(buf) <= sizeof(line) */
 579         l = buf + n - p;
 580         if (l > 0) {
 581                 memcpy(line, p, n);
 582                 linep = line + l;
 583         }
 584 }
 585
 586 /*
 587  * print_string - print a readable representation of a string using
 588  * printer.
 589  */
 590 void
 591 print_string(p, len, printer, arg)
 592     char *p;
 593     int len;
 594     void (*printer) __P((void *, char *, ...));
 595     void *arg;
 596 {
 597     int c;
 598
 599     printer(arg, "\"");
 600     for (; len > 0; --len) {
 601         c = *p++;
 602         if (' ' <= c && c <= '~') {
 603             if (c == '\\' || c == '"')
 604                 printer(arg, "\\");
 605             printer(arg, "%c", c);
 606         } else {
 607             switch (c) {
 608             case '\n':
 609                 printer(arg, "\\n");
 610                 break;
 611             case '\r':
 612                 printer(arg, "\\r");
 613                 break;
 614             case '\t':
 615                 printer(arg, "\\t");
 616                 break;
 617             default:
 618                 printer(arg, "\\%.3o", c);
 619             }
 620         }
 621     }
 622     printer(arg, "\"");
 623 }
 624
 625 static void
 626 log_write(level, buf)
 627     int level;
 628     char *buf;
 629 {
 630     syslog(level, "%s", buf);
 631     if (log_to_fd >= 0 && (level != LOG_DEBUG || debug)) {
 632         int n = strlen(buf);
 633
 634         if (n > 0 && buf[n-1] == '\n')
 635             --n;
 636         if (write(log_to_fd, buf, n) != n
 637             || write(log_to_fd, "\n", 1) != 1)
 638             log_to_fd = -1;
 639     }
 640 }
 641 #endif  // DEBUG
 642
 643 /*
 644  * logit - does the hard work for fatal et al.
 645  */
 646 static void
 647 logit(level, fmt, args)
 648     int level;
 649     char *fmt;
 650     va_list args;
 651 {
 652     int n;
 653     char buf[1024];
 654
 655     n = vslprintf(buf, sizeof(buf), fmt, args);
 656 #ifdef DEBUG
 657     log_write(level, buf);
 658 #else
 659         syslog(level, "%s", buf);
 660 #endif
 661 }
 662
 663 /*
 664  * fatal - log an error message and die horribly.
 665  */
 666 void
 667 fatal __V((char *fmt, ...))
 668 {
 669     va_list pvar;
 670
 671 #if defined(__STDC__)
 672     va_start(pvar, fmt);
 673 #else
 674     char *fmt;
 675     va_start(pvar);
 676     fmt = va_arg(pvar, char *);
 677 #endif
 678
 679     logit(LOG_ERR, fmt, pvar);
 680     va_end(pvar);
 681
 682 #if 0
 683         int i;
 684
 685         for (i = 120; i > 0; --i) {
 686                 sleep(1);
 687         }
 688         system("service wan restart");
 689 #endif
 690
 691     die(1);                     /* as promised */
 692 }
 693
 694 #ifdef DEBUG
 695 /*
 696  * error - log an error message.
 697  */
 698 void
 699 error __V((char *fmt, ...))
 700 {
 701     va_list pvar;
 702
 703 #if defined(__STDC__)
 704     va_start(pvar, fmt);
 705 #else
 706     char *fmt;
 707     va_start(pvar);
 708     fmt = va_arg(pvar, char *);
 709 #endif
 710
 711     logit(LOG_ERR, fmt, pvar);
 712     va_end(pvar);
 713 }
 714
 715 /*
 716  * warn - log a warning message.
 717  */
 718 void
 719 warn __V((char *fmt, ...))
 720 {
 721     va_list pvar;
 722
 723 #if defined(__STDC__)
 724     va_start(pvar, fmt);
 725 #else
 726     char *fmt;
 727     va_start(pvar);
 728     fmt = va_arg(pvar, char *);
 729 #endif
 730
 731     logit(LOG_WARNING, fmt, pvar);
 732     va_end(pvar);
 733 }
 734
 735 /*
 736  * notice - log a notice-level message.
 737  */
 738 void
 739 notice __V((char *fmt, ...))
 740 {
 741     va_list pvar;
 742
 743 #if defined(__STDC__)
 744     va_start(pvar, fmt);
 745 #else
 746     char *fmt;
 747     va_start(pvar);
 748     fmt = va_arg(pvar, char *);
 749 #endif
 750
 751     logit(LOG_NOTICE, fmt, pvar);
 752     va_end(pvar);
 753 }
 754
 755 /*
 756  * info - log an informational message.
 757  */
 758 void
 759 info __V((char *fmt, ...))
 760 {
 761     va_list pvar;
 762
 763 #if defined(__STDC__)
 764     va_start(pvar, fmt);
 765 #else
 766     char *fmt;
 767     va_start(pvar);
 768     fmt = va_arg(pvar, char *);
 769 #endif
 770
 771     logit(LOG_INFO, fmt, pvar);
 772     va_end(pvar);
 773 }
 774
 775 /*
 776  * dbglog - log a debug message.
 777  */
 778 void
 779 dbglog __V((char *fmt, ...))
 780 {
 781     va_list pvar;
 782
 783 #if defined(__STDC__)
 784     va_start(pvar, fmt);
 785 #else
 786     char *fmt;
 787     va_start(pvar);
 788     fmt = va_arg(pvar, char *);
 789 #endif
 790
 791     logit(LOG_DEBUG, fmt, pvar);
 792     va_end(pvar);
 793 }
 794
 795 #endif /* DEBUG */
 796
 797
 798 int
 799 my_gettimeofday(struct timeval *timenow, struct timezone *tz)
 800 {
 801         struct sysinfo info;
 802
 803         sysinfo(&info);
 804
 805         timenow->tv_sec = info.uptime;
 806         timenow->tv_usec = 0;
 807
 808         return 0;
 809 }
 810