1 /* $NetBSD: util.c,v 1.57 2020/07/03 08:13:23 rillig Exp $ */ 2 3 /* 4 * Missing stuff from OS's 5 * 6 * $Id: util.c,v 1.35 2020/07/04 18:16:55 sjg Exp $ 7 */ 8 #if defined(__MINT__) || defined(__linux__) 9 #include <signal.h> 10 #endif 11 12 #include "make.h" 13 14 #ifndef MAKE_NATIVE 15 static char rcsid[] = "$NetBSD: util.c,v 1.57 2020/07/03 08:13:23 rillig Exp $"; 16 #else 17 #ifndef lint 18 __RCSID("$NetBSD: util.c,v 1.57 2020/07/03 08:13:23 rillig Exp $"); 19 #endif 20 #endif 21 22 #include <errno.h> 23 #include <time.h> 24 #include <signal.h> 25 26 #if !defined(HAVE_STRERROR) 27 extern int errno, sys_nerr; 28 extern char *sys_errlist[]; 29 30 char * 31 strerror(int e) 32 { 33 static char buf[100]; 34 if (e < 0 || e >= sys_nerr) { 35 snprintf(buf, sizeof(buf), "Unknown error %d", e); 36 return buf; 37 } 38 else 39 return sys_errlist[e]; 40 } 41 #endif 42 43 #if !defined(HAVE_GETENV) || !defined(HAVE_SETENV) || !defined(HAVE_UNSETENV) 44 extern char **environ; 45 46 static char * 47 findenv(const char *name, int *offset) 48 { 49 size_t i, len; 50 char *p, *q; 51 52 len = strlen(name); 53 for (i = 0; (q = environ[i]); i++) { 54 p = strchr(q, '='); 55 if (p == NULL || p - q != len) 56 continue; 57 if (strncmp(name, q, len) == 0) { 58 *offset = i; 59 return q + len + 1; 60 } 61 } 62 *offset = i; 63 return NULL; 64 } 65 66 char * 67 getenv(const char *name) 68 { 69 int offset; 70 71 return findenv(name, &offset); 72 } 73 74 int 75 unsetenv(const char *name) 76 { 77 char **p; 78 int offset; 79 80 if (name == NULL || *name == '\0' || strchr(name, '=') != NULL) { 81 errno = EINVAL; 82 return -1; 83 } 84 85 while (findenv(name, &offset)) { /* if set multiple times */ 86 for (p = &environ[offset];; ++p) 87 if (!(*p = *(p + 1))) 88 break; 89 } 90 return 0; 91 } 92 93 int 94 setenv(const char *name, const char *value, int rewrite) 95 { 96 char *c, **newenv; 97 const char *cc; 98 size_t l_value, size; 99 int offset; 100 101 if (name == NULL || value == NULL) { 102 errno = EINVAL; 103 return -1; 104 } 105 106 if (*value == '=') /* no `=' in value */ 107 ++value; 108 l_value = strlen(value); 109 110 /* find if already exists */ 111 if ((c = findenv(name, &offset))) { 112 if (!rewrite) 113 return 0; 114 if (strlen(c) >= l_value) /* old larger; copy over */ 115 goto copy; 116 } else { /* create new slot */ 117 size = sizeof(char *) * (offset + 2); 118 if (savedEnv == environ) { /* just increase size */ 119 if ((newenv = realloc(savedEnv, size)) == NULL) 120 return -1; 121 savedEnv = newenv; 122 } else { /* get new space */ 123 /* 124 * We don't free here because we don't know if 125 * the first allocation is valid on all OS's 126 */ 127 if ((savedEnv = malloc(size)) == NULL) 128 return -1; 129 (void)memcpy(savedEnv, environ, size - sizeof(char *)); 130 } 131 environ = savedEnv; 132 environ[offset + 1] = NULL; 133 } 134 for (cc = name; *cc && *cc != '='; ++cc) /* no `=' in name */ 135 continue; 136 size = cc - name; 137 /* name + `=' + value */ 138 if ((environ[offset] = malloc(size + l_value + 2)) == NULL) 139 return -1; 140 c = environ[offset]; 141 (void)memcpy(c, name, size); 142 c += size; 143 *c++ = '='; 144 copy: 145 (void)memcpy(c, value, l_value + 1); 146 return 0; 147 } 148 149 #ifdef TEST 150 int 151 main(int argc, char *argv[]) 152 { 153 setenv(argv[1], argv[2], 0); 154 printf("%s\n", getenv(argv[1])); 155 unsetenv(argv[1]); 156 printf("%s\n", getenv(argv[1])); 157 return 0; 158 } 159 #endif 160 161 #endif 162 163 164 #if defined(__hpux__) || defined(__hpux) 165 /* strrcpy(): 166 * Like strcpy, going backwards and returning the new pointer 167 */ 168 static char * 169 strrcpy(char *ptr, char *str) 170 { 171 int len = strlen(str); 172 173 while (len) 174 *--ptr = str[--len]; 175 176 return ptr; 177 } /* end strrcpy */ 178 179 180 char *sys_siglist[] = { 181 "Signal 0", 182 "Hangup", /* SIGHUP */ 183 "Interrupt", /* SIGINT */ 184 "Quit", /* SIGQUIT */ 185 "Illegal instruction", /* SIGILL */ 186 "Trace/BPT trap", /* SIGTRAP */ 187 "IOT trap", /* SIGIOT */ 188 "EMT trap", /* SIGEMT */ 189 "Floating point exception", /* SIGFPE */ 190 "Killed", /* SIGKILL */ 191 "Bus error", /* SIGBUS */ 192 "Segmentation fault", /* SIGSEGV */ 193 "Bad system call", /* SIGSYS */ 194 "Broken pipe", /* SIGPIPE */ 195 "Alarm clock", /* SIGALRM */ 196 "Terminated", /* SIGTERM */ 197 "User defined signal 1", /* SIGUSR1 */ 198 "User defined signal 2", /* SIGUSR2 */ 199 "Child exited", /* SIGCLD */ 200 "Power-fail restart", /* SIGPWR */ 201 "Virtual timer expired", /* SIGVTALRM */ 202 "Profiling timer expired", /* SIGPROF */ 203 "I/O possible", /* SIGIO */ 204 "Window size changes", /* SIGWINDOW */ 205 "Stopped (signal)", /* SIGSTOP */ 206 "Stopped", /* SIGTSTP */ 207 "Continued", /* SIGCONT */ 208 "Stopped (tty input)", /* SIGTTIN */ 209 "Stopped (tty output)", /* SIGTTOU */ 210 "Urgent I/O condition", /* SIGURG */ 211 "Remote lock lost (NFS)", /* SIGLOST */ 212 "Signal 31", /* reserved */ 213 "DIL signal" /* SIGDIL */ 214 }; 215 #endif /* __hpux__ || __hpux */ 216 217 #if defined(__hpux__) || defined(__hpux) 218 #include <sys/types.h> 219 #include <sys/syscall.h> 220 #include <sys/signal.h> 221 #include <sys/stat.h> 222 #include <dirent.h> 223 #include <sys/time.h> 224 #include <unistd.h> 225 226 int 227 killpg(int pid, int sig) 228 { 229 return kill(-pid, sig); 230 } 231 232 #if !defined(BSD) && !defined(d_fileno) 233 # define d_fileno d_ino 234 #endif 235 236 #ifndef DEV_DEV_COMPARE 237 # define DEV_DEV_COMPARE(a, b) ((a) == (b)) 238 #endif 239 #define ISDOT(c) ((c)[0] == '.' && (((c)[1] == '\0') || ((c)[1] == '/'))) 240 #define ISDOTDOT(c) ((c)[0] == '.' && ISDOT(&((c)[1]))) 241 242 char * 243 getwd(char *pathname) 244 { 245 DIR *dp; 246 struct dirent *d; 247 extern int errno; 248 249 struct stat st_root, st_cur, st_next, st_dotdot; 250 char pathbuf[MAXPATHLEN], nextpathbuf[MAXPATHLEN * 2]; 251 char *pathptr, *nextpathptr, *cur_name_add; 252 253 /* find the inode of root */ 254 if (stat("/", &st_root) == -1) { 255 (void)sprintf(pathname, 256 "getwd: Cannot stat \"/\" (%s)", strerror(errno)); 257 return NULL; 258 } 259 pathbuf[MAXPATHLEN - 1] = '\0'; 260 pathptr = &pathbuf[MAXPATHLEN - 1]; 261 nextpathbuf[MAXPATHLEN - 1] = '\0'; 262 cur_name_add = nextpathptr = &nextpathbuf[MAXPATHLEN - 1]; 263 264 /* find the inode of the current directory */ 265 if (lstat(".", &st_cur) == -1) { 266 (void)sprintf(pathname, 267 "getwd: Cannot stat \".\" (%s)", strerror(errno)); 268 return NULL; 269 } 270 nextpathptr = strrcpy(nextpathptr, "../"); 271 272 /* Descend to root */ 273 for (;;) { 274 275 /* look if we found root yet */ 276 if (st_cur.st_ino == st_root.st_ino && 277 DEV_DEV_COMPARE(st_cur.st_dev, st_root.st_dev)) { 278 (void)strcpy(pathname, *pathptr != '/' ? "/" : pathptr); 279 return pathname; 280 } 281 282 /* open the parent directory */ 283 if (stat(nextpathptr, &st_dotdot) == -1) { 284 (void)sprintf(pathname, 285 "getwd: Cannot stat directory \"%s\" (%s)", 286 nextpathptr, strerror(errno)); 287 return NULL; 288 } 289 if ((dp = opendir(nextpathptr)) == NULL) { 290 (void)sprintf(pathname, 291 "getwd: Cannot open directory \"%s\" (%s)", 292 nextpathptr, strerror(errno)); 293 return NULL; 294 } 295 296 /* look in the parent for the entry with the same inode */ 297 if (DEV_DEV_COMPARE(st_dotdot.st_dev, st_cur.st_dev)) { 298 /* Parent has same device. No need to stat every member */ 299 for (d = readdir(dp); d != NULL; d = readdir(dp)) 300 if (d->d_fileno == st_cur.st_ino) 301 break; 302 } 303 else { 304 /* 305 * Parent has a different device. This is a mount point so we 306 * need to stat every member 307 */ 308 for (d = readdir(dp); d != NULL; d = readdir(dp)) { 309 if (ISDOT(d->d_name) || ISDOTDOT(d->d_name)) 310 continue; 311 (void)strcpy(cur_name_add, d->d_name); 312 if (lstat(nextpathptr, &st_next) == -1) { 313 (void)sprintf(pathname, 314 "getwd: Cannot stat \"%s\" (%s)", 315 d->d_name, strerror(errno)); 316 (void)closedir(dp); 317 return NULL; 318 } 319 /* check if we found it yet */ 320 if (st_next.st_ino == st_cur.st_ino && 321 DEV_DEV_COMPARE(st_next.st_dev, st_cur.st_dev)) 322 break; 323 } 324 } 325 if (d == NULL) { 326 (void)sprintf(pathname, 327 "getwd: Cannot find \".\" in \"..\""); 328 (void)closedir(dp); 329 return NULL; 330 } 331 st_cur = st_dotdot; 332 pathptr = strrcpy(pathptr, d->d_name); 333 pathptr = strrcpy(pathptr, "/"); 334 nextpathptr = strrcpy(nextpathptr, "../"); 335 (void)closedir(dp); 336 *cur_name_add = '\0'; 337 } 338 } /* end getwd */ 339 340 #endif /* __hpux */ 341 342 #if !defined(HAVE_GETCWD) 343 char * 344 getcwd(path, sz) 345 char *path; 346 int sz; 347 { 348 return getwd(path); 349 } 350 #endif 351 352 /* force posix signals */ 353 void (* 354 bmake_signal(int s, void (*a)(int)))(int) 355 { 356 struct sigaction sa, osa; 357 358 sa.sa_handler = a; 359 sigemptyset(&sa.sa_mask); 360 sa.sa_flags = SA_RESTART; 361 362 if (sigaction(s, &sa, &osa) == -1) 363 return SIG_ERR; 364 else 365 return osa.sa_handler; 366 } 367 368 #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_VASPRINTF) 369 #include <stdarg.h> 370 #endif 371 372 #if !defined(HAVE_VSNPRINTF) 373 #if !defined(__osf__) 374 #ifdef _IOSTRG 375 #define STRFLAG (_IOSTRG|_IOWRT) /* no _IOWRT: avoid stdio bug */ 376 #else 377 #if 0 378 #define STRFLAG (_IOREAD) /* XXX: Assume svr4 stdio */ 379 #endif 380 #endif /* _IOSTRG */ 381 #endif /* __osf__ */ 382 383 int 384 vsnprintf(char *s, size_t n, const char *fmt, va_list args) 385 { 386 #ifdef STRFLAG 387 FILE fakebuf; 388 389 fakebuf._flag = STRFLAG; 390 /* 391 * Some os's are char * _ptr, others are unsigned char *_ptr... 392 * We cast to void * to make everyone happy. 393 */ 394 fakebuf._ptr = (void *)s; 395 fakebuf._cnt = n-1; 396 fakebuf._file = -1; 397 _doprnt(fmt, args, &fakebuf); 398 fakebuf._cnt++; 399 putc('\0', &fakebuf); 400 if (fakebuf._cnt<0) 401 fakebuf._cnt = 0; 402 return n-fakebuf._cnt-1; 403 #else 404 #ifndef _PATH_DEVNULL 405 # define _PATH_DEVNULL "/dev/null" 406 #endif 407 /* 408 * Rats... we don't want to clobber anything... 409 * do a printf to /dev/null to see how much space we need. 410 */ 411 static FILE *nullfp; 412 int need = 0; /* XXX what's a useful error return? */ 413 414 if (!nullfp) 415 nullfp = fopen(_PATH_DEVNULL, "w"); 416 if (nullfp) { 417 need = vfprintf(nullfp, fmt, args); 418 if (need < n) 419 (void)vsprintf(s, fmt, args); 420 } 421 return need; 422 #endif 423 } 424 #endif 425 426 #if !defined(HAVE_SNPRINTF) 427 int 428 snprintf(char *s, size_t n, const char *fmt, ...) 429 { 430 va_list ap; 431 int rv; 432 433 va_start(ap, fmt); 434 rv = vsnprintf(s, n, fmt, ap); 435 va_end(ap); 436 return rv; 437 } 438 #endif 439 440 #if !defined(HAVE_STRFTIME) 441 size_t 442 strftime(char *buf, size_t len, const char *fmt, const struct tm *tm) 443 { 444 static char months[][4] = { 445 "Jan", "Feb", "Mar", "Apr", "May", "Jun", 446 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" 447 }; 448 449 size_t s; 450 char *b = buf; 451 452 while (*fmt) { 453 if (len == 0) 454 return buf - b; 455 if (*fmt != '%') { 456 *buf++ = *fmt++; 457 len--; 458 continue; 459 } 460 switch (*fmt++) { 461 case '%': 462 *buf++ = '%'; 463 len--; 464 if (len == 0) return buf - b; 465 /*FALLTHROUGH*/ 466 case '\0': 467 *buf = '%'; 468 s = 1; 469 break; 470 case 'k': 471 s = snprintf(buf, len, "%d", tm->tm_hour); 472 break; 473 case 'M': 474 s = snprintf(buf, len, "%02d", tm->tm_min); 475 break; 476 case 'S': 477 s = snprintf(buf, len, "%02d", tm->tm_sec); 478 break; 479 case 'b': 480 if (tm->tm_mon >= 12) 481 return buf - b; 482 s = snprintf(buf, len, "%s", months[tm->tm_mon]); 483 break; 484 case 'd': 485 s = snprintf(buf, len, "%02d", tm->tm_mday); 486 break; 487 case 'Y': 488 s = snprintf(buf, len, "%d", 1900 + tm->tm_year); 489 break; 490 default: 491 s = snprintf(buf, len, "Unsupported format %c", 492 fmt[-1]); 493 break; 494 } 495 buf += s; 496 len -= s; 497 } 498 } 499 #endif 500 501 #if !defined(HAVE_KILLPG) 502 #if !defined(__hpux__) && !defined(__hpux) 503 int 504 killpg(int pid, int sig) 505 { 506 return kill(-pid, sig); 507 } 508 #endif 509 #endif 510 511 #if !defined(HAVE_WARNX) 512 static void 513 vwarnx(const char *fmt, va_list args) 514 { 515 fprintf(stderr, "%s: ", progname); 516 if ((fmt)) { 517 vfprintf(stderr, fmt, args); 518 fprintf(stderr, ": "); 519 } 520 } 521 #endif 522 523 #if !defined(HAVE_WARN) 524 static void 525 vwarn(const char *fmt, va_list args) 526 { 527 vwarnx(fmt, args); 528 fprintf(stderr, "%s\n", strerror(errno)); 529 } 530 #endif 531 532 #if !defined(HAVE_ERR) 533 static void 534 verr(int eval, const char *fmt, va_list args) 535 { 536 vwarn(fmt, args); 537 exit(eval); 538 } 539 #endif 540 541 #if !defined(HAVE_ERRX) 542 static void 543 verrx(int eval, const char *fmt, va_list args) 544 { 545 vwarnx(fmt, args); 546 exit(eval); 547 } 548 #endif 549 550 #if !defined(HAVE_ERR) 551 void 552 err(int eval, const char *fmt, ...) 553 { 554 va_list ap; 555 556 va_start(ap, fmt); 557 verr(eval, fmt, ap); 558 va_end(ap); 559 } 560 #endif 561 562 #if !defined(HAVE_ERRX) 563 void 564 errx(int eval, const char *fmt, ...) 565 { 566 va_list ap; 567 568 va_start(ap, fmt); 569 verrx(eval, fmt, ap); 570 va_end(ap); 571 } 572 #endif 573 574 #if !defined(HAVE_WARN) 575 void 576 warn(const char *fmt, ...) 577 { 578 va_list ap; 579 580 va_start(ap, fmt); 581 vwarn(fmt, ap); 582 va_end(ap); 583 } 584 #endif 585 586 #if !defined(HAVE_WARNX) 587 void 588 warnx(const char *fmt, ...) 589 { 590 va_list ap; 591 592 va_start(ap, fmt); 593 vwarnx(fmt, ap); 594 va_end(ap); 595 } 596 #endif 597