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$ 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(__FreeBSD__) && !defined(NOKLDLOAD) 43 #include <sys/module.h> 44 #endif 45 #include <termios.h> 46 #ifndef __FreeBSD__ 47 #include <time.h> 48 #endif 49 #include <unistd.h> 50 51 #if defined(__FreeBSD__) && !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 #ifdef __NetBSD__ 60 void 61 randinit() 62 { 63 srandom((time(NULL)^getpid())+random()); 64 } 65 #endif 66 67 ssize_t 68 fullread(int fd, void *v, size_t n) 69 { 70 size_t got, total; 71 72 for (total = 0; total < n; total += got) 73 switch ((got = read(fd, (char *)v + total, n - total))) { 74 case 0: 75 return total; 76 case -1: 77 if (errno == EINTR) 78 got = 0; 79 else 80 return -1; 81 } 82 return total; 83 } 84 85 static struct { 86 int mode; 87 const char *name; 88 } modes[] = { 89 { PHYS_INTERACTIVE, "interactive" }, 90 { PHYS_AUTO, "auto" }, 91 { PHYS_DIRECT, "direct" }, 92 { PHYS_DEDICATED, "dedicated" }, 93 { PHYS_DDIAL, "ddial" }, 94 { PHYS_BACKGROUND, "background" }, 95 { PHYS_FOREGROUND, "foreground" }, 96 { PHYS_ALL, "*" }, 97 { 0, 0 } 98 }; 99 100 const char * 101 mode2Nam(int mode) 102 { 103 int m; 104 105 for (m = 0; modes[m].mode; m++) 106 if (modes[m].mode == mode) 107 return modes[m].name; 108 109 return "unknown"; 110 } 111 112 int 113 Nam2mode(const char *name) 114 { 115 int m, got, len; 116 117 len = strlen(name); 118 got = -1; 119 for (m = 0; modes[m].mode; m++) 120 if (!strncasecmp(name, modes[m].name, len)) { 121 if (modes[m].name[len] == '\0') 122 return modes[m].mode; 123 if (got != -1) 124 return 0; 125 got = m; 126 } 127 128 return got == -1 ? 0 : modes[got].mode; 129 } 130 131 struct in_addr 132 GetIpAddr(const char *cp) 133 { 134 struct in_addr ipaddr; 135 136 if (!strcasecmp(cp, "default")) 137 ipaddr.s_addr = INADDR_ANY; 138 else if (inet_aton(cp, &ipaddr) == 0) { 139 const char *ptr; 140 141 /* Any illegal characters ? */ 142 for (ptr = cp; *ptr != '\0'; ptr++) 143 if (!isalnum(*ptr) && strchr("-.", *ptr) == NULL) 144 break; 145 146 if (*ptr == '\0') { 147 struct hostent *hp; 148 149 hp = gethostbyname(cp); 150 if (hp && hp->h_addrtype == AF_INET) 151 memcpy(&ipaddr, hp->h_addr, hp->h_length); 152 else 153 ipaddr.s_addr = INADDR_NONE; 154 } else 155 ipaddr.s_addr = INADDR_NONE; 156 } 157 158 return ipaddr; 159 } 160 161 static const struct speeds { 162 unsigned nspeed; 163 speed_t speed; 164 } speeds[] = { 165 #ifdef B50 166 { 50, B50, }, 167 #endif 168 #ifdef B75 169 { 75, B75, }, 170 #endif 171 #ifdef B110 172 { 110, B110, }, 173 #endif 174 #ifdef B134 175 { 134, B134, }, 176 #endif 177 #ifdef B150 178 { 150, B150, }, 179 #endif 180 #ifdef B200 181 { 200, B200, }, 182 #endif 183 #ifdef B300 184 { 300, B300, }, 185 #endif 186 #ifdef B600 187 { 600, B600, }, 188 #endif 189 #ifdef B1200 190 { 1200, B1200, }, 191 #endif 192 #ifdef B1800 193 { 1800, B1800, }, 194 #endif 195 #ifdef B2400 196 { 2400, B2400, }, 197 #endif 198 #ifdef B4800 199 { 4800, B4800, }, 200 #endif 201 #ifdef B9600 202 { 9600, B9600, }, 203 #endif 204 #ifdef B19200 205 { 19200, B19200, }, 206 #endif 207 #ifdef B38400 208 { 38400, B38400, }, 209 #endif 210 #ifndef _POSIX_SOURCE 211 #ifdef B7200 212 { 7200, B7200, }, 213 #endif 214 #ifdef B14400 215 { 14400, B14400, }, 216 #endif 217 #ifdef B28800 218 { 28800, B28800, }, 219 #endif 220 #ifdef B57600 221 { 57600, B57600, }, 222 #endif 223 #ifdef B76800 224 { 76800, B76800, }, 225 #endif 226 #ifdef B115200 227 { 115200, B115200, }, 228 #endif 229 #ifdef B230400 230 { 230400, B230400, }, 231 #endif 232 #ifdef B460800 233 { 460800, B460800, }, 234 #endif 235 #ifdef B921600 236 { 921600, B921600, }, 237 #endif 238 #ifdef EXTA 239 { 19200, EXTA, }, 240 #endif 241 #ifdef EXTB 242 { 38400, EXTB, }, 243 #endif 244 #endif /* _POSIX_SOURCE */ 245 { 0, 0 } 246 }; 247 248 unsigned 249 SpeedToUnsigned(speed_t speed) 250 { 251 const struct speeds *sp; 252 253 for (sp = speeds; sp->nspeed; sp++) { 254 if (sp->speed == speed) { 255 return sp->nspeed; 256 } 257 } 258 return 0; 259 } 260 261 speed_t 262 UnsignedToSpeed(unsigned nspeed) 263 { 264 const struct speeds *sp; 265 266 for (sp = speeds; sp->nspeed; sp++) { 267 if (sp->nspeed == nspeed) { 268 return sp->speed; 269 } 270 } 271 return B0; 272 } 273 274 char * 275 findblank(char *p, int flags) 276 { 277 int instring; 278 279 instring = 0; 280 while (*p) { 281 if (*p == '\\') { 282 if (flags & PARSE_REDUCE) { 283 memmove(p, p + 1, strlen(p)); 284 if (!*p) 285 break; 286 } else 287 p++; 288 } else if (*p == '"') { 289 memmove(p, p + 1, strlen(p)); 290 instring = !instring; 291 continue; 292 } else if (!instring && (issep(*p) || 293 (*p == '#' && !(flags & PARSE_NOHASH)))) 294 return p; 295 p++; 296 } 297 298 return instring ? NULL : p; 299 } 300 301 int 302 MakeArgs(char *script, char **pvect, int maxargs, int flags) 303 { 304 int nargs; 305 306 nargs = 0; 307 while (*script) { 308 script += strspn(script, " \t"); 309 if (*script == '#' && !(flags & PARSE_NOHASH)) { 310 *script = '\0'; 311 break; 312 } 313 if (*script) { 314 if (nargs >= maxargs - 1) 315 break; 316 *pvect++ = script; 317 nargs++; 318 script = findblank(script, flags); 319 if (script == NULL) 320 return -1; 321 else if (!(flags & PARSE_NOHASH) && *script == '#') 322 *script = '\0'; 323 else if (*script) 324 *script++ = '\0'; 325 } 326 } 327 *pvect = NULL; 328 return nargs; 329 } 330 331 const char * 332 NumStr(long val, char *buf, size_t sz) 333 { 334 static char result[23]; /* handles 64 bit numbers */ 335 336 if (buf == NULL || sz == 0) { 337 buf = result; 338 sz = sizeof result; 339 } 340 snprintf(buf, sz, "<%ld>", val); 341 return buf; 342 } 343 344 const char * 345 HexStr(long val, char *buf, size_t sz) 346 { 347 static char result[21]; /* handles 64 bit numbers */ 348 349 if (buf == NULL || sz == 0) { 350 buf = result; 351 sz = sizeof result; 352 } 353 snprintf(buf, sz, "<0x%lx>", val); 354 return buf; 355 } 356 357 const char * 358 ex_desc(int ex) 359 { 360 static char num[12]; /* Used immediately if returned */ 361 static const char * const desc[] = { 362 "normal", "start", "sock", "modem", "dial", "dead", "done", 363 "reboot", "errdead", "hangup", "term", "nodial", "nologin", 364 "redial", "reconnect" 365 }; 366 367 if (ex >= 0 && ex < (int)(sizeof desc / sizeof *desc)) 368 return desc[ex]; 369 snprintf(num, sizeof num, "%d", ex); 370 return num; 371 } 372 373 void 374 SetTitle(const char *title) 375 { 376 if (title == NULL) 377 setproctitle(NULL); 378 else if (title[0] == '-' && title[1] != '\0') 379 setproctitle("-%s", title + 1); 380 else 381 setproctitle("%s", title); 382 } 383 384 fd_set * 385 mkfdset() 386 { 387 return (fd_set *)malloc(howmany(getdtablesize(), NFDBITS) * sizeof (fd_mask)); 388 } 389 390 void 391 zerofdset(fd_set *s) 392 { 393 memset(s, '\0', howmany(getdtablesize(), NFDBITS) * sizeof (fd_mask)); 394 } 395 396 void 397 Concatinate(char *buf, size_t sz, int argc, const char *const *argv) 398 { 399 int i, n; 400 unsigned pos; 401 402 *buf = '\0'; 403 for (pos = i = 0; i < argc; i++) { 404 n = snprintf(buf + pos, sz - pos, "%s%s", i ? " " : "", argv[i]); 405 if (n < 0) { 406 buf[pos] = '\0'; 407 break; 408 } 409 if ((pos += n) >= sz) 410 break; 411 } 412 } 413 414 #if defined(__FreeBSD__) && !defined(NOKLDLOAD) 415 int 416 loadmodules(int how, const char *module, ...) 417 { 418 int loaded = 0; 419 va_list ap; 420 421 va_start(ap, module); 422 while (module != NULL) { 423 if (modfind(module) == -1) { 424 if (ID0kldload(module) == -1) { 425 if (how == LOAD_VERBOSLY) 426 log_Printf(LogWARN, "%s: Cannot load module\n", module); 427 } else 428 loaded++; 429 } 430 module = va_arg(ap, const char *); 431 } 432 va_end(ap); 433 return loaded; 434 } 435 #else 436 int 437 loadmodules(int how __unused, const char *module __unused, ...) 438 { 439 return 0; 440 } 441 #endif 442