lib/xwrap.c

   1 /* xwrap.c - wrappers around existing library functions.
   2  *
   3  * Functions with the x prefix are wrappers that either succeed or kill the
   4  * program with an error message, but never return failure. They usually have
   5  * the same arguments and return value as the function they wrap.
   6  *
   7  * Copyright 2006 Rob Landley <rob@landley.net>
   8  */
   9
  10 #include "toys.h"
  11
  12 // strcpy and strncat with size checking. Size is the total space in "dest",
  13 // including null terminator. Exit if there's not enough space for the string
  14 // (including space for the null terminator), because silently truncating is
  15 // still broken behavior. (And leaving the string unterminated is INSANE.)
  16 void xstrncpy(char *dest, char *src, size_t size)
  17 {
  18   if (strlen(src)+1 > size) error_exit("'%s' > %ld bytes", src, (long)size);
  19   strcpy(dest, src);
  20 }
  21
  22 void xstrncat(char *dest, char *src, size_t size)
  23 {
  24   long len = strlen(dest);
  25
  26   if (len+strlen(src)+1 > size)
  27     error_exit("'%s%s' > %ld bytes", dest, src, (long)size);
  28   strcpy(dest+len, src);
  29 }
  30
  31 // We replaced exit(), _exit(), and atexit() with xexit(), _xexit(), and
  32 // sigatexit(). This gives _xexit() the option to siglongjmp(toys.rebound, 1)
  33 // instead of exiting, lets xexit() report stdout flush failures to stderr
  34 // and change the exit code to indicate error, lets our toys.exit function
  35 // change happen for signal exit paths and lets us remove the functions
  36 // after we've called them.
  37
  38 void _xexit(void)
  39 {
  40   if (toys.rebound) siglongjmp(*toys.rebound, 1);
  41
  42   _exit(toys.exitval);
  43 }
  44
  45 void xexit(void)
  46 {
  47   // Call toys.xexit functions in reverse order added.
  48   while (toys.xexit) {
  49     // This is typecasting xexit->arg to a function pointer,then calling it.
  50     // Using the invalid signal number 0 lets the signal handlers distinguish
  51     // an actual signal from a regular exit.
  52     ((void (*)(int))(toys.xexit->arg))(0);
  53
  54     free(llist_pop(&toys.xexit));
  55   }
  56   if (fflush(NULL) || ferror(stdout))
  57     if (!toys.exitval) perror_msg("write");
  58   _xexit();
  59 }
  60
  61 void *xmmap(void *addr, size_t length, int prot, int flags, int fd, off_t off)
  62 {
  63   void *ret = mmap(addr, length, prot, flags, fd, off);
  64   if (ret == MAP_FAILED) perror_exit("mmap");
  65   return ret;
  66 }
  67
  68 // Die unless we can allocate memory.
  69 void *xmalloc(size_t size)
  70 {
  71   void *ret = malloc(size);
  72   if (!ret) error_exit("xmalloc(%ld)", (long)size);
  73
  74   return ret;
  75 }
  76
  77 // Die unless we can allocate prezeroed memory.
  78 void *xzalloc(size_t size)
  79 {
  80   void *ret = xmalloc(size);
  81   memset(ret, 0, size);
  82   return ret;
  83 }
  84
  85 // Die unless we can change the size of an existing allocation, possibly
  86 // moving it.  (Notice different arguments from libc function.)
  87 void *xrealloc(void *ptr, size_t size)
  88 {
  89   ptr = realloc(ptr, size);
  90   if (!ptr) error_exit("xrealloc");
  91
  92   return ptr;
  93 }
  94
  95 // Die unless we can allocate a copy of this many bytes of string.
  96 char *xstrndup(char *s, size_t n)
  97 {
  98   char *ret = strndup(s, ++n);
  99
 100   if (!ret) error_exit("xstrndup");
 101   ret[--n] = 0;
 102
 103   return ret;
 104 }
 105
 106 // Die unless we can allocate a copy of this string.
 107 char *xstrdup(char *s)
 108 {
 109   return xstrndup(s, strlen(s));
 110 }
 111
 112 void *xmemdup(void *s, long len)
 113 {
 114   void *ret = xmalloc(len);
 115   memcpy(ret, s, len);
 116
 117   return ret;
 118 }
 119
 120 // Die unless we can allocate enough space to sprintf() into.
 121 char *xmprintf(char *format, ...)
 122 {
 123   va_list va, va2;
 124   int len;
 125   char *ret;
 126
 127   va_start(va, format);
 128   va_copy(va2, va);
 129
 130   // How long is it?
 131   len = vsnprintf(0, 0, format, va);
 132   len++;
 133   va_end(va);
 134
 135   // Allocate and do the sprintf()
 136   ret = xmalloc(len);
 137   vsnprintf(ret, len, format, va2);
 138   va_end(va2);
 139
 140   return ret;
 141 }
 142
 143 void xprintf(char *format, ...)
 144 {
 145   va_list va;
 146   va_start(va, format);
 147
 148   vprintf(format, va);
 149   va_end(va);
 150   if (fflush(stdout) || ferror(stdout)) perror_exit("write");
 151 }
 152
 153 void xputs(char *s)
 154 {
 155   if (EOF == puts(s) || fflush(stdout) || ferror(stdout)) perror_exit("write");
 156 }
 157
 158 void xputc(char c)
 159 {
 160   if (EOF == fputc(c, stdout) || fflush(stdout) || ferror(stdout))
 161     perror_exit("write");
 162 }
 163
 164 void xflush(void)
 165 {
 166   if (fflush(stdout) || ferror(stdout)) perror_exit("write");;
 167 }
 168
 169 // This is called through the XVFORK macro because parent/child of vfork
 170 // share a stack, so child returning from a function would stomp the return
 171 // address parent would need. Solution: make vfork() an argument so processes
 172 // diverge before function gets called.
 173 pid_t __attribute__((returns_twice)) xvforkwrap(pid_t pid)
 174 {
 175   if (pid == -1) perror_exit("vfork");
 176
 177   // Signal to xexec() and friends that we vforked so can't recurse
 178   toys.stacktop = 0;
 179
 180   return pid;
 181 }
 182
 183 // Die unless we can exec argv[] (or run builtin command).  Note that anything
 184 // with a path isn't a builtin, so /bin/sh won't match the builtin sh.
 185 void xexec(char **argv)
 186 {
 187   // Only recurse to builtin when we have multiplexer and !vfork context.
 188   if (CFG_TOYBOX && !CFG_TOYBOX_NORECURSE && toys.stacktop) toy_exec(argv);
 189   execvp(argv[0], argv);
 190
 191   perror_msg("exec %s", argv[0]);
 192   toys.exitval = 127;
 193   if (!CFG_TOYBOX_FORK) _exit(toys.exitval);
 194   xexit();
 195 }
 196
 197 // Spawn child process, capturing stdin/stdout.
 198 // argv[]: command to exec. If null, child re-runs original program with
 199 //         toys.stacktop zeroed.
 200 // pipes[2]: stdin, stdout of new process, only allocated if zero on way in,
 201 //           pass NULL to skip pipe allocation entirely.
 202 // return: pid of child process
 203 pid_t xpopen_both(char **argv, int *pipes)
 204 {
 205   int cestnepasun[4], pid;
 206
 207   // Make the pipes? Note this won't set either pipe to 0 because if fds are
 208   // allocated in order and if fd0 was free it would go to cestnepasun[0]
 209   if (pipes) {
 210     for (pid = 0; pid < 2; pid++) {
 211       if (pipes[pid] != 0) continue;
 212       if (pipe(cestnepasun+(2*pid))) perror_exit("pipe");
 213       pipes[pid] = cestnepasun[pid+1];
 214     }
 215   }
 216
 217   // Child process.
 218   if (!(pid = CFG_TOYBOX_FORK ? xfork() : XVFORK())) {
 219     // Dance of the stdin/stdout redirection.
 220     if (pipes) {
 221       // if we had no stdin/out, pipe handles could overlap, so test for it
 222       // and free up potentially overlapping pipe handles before reuse
 223       if (pipes[1] != -1) close(cestnepasun[2]);
 224       if (pipes[0] != -1) {
 225         close(cestnepasun[1]);
 226         if (cestnepasun[0]) {
 227           dup2(cestnepasun[0], 0);
 228           close(cestnepasun[0]);
 229         }
 230       }
 231       if (pipes[1] != -1) {
 232         dup2(cestnepasun[3], 1);
 233         dup2(cestnepasun[3], 2);
 234         if (cestnepasun[3] > 2 || !cestnepasun[3]) close(cestnepasun[3]);
 235       }
 236     }
 237     if (argv) xexec(argv);
 238
 239     // In fork() case, force recursion because we know it's us.
 240     if (CFG_TOYBOX_FORK) {
 241       toy_init(toys.which, toys.argv);
 242       toys.stacktop = 0;
 243       toys.which->toy_main();
 244       xexit();
 245     // In vfork() case, exec /proc/self/exe with high bit of first letter set
 246     // to tell main() we reentered.
 247     } else {
 248       char *s = "/proc/self/exe";
 249
 250       // We did a nommu-friendly vfork but must exec to continue.
 251       // setting high bit of argv[0][0] to let new process know
 252       **toys.argv |= 0x80;
 253       execv(s, toys.argv);
 254       perror_msg_raw(s);
 255
 256       _exit(127);
 257     }
 258   }
 259
 260   // Parent process
 261   if (!CFG_TOYBOX_FORK) **toys.argv &= 0x7f;
 262   if (pipes) {
 263     if (pipes[0] != -1) close(cestnepasun[0]);
 264     if (pipes[1] != -1) close(cestnepasun[3]);
 265   }
 266
 267   return pid;
 268 }
 269
 270 // Wait for child process to exit, then return adjusted exit code.
 271 int xwaitpid(pid_t pid)
 272 {
 273   int status;
 274
 275   while (-1 == waitpid(pid, &status, 0) && errno == EINTR);
 276
 277   return WIFEXITED(status) ? WEXITSTATUS(status) : WTERMSIG(status)+127;
 278 }
 279
 280 int xpclose_both(pid_t pid, int *pipes)
 281 {
 282   if (pipes) {
 283     close(pipes[0]);
 284     close(pipes[1]);
 285   }
 286
 287   return xwaitpid(pid);
 288 }
 289
 290 // Wrapper to xpopen with a pipe for just one of stdin/stdout
 291 pid_t xpopen(char **argv, int *pipe, int isstdout)
 292 {
 293   int pipes[2], pid;
 294
 295   pipes[!isstdout] = -1;
 296   pipes[!!isstdout] = 0;
 297   pid = xpopen_both(argv, pipes);
 298   *pipe = pid ? pipes[!!isstdout] : -1;
 299
 300   return pid;
 301 }
 302
 303 int xpclose(pid_t pid, int pipe)
 304 {
 305   close(pipe);
 306
 307   return xpclose_both(pid, 0);
 308 }
 309
 310 // Call xpopen and wait for it to finish, keeping existing stdin/stdout.
 311 int xrun(char **argv)
 312 {
 313   return xpclose_both(xpopen_both(argv, 0), 0);
 314 }
 315
 316 void xaccess(char *path, int flags)
 317 {
 318   if (access(path, flags)) perror_exit("Can't access '%s'", path);
 319 }
 320
 321 // Die unless we can delete a file.  (File must exist to be deleted.)
 322 void xunlink(char *path)
 323 {
 324   if (unlink(path)) perror_exit("unlink '%s'", path);
 325 }
 326
 327 // Die unless we can open/create a file, returning file descriptor.
 328 // The meaning of O_CLOEXEC is reversed (it defaults on, pass it to disable)
 329 // and WARN_ONLY tells us not to exit.
 330 int xcreate_stdio(char *path, int flags, int mode)
 331 {
 332   int fd = open(path, (flags^O_CLOEXEC)&~WARN_ONLY, mode);
 333
 334   if (fd == -1) ((mode&WARN_ONLY) ? perror_msg_raw : perror_exit_raw)(path);
 335   return fd;
 336 }
 337
 338 // Die unless we can open a file, returning file descriptor.
 339 int xopen_stdio(char *path, int flags)
 340 {
 341   return xcreate_stdio(path, flags, 0);
 342 }
 343
 344 void xpipe(int *pp)
 345 {
 346   if (pipe(pp)) perror_exit("xpipe");
 347 }
 348
 349 void xclose(int fd)
 350 {
 351   if (close(fd)) perror_exit("xclose");
 352 }
 353
 354 int xdup(int fd)
 355 {
 356   if (fd != -1) {
 357     fd = dup(fd);
 358     if (fd == -1) perror_exit("xdup");
 359   }
 360   return fd;
 361 }
 362
 363 // Move file descriptor above stdin/stdout/stderr, using /dev/null to consume
 364 // old one. (We should never be called with stdin/stdout/stderr closed, but...)
 365 int notstdio(int fd)
 366 {
 367   if (fd<0) return fd;
 368
 369   while (fd<3) {
 370     int fd2 = xdup(fd);
 371
 372     close(fd);
 373     xopen_stdio("/dev/null", O_RDWR);
 374     fd = fd2;
 375   }
 376
 377   return fd;
 378 }
 379
 380 // Create a file but don't return stdin/stdout/stderr
 381 int xcreate(char *path, int flags, int mode)
 382 {
 383   return notstdio(xcreate_stdio(path, flags, mode));
 384 }
 385
 386 // Open a file descriptor NOT in stdin/stdout/stderr
 387 int xopen(char *path, int flags)
 388 {
 389   return notstdio(xopen_stdio(path, flags));
 390 }
 391
 392 // Open read only, treating "-" as a synonym for stdin, defaulting to warn only
 393 int openro(char *path, int flags)
 394 {
 395   if (!strcmp(path, "-")) return 0;
 396
 397   return xopen(path, flags^WARN_ONLY);
 398 }
 399
 400 // Open read only, treating "-" as a synonym for stdin.
 401 int xopenro(char *path)
 402 {
 403   return openro(path, O_RDONLY|WARN_ONLY);
 404 }
 405
 406 FILE *xfdopen(int fd, char *mode)
 407 {
 408   FILE *f = fdopen(fd, mode);
 409
 410   if (!f) perror_exit("xfdopen");
 411
 412   return f;
 413 }
 414
 415 // Die unless we can open/create a file, returning FILE *.
 416 FILE *xfopen(char *path, char *mode)
 417 {
 418   FILE *f = fopen(path, mode);
 419   if (!f) perror_exit("No file %s", path);
 420   return f;
 421 }
 422
 423 // Die if there's an error other than EOF.
 424 size_t xread(int fd, void *buf, size_t len)
 425 {
 426   ssize_t ret = read(fd, buf, len);
 427   if (ret < 0) perror_exit("xread");
 428
 429   return ret;
 430 }
 431
 432 void xreadall(int fd, void *buf, size_t len)
 433 {
 434   if (len != readall(fd, buf, len)) perror_exit("xreadall");
 435 }
 436
 437 // There's no xwriteall(), just xwrite().  When we read, there may or may not
 438 // be more data waiting.  When we write, there is data and it had better go
 439 // somewhere.
 440
 441 void xwrite(int fd, void *buf, size_t len)
 442 {
 443   if (len != writeall(fd, buf, len)) perror_exit("xwrite");
 444 }
 445
 446 // Die if lseek fails, probably due to being called on a pipe.
 447
 448 off_t xlseek(int fd, off_t offset, int whence)
 449 {
 450   offset = lseek(fd, offset, whence);
 451   if (offset<0) perror_exit("lseek");
 452
 453   return offset;
 454 }
 455
 456 char *xgetcwd(void)
 457 {
 458   char *buf = getcwd(NULL, 0);
 459   if (!buf) perror_exit("xgetcwd");
 460
 461   return buf;
 462 }
 463
 464 void xstat(char *path, struct stat *st)
 465 {
 466   if(stat(path, st)) perror_exit("Can't stat %s", path);
 467 }
 468
 469 // Cannonicalize path, even to file with one or more missing components at end.
 470 // if exact, require last path component to exist
 471 char *xabspath(char *path, int exact)
 472 {
 473   struct string_list *todo, *done = 0;
 474   int try = 9999, dirfd = open("/", 0);;
 475   char *ret;
 476
 477   // If this isn't an absolute path, start with cwd.
 478   if (*path != '/') {
 479     char *temp = xgetcwd();
 480
 481     splitpath(path, splitpath(temp, &todo));
 482     free(temp);
 483   } else splitpath(path, &todo);
 484
 485   // Iterate through path components
 486   while (todo) {
 487     struct string_list *new = llist_pop(&todo), **tail;
 488     ssize_t len;
 489
 490     if (!try--) {
 491       errno = ELOOP;
 492       goto error;
 493     }
 494
 495     // Removable path componenents.
 496     if (!strcmp(new->str, ".") || !strcmp(new->str, "..")) {
 497       int x = new->str[1];
 498
 499       free(new);
 500       if (x) {
 501         if (done) free(llist_pop(&done));
 502         len = 0;
 503       } else continue;
 504
 505     // Is this a symlink?
 506     } else len = readlinkat(dirfd, new->str, libbuf, sizeof(libbuf));
 507
 508     if (len>4095) goto error;
 509     if (len<1) {
 510       int fd;
 511       char *s = "..";
 512
 513       // For .. just move dirfd
 514       if (len) {
 515         // Not a symlink: add to linked list, move dirfd, fail if error
 516         if ((exact || todo) && errno != EINVAL) goto error;
 517         new->next = done;
 518         done = new;
 519         if (errno == EINVAL && !todo) break;
 520         s = new->str;
 521       }
 522       fd = openat(dirfd, s, 0);
 523       if (fd == -1 && (exact || todo || errno != ENOENT)) goto error;
 524       close(dirfd);
 525       dirfd = fd;
 526       continue;
 527     }
 528
 529     // If this symlink is to an absolute path, discard existing resolved path
 530     libbuf[len] = 0;
 531     if (*libbuf == '/') {
 532       llist_traverse(done, free);
 533       done=0;
 534       close(dirfd);
 535       dirfd = open("/", 0);
 536     }
 537     free(new);
 538
 539     // prepend components of new path. Note symlink to "/" will leave new NULL
 540     tail = splitpath(libbuf, &new);
 541
 542     // symlink to "/" will return null and leave tail alone
 543     if (new) {
 544       *tail = todo;
 545       todo = new;
 546     }
 547   }
 548   close(dirfd);
 549
 550   // At this point done has the path, in reverse order. Reverse list while
 551   // calculating buffer length.
 552
 553   try = 2;
 554   while (done) {
 555     struct string_list *temp = llist_pop(&done);;
 556
 557     if (todo) try++;
 558     try += strlen(temp->str);
 559     temp->next = todo;
 560     todo = temp;
 561   }
 562
 563   // Assemble return buffer
 564
 565   ret = xmalloc(try);
 566   *ret = '/';
 567   ret [try = 1] = 0;
 568   while (todo) {
 569     if (try>1) ret[try++] = '/';
 570     try = stpcpy(ret+try, todo->str) - ret;
 571     free(llist_pop(&todo));
 572   }
 573
 574   return ret;
 575
 576 error:
 577   close(dirfd);
 578   llist_traverse(todo, free);
 579   llist_traverse(done, free);
 580
 581   return NULL;
 582 }
 583
 584 void xchdir(char *path)
 585 {
 586   if (chdir(path)) error_exit("chdir '%s'", path);
 587 }
 588
 589 void xchroot(char *path)
 590 {
 591   if (chroot(path)) error_exit("chroot '%s'", path);
 592   xchdir("/");
 593 }
 594
 595 struct passwd *xgetpwuid(uid_t uid)
 596 {
 597   struct passwd *pwd = getpwuid(uid);
 598   if (!pwd) error_exit("bad uid %ld", (long)uid);
 599   return pwd;
 600 }
 601
 602 struct group *xgetgrgid(gid_t gid)
 603 {
 604   struct group *group = getgrgid(gid);
 605
 606   if (!group) perror_exit("gid %ld", (long)gid);
 607   return group;
 608 }
 609
 610 unsigned xgetuid(char *name)
 611 {
 612   struct passwd *up = getpwnam(name);
 613   char *s = 0;
 614   long uid;
 615
 616   if (up) return up->pw_uid;
 617
 618   uid = estrtol(name, &s, 10);
 619   if (!errno && s && !*s && uid>=0 && uid<=UINT_MAX) return uid;
 620
 621   error_exit("bad user '%s'", name);
 622 }
 623
 624 unsigned xgetgid(char *name)
 625 {
 626   struct group *gr = getgrnam(name);
 627   char *s = 0;
 628   long gid;
 629
 630   if (gr) return gr->gr_gid;
 631
 632   gid = estrtol(name, &s, 10);
 633   if (!errno && s && !*s && gid>=0 && gid<=UINT_MAX) return gid;
 634
 635   error_exit("bad group '%s'", name);
 636 }
 637
 638 struct passwd *xgetpwnam(char *name)
 639 {
 640   struct passwd *up = getpwnam(name);
 641
 642   if (!up) perror_exit("user '%s'", name);
 643   return up;
 644 }
 645
 646 struct group *xgetgrnam(char *name)
 647 {
 648   struct group *gr = getgrnam(name);
 649
 650   if (!gr) perror_exit("group '%s'", name);
 651   return gr;
 652 }
 653
 654 // setuid() can fail (for example, too many processes belonging to that user),
 655 // which opens a security hole if the process continues as the original user.
 656
 657 void xsetuser(struct passwd *pwd)
 658 {
 659   if (initgroups(pwd->pw_name, pwd->pw_gid) || setgid(pwd->pw_uid)
 660       || setuid(pwd->pw_uid)) perror_exit("xsetuser '%s'", pwd->pw_name);
 661 }
 662
 663 // This can return null (meaning file not found).  It just won't return null
 664 // for memory allocation reasons.
 665 char *xreadlink(char *name)
 666 {
 667   int len, size = 0;
 668   char *buf = 0;
 669
 670   // Grow by 64 byte chunks until it's big enough.
 671   for(;;) {
 672     size +=64;
 673     buf = xrealloc(buf, size);
 674     len = readlink(name, buf, size);
 675
 676     if (len<0) {
 677       free(buf);
 678       return 0;
 679     }
 680     if (len<size) {
 681       buf[len]=0;
 682       return buf;
 683     }
 684   }
 685 }
 686
 687 char *xreadfile(char *name, char *buf, off_t len)
 688 {
 689   if (!(buf = readfile(name, buf, len))) perror_exit("Bad '%s'", name);
 690
 691   return buf;
 692 }
 693
 694 // The data argument to ioctl() is actually long, but it's usually used as
 695 // a pointer. If you need to feed in a number, do (void *)(long) typecast.
 696 int xioctl(int fd, int request, void *data)
 697 {
 698   int rc;
 699
 700   errno = 0;
 701   rc = ioctl(fd, request, data);
 702   if (rc == -1 && errno) perror_exit("ioctl %x", request);
 703
 704   return rc;
 705 }
 706
 707 // Open a /var/run/NAME.pid file, dying if we can't write it or if it currently
 708 // exists and is this executable.
 709 void xpidfile(char *name)
 710 {
 711   char pidfile[256], spid[32];
 712   int i, fd;
 713   pid_t pid;
 714
 715   sprintf(pidfile, "/var/run/%s.pid", name);
 716   // Try three times to open the sucker.
 717   for (i=0; i<3; i++) {
 718     fd = open(pidfile, O_CREAT|O_EXCL|O_WRONLY, 0644);
 719     if (fd != -1) break;
 720
 721     // If it already existed, read it.  Loop for race condition.
 722     fd = open(pidfile, O_RDONLY);
 723     if (fd == -1) continue;
 724
 725     // Is the old program still there?
 726     spid[xread(fd, spid, sizeof(spid)-1)] = 0;
 727     close(fd);
 728     pid = atoi(spid);
 729     if (pid < 1 || (kill(pid, 0) && errno == ESRCH)) unlink(pidfile);
 730
 731     // An else with more sanity checking might be nice here.
 732   }
 733
 734   if (i == 3) error_exit("xpidfile %s", name);
 735
 736   xwrite(fd, spid, sprintf(spid, "%ld\n", (long)getpid()));
 737   close(fd);
 738 }
 739
 740 // Copy the rest of in to out and close both files.
 741
 742 long long xsendfile(int in, int out)
 743 {
 744   long long total = 0;
 745   long len;
 746
 747   if (in<0) return 0;
 748   for (;;) {
 749     len = xread(in, libbuf, sizeof(libbuf));
 750     if (len<1) break;
 751     xwrite(out, libbuf, len);
 752     total += len;
 753   }
 754
 755   return total;
 756 }
 757
 758 // parse fractional seconds with optional s/m/h/d suffix
 759 long xparsetime(char *arg, long units, long *fraction)
 760 {
 761   double d;
 762   long l;
 763
 764   if (CFG_TOYBOX_FLOAT) d = strtod(arg, &arg);
 765   else l = strtoul(arg, &arg, 10);
 766
 767   // Parse suffix
 768   if (*arg) {
 769     int ismhd[]={1,60,3600,86400}, i = stridx("smhd", *arg);
 770
 771     if (i == -1) error_exit("Unknown suffix '%c'", *arg);
 772     if (CFG_TOYBOX_FLOAT) d *= ismhd[i];
 773     else l *= ismhd[i];
 774   }
 775
 776   if (CFG_TOYBOX_FLOAT) {
 777     l = (long)d;
 778     if (fraction) *fraction = units*(d-l);
 779   } else if (fraction) *fraction = 0;
 780
 781   return l;
 782 }
 783
 784 // Compile a regular expression into a regex_t
 785 void xregcomp(regex_t *preg, char *regex, int cflags)
 786 {
 787   int rc = regcomp(preg, regex, cflags);
 788
 789   if (rc) {
 790     regerror(rc, preg, libbuf, sizeof(libbuf));
 791     error_exit("xregcomp: %s", libbuf);
 792   }
 793 }
 794
 795 char *xtzset(char *new)
 796 {
 797   char *old = getenv("TZ");
 798
 799   if (old) old = xstrdup(old);
 800   if (new ? setenv("TZ", new, 1) : unsetenv("TZ")) perror_exit("setenv");
 801   tzset();
 802
 803   return old;
 804 }
 805
 806 // Set a signal handler
 807 void xsignal(int signal, void *handler)
 808 {
 809   struct sigaction *sa = (void *)libbuf;
 810
 811   memset(sa, 0, sizeof(struct sigaction));
 812   sa->sa_handler = handler;
 813
 814   if (sigaction(signal, sa, 0)) perror_exit("xsignal %d", signal);
 815 }