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