usr.sbin/ppp/defs.c

   1 /*-
   2  * Copyright (c) 1997 Brian Somers <brian@Awfulhak.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/usr.sbin/ppp/defs.c,v 1.31.2.12 2002/09/01 02:12:26 brian Exp $
  27  */
  28
  29
  30 #include <sys/param.h>
  31 #include <netdb.h>
  32 #include <netinet/in.h>
  33 #include <arpa/inet.h>
  34 #include <sys/socket.h>
  35
  36 #include <ctype.h>
  37 #include <errno.h>
  38 #include <stdarg.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #if defined(__DragonFly__) && !defined(NOKLDLOAD)
  43 #include <sys/module.h>
  44 #endif
  45 #include <termios.h>
  46 #if !defined(__DragonFly__)
  47 #include <time.h>
  48 #endif
  49 #include <unistd.h>
  50
  51 #if defined(__DragonFly__) && !defined(NOKLDLOAD)
  52 #include "id.h"
  53 #include "log.h"
  54 #endif
  55 #include "defs.h"
  56
  57 #define issep(c)        ((c) == '\t' || (c) == ' ')
  58
  59 #if defined(__NetBSD__)
  60 void
  61 randinit(void)
  62 {
  63 #if defined(__DragonFly__)
  64   static int initdone;          /* srandomdev() call is only required once */
  65
  66   if (!initdone) {
  67     initdone = 1;
  68     srandomdev();
  69   }
  70 #else
  71   srandom((time(NULL)^getpid())+random());
  72 #endif
  73 }
  74 #endif
  75
  76 ssize_t
  77 fullread(int fd, void *v, size_t n)
  78 {
  79   size_t got, total;
  80
  81   for (total = 0; total < n; total += got)
  82     switch ((got = read(fd, (char *)v + total, n - total))) {
  83       case 0:
  84         return total;
  85       case -1:
  86         if (errno == EINTR)
  87           got = 0;
  88         else
  89           return -1;
  90     }
  91   return total;
  92 }
  93
  94 static struct {
  95   int mode;
  96   const char *name;
  97 } modes[] = {
  98   { PHYS_INTERACTIVE, "interactive" },
  99   { PHYS_AUTO, "auto" },
 100   { PHYS_DIRECT, "direct" },
 101   { PHYS_DEDICATED, "dedicated" },
 102   { PHYS_DDIAL, "ddial" },
 103   { PHYS_BACKGROUND, "background" },
 104   { PHYS_FOREGROUND, "foreground" },
 105   { PHYS_ALL, "*" },
 106   { 0, 0 }
 107 };
 108
 109 const char *
 110 mode2Nam(int mode)
 111 {
 112   int m;
 113
 114   for (m = 0; modes[m].mode; m++)
 115     if (modes[m].mode == mode)
 116       return modes[m].name;
 117
 118   return "unknown";
 119 }
 120
 121 int
 122 Nam2mode(const char *name)
 123 {
 124   int m, got, len;
 125
 126   len = strlen(name);
 127   got = -1;
 128   for (m = 0; modes[m].mode; m++)
 129     if (!strncasecmp(name, modes[m].name, len)) {
 130       if (modes[m].name[len] == '\0')
 131         return modes[m].mode;
 132       if (got != -1)
 133         return 0;
 134       got = m;
 135     }
 136
 137   return got == -1 ? 0 : modes[got].mode;
 138 }
 139
 140 struct in_addr
 141 GetIpAddr(const char *cp)
 142 {
 143   struct in_addr ipaddr;
 144
 145   if (!strcasecmp(cp, "default"))
 146     ipaddr.s_addr = INADDR_ANY;
 147   else if (inet_aton(cp, &ipaddr) == 0) {
 148     const char *ptr;
 149
 150     /* Any illegal characters ? */
 151     for (ptr = cp; *ptr != '\0'; ptr++)
 152       if (!isalnum(*ptr) && strchr("-.", *ptr) == NULL)
 153         break;
 154
 155     if (*ptr == '\0') {
 156       struct hostent *hp;
 157
 158       hp = gethostbyname(cp);
 159       if (hp && hp->h_addrtype == AF_INET)
 160         memcpy(&ipaddr, hp->h_addr, hp->h_length);
 161       else
 162         ipaddr.s_addr = INADDR_NONE;
 163     } else
 164       ipaddr.s_addr = INADDR_NONE;
 165   }
 166
 167   return ipaddr;
 168 }
 169
 170 static const struct speeds {
 171   unsigned nspeed;
 172   speed_t speed;
 173 } speeds[] = {
 174 #ifdef B50
 175   { 50, B50, },
 176 #endif
 177 #ifdef B75
 178   { 75, B75, },
 179 #endif
 180 #ifdef B110
 181   { 110, B110, },
 182 #endif
 183 #ifdef B134
 184   { 134, B134, },
 185 #endif
 186 #ifdef B150
 187   { 150, B150, },
 188 #endif
 189 #ifdef B200
 190   { 200, B200, },
 191 #endif
 192 #ifdef B300
 193   { 300, B300, },
 194 #endif
 195 #ifdef B600
 196   { 600, B600, },
 197 #endif
 198 #ifdef B1200
 199   { 1200, B1200, },
 200 #endif
 201 #ifdef B1800
 202   { 1800, B1800, },
 203 #endif
 204 #ifdef B2400
 205   { 2400, B2400, },
 206 #endif
 207 #ifdef B4800
 208   { 4800, B4800, },
 209 #endif
 210 #ifdef B9600
 211   { 9600, B9600, },
 212 #endif
 213 #ifdef B19200
 214   { 19200, B19200, },
 215 #endif
 216 #ifdef B38400
 217   { 38400, B38400, },
 218 #endif
 219 #ifdef B7200
 220   { 7200, B7200, },
 221 #endif
 222 #ifdef B14400
 223   { 14400, B14400, },
 224 #endif
 225 #ifdef B28800
 226   { 28800, B28800, },
 227 #endif
 228 #ifdef B57600
 229   { 57600, B57600, },
 230 #endif
 231 #ifdef B76800
 232   { 76800, B76800, },
 233 #endif
 234 #ifdef B115200
 235   { 115200, B115200, },
 236 #endif
 237 #ifdef B230400
 238   { 230400, B230400, },
 239 #endif
 240 #ifdef B460800
 241   { 460800, B460800, },
 242 #endif
 243 #ifdef B921600
 244   { 921600, B921600, },
 245 #endif
 246 #ifdef EXTA
 247   { 19200, EXTA, },
 248 #endif
 249 #ifdef EXTB
 250   { 38400, EXTB, },
 251 #endif
 252   { 0, 0 }
 253 };
 254
 255 unsigned
 256 SpeedToUnsigned(speed_t speed)
 257 {
 258   const struct speeds *sp;
 259
 260   for (sp = speeds; sp->nspeed; sp++) {
 261     if (sp->speed == speed) {
 262       return sp->nspeed;
 263     }
 264   }
 265   return 0;
 266 }
 267
 268 speed_t
 269 UnsignedToSpeed(unsigned nspeed)
 270 {
 271   const struct speeds *sp;
 272
 273   for (sp = speeds; sp->nspeed; sp++) {
 274     if (sp->nspeed == nspeed) {
 275       return sp->speed;
 276     }
 277   }
 278   return B0;
 279 }
 280
 281 char *
 282 findblank(char *p, int flags)
 283 {
 284   int instring;
 285
 286   instring = 0;
 287   while (*p) {
 288     if (*p == '\\') {
 289       if (flags & PARSE_REDUCE) {
 290         memmove(p, p + 1, strlen(p));
 291         if (!*p)
 292           break;
 293       } else
 294         p++;
 295     } else if (*p == '"') {
 296       memmove(p, p + 1, strlen(p));
 297       instring = !instring;
 298       continue;
 299     } else if (!instring && (issep(*p) ||
 300                              (*p == '#' && !(flags & PARSE_NOHASH))))
 301       return p;
 302     p++;
 303   }
 304
 305   return instring ? NULL : p;
 306 }
 307
 308 int
 309 MakeArgs(char *script, char **pvect, int maxargs, int flags)
 310 {
 311   int nargs;
 312
 313   nargs = 0;
 314   while (*script) {
 315     script += strspn(script, " \t");
 316     if (*script == '#' && !(flags & PARSE_NOHASH)) {
 317       *script = '\0';
 318       break;
 319     }
 320     if (*script) {
 321       if (nargs >= maxargs - 1)
 322         break;
 323       *pvect++ = script;
 324       nargs++;
 325       script = findblank(script, flags);
 326       if (script == NULL)
 327         return -1;
 328       else if (!(flags & PARSE_NOHASH) && *script == '#')
 329         *script = '\0';
 330       else if (*script)
 331         *script++ = '\0';
 332     }
 333   }
 334   *pvect = NULL;
 335   return nargs;
 336 }
 337
 338 const char *
 339 NumStr(long val, char *buf, size_t sz)
 340 {
 341   static char result[23];               /* handles 64 bit numbers */
 342
 343   if (buf == NULL || sz == 0) {
 344     buf = result;
 345     sz = sizeof result;
 346   }
 347   snprintf(buf, sz, "<%ld>", val);
 348   return buf;
 349 }
 350
 351 const char *
 352 HexStr(long val, char *buf, size_t sz)
 353 {
 354   static char result[21];               /* handles 64 bit numbers */
 355
 356   if (buf == NULL || sz == 0) {
 357     buf = result;
 358     sz = sizeof result;
 359   }
 360   snprintf(buf, sz, "<0x%lx>", val);
 361   return buf;
 362 }
 363
 364 const char *
 365 ex_desc(int ex)
 366 {
 367   static char num[12];          /* Used immediately if returned */
 368   static const char * const desc[] = {
 369     "normal", "start", "sock", "modem", "dial", "dead", "done",
 370     "reboot", "errdead", "hangup", "term", "nodial", "nologin",
 371     "redial", "reconnect"
 372   };
 373
 374   if (ex >= 0 && ex < (int)NELEM(desc))
 375     return desc[ex];
 376   snprintf(num, sizeof num, "%d", ex);
 377   return num;
 378 }
 379
 380 void
 381 SetTitle(const char *title)
 382 {
 383   if (title == NULL)
 384     setproctitle(NULL);
 385   else if (title[0] == '-' && title[1] != '\0')
 386     setproctitle("-%s", title + 1);
 387   else
 388     setproctitle("%s", title);
 389 }
 390
 391 fd_set *
 392 mkfdset(void)
 393 {
 394   return (fd_set *)malloc(howmany(getdtablesize(), NFDBITS) * sizeof (fd_mask));
 395 }
 396
 397 void
 398 zerofdset(fd_set *s)
 399 {
 400   memset(s, '\0', howmany(getdtablesize(), NFDBITS) * sizeof (fd_mask));
 401 }
 402
 403 void
 404 Concatinate(char *buf, size_t sz, int argc, const char *const *argv)
 405 {
 406   int i, n;
 407   unsigned pos;
 408
 409   *buf = '\0';
 410   for (pos = i = 0; i < argc; i++) {
 411     n = snprintf(buf + pos, sz - pos, "%s%s", i ? " " : "", argv[i]);
 412     if (n < 0) {
 413       buf[pos] = '\0';
 414       break;
 415     }
 416     if ((pos += n) >= sz)
 417       break;
 418   }
 419 }
 420
 421 #if defined(__DragonFly__) && !defined(NOKLDLOAD)
 422 int
 423 loadmodules(int how, const char *module, ...)
 424 {
 425   int loaded = 0;
 426   va_list ap;
 427
 428   va_start(ap, module);
 429   while (module != NULL) {
 430     if (modfind(module) == -1) {
 431       if (ID0kldload(module) == -1) {
 432         if (how == LOAD_VERBOSLY)
 433           log_Printf(LogWARN, "%s: Cannot load module\n", module);
 434       } else
 435         loaded++;
 436     }
 437     module = va_arg(ap, const char *);
 438   }
 439   va_end(ap);
 440   return loaded;
 441 }
 442 #else
 443 int
 444 loadmodules(int how __unused, const char *module __unused, ...)
 445 {
 446   return 0;
 447 }
 448 #endif