wrappers.h

   1
   2 #ifndef _WRAPPERS_H
   3 #define _WRAPPERS_H 1
   4
   5 #define _GNU_SOURCE 1
   6
   7 #include <errno.h>
   8 #include <error.h>
   9 #include <fcntl.h>
  10 #include <limits.h>
  11 #include <pwd.h>
  12 #include <stdarg.h>
  13 #include <stdbool.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20 #include <termios.h>
  21 #include <unistd.h>
  22
  23 #include "system.h"
  24
  25 #if !__GCC_PREREQ (5, 0)
  26 /* https://stackoverflow.com/a/1815371 */
  27 static __warn_unused_result __force_inline __nonnull ((3)) bool
  28 __builtin_mul_overflow (size_t a, size_t b, size_t *c)
  29 {
  30 # define SIZE_BIT (sizeof (size_t) * CHAR_BIT / 2)
  31 # define HI(x) (x >> SIZE_BIT)
  32 # define LO(x) ((((size_t)1 << SIZE_BIT) - 1) & x)
  33
  34   size_t s0, s1, s2, s3, x, result, carry;
  35
  36   x = LO (a) * LO (b);
  37   s0 = LO (x);
  38
  39   x = HI (a) * LO (b) + HI (x);
  40   s1 = LO (x);
  41   s2 = HI (x);
  42
  43   x = s1 + LO (a) * HI (b);
  44   s1 = LO (x);
  45
  46   x = s2 + HI (a) * HI (b) + HI (x);
  47   s2 = LO (x);
  48   s3 = HI (x);
  49
  50   result = s1 << SIZE_BIT | s0;
  51   carry = s3 << SIZE_BIT | s2;
  52
  53   *c = result;
  54
  55   return carry != 0;
  56 }
  57 # endif
  58
  59 #define mul_overflow(n, m, s) __builtin_mul_overflow (n, m, s)
  60
  61 #define edie(e, ...) (error (EXIT_FAILURE, e, __VA_ARGS__), assume (false))
  62 #define die(c, s)    (fprintf (stderr, "%s\n", s), exit (c), assume (false))
  63
  64 static inline bool program_exited_successfully (int status) __warn_unused_result __const;
  65 static inline bool
  66 program_exited_successfully (int status)
  67 {
  68   return WIFEXITED (status) && WEXITSTATUS (status) == EXIT_SUCCESS;
  69 }
  70 static inline bool program_exited_unsuccessfully (int status) __warn_unused_result __const;
  71 static inline bool
  72 program_exited_unsuccessfully (int status)
  73 {
  74   return !WIFEXITED (status) || WEXITSTATUS (status) != EXIT_SUCCESS;
  75 }
  76 static inline bool program_terminated (int status) __warn_unused_result __const;
  77 static inline bool
  78 program_terminated (int status)
  79 {
  80   return WIFEXITED (status) || (WIFSIGNALED (status) && !WIFSTOPPED (status) && !WIFCONTINUED (status));
  81 }
  82
  83 static inline int xopenat (int dd, const char *file, int oflags, int cflags) __nonnull ((2));
  84 static inline int
  85 xopenat (int dd, const char *file, int oflags, int cflags)
  86 {
  87   int fd = openat (dd, file, oflags, cflags);
  88   if (fd < 0)
  89     edie (errno, "openat(%s)", file);
  90   return fd;
  91 }
  92
  93 static inline int xopen (const char *file, int oflags, int cflags) __nonnull ((1));
  94 static inline int
  95 xopen (const char *file, int oflags, int cflags)
  96 {
  97   int fd = open (file, oflags, cflags);
  98
  99   if (fd < 0)
 100     edie (errno, "open(%s)", file);
 101
 102   return fd;
 103 }
 104
 105 static inline void xdup2 (int oldfd, int newfd);
 106 static inline void
 107 xdup2 (int oldfd, int newfd)
 108 {
 109   if (dup2 (oldfd, newfd) < 0)
 110     edie (errno, "dup2(%d, %d)", oldfd, newfd);
 111 }
 112
 113 static inline void xclose (int fd);
 114 static inline void
 115 xclose (int fd)
 116 {
 117   if (close (fd) < 0)
 118     edie (errno, "close(%d)", fd);
 119 }
 120
 121 static inline void
 122 xpipe (int pipes[2])
 123 {
 124   if (pipe (pipes) != 0)
 125     edie (errno, "pipe()");
 126 }
 127
 128 static inline size_t full_write (int fd, const void *buf, size_t len) __nonnull ((2));
 129 static inline size_t
 130 full_write (int fd, const void *buf, size_t len)
 131 {
 132   const char *s = buf;
 133   size_t n = len;
 134
 135   if (len == 0)
 136     {
 137       errno = EINVAL;
 138       return 0;
 139     }
 140
 141   do
 142     {
 143       int saved_errno = errno;
 144       ssize_t ret = write (fd, s, n);
 145
 146       if (ret < 0)
 147         {
 148           if (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)
 149             {
 150               errno = saved_errno;
 151               continue;
 152             }
 153           break;
 154         }
 155
 156       if (ret == 0)
 157         {
 158           /* According to gnulib note.
 159              Some buggy drivers return 0 when one tries
 160              to write beyond a device's end.
 161              (Example: Linux 1.2.13 on /dev/fd0.)
 162              Set errno to ENOSPC so they get a sensible
 163              diagnostic.  */
 164           errno = ENOSPC;
 165           break;
 166         }
 167
 168       s += ret;
 169       n -= ret;
 170     }
 171   while (n != 0);
 172
 173   return len - n;
 174 }
 175
 176 static inline size_t full_read (int fd, void *buf, size_t len) __nonnull ((2));
 177 static inline size_t
 178 full_read (int fd, void *buf, size_t len)
 179 {
 180   char *s = buf;
 181   size_t n = len;
 182
 183   if (len == 0)
 184     {
 185       errno = EINVAL;
 186       return 0;
 187     }
 188
 189   do
 190     {
 191       int saved_errno = errno;
 192       ssize_t ret = read (fd, s, n);
 193
 194       if (ret < 0)
 195         {
 196           if (errno == EWOULDBLOCK || (errno != EINTR && errno != EAGAIN))
 197             {
 198               break;
 199             }
 200           else
 201             {
 202               errno = saved_errno;
 203               continue;
 204             }
 205         }
 206
 207       if (ret == 0)
 208         break;
 209
 210       s += ret;
 211       n -= ret;
 212     }
 213   while (n != 0);
 214
 215   return len - n;
 216 }
 217
 218 static inline size_t xread (int fd, void *buf, size_t len);
 219 static inline size_t
 220 xread (int fd, void *buf, size_t len)
 221 {
 222   size_t r = full_read (fd, buf, len);
 223
 224   if (r == 0)
 225     edie (errno, "read(%d, %lu)", fd, (unsigned long int) len);
 226
 227   return r;
 228 }
 229
 230 static inline size_t xwrite (int fd, const void *buf, size_t len);
 231 static inline size_t
 232 xwrite (int fd, const void *buf, size_t len)
 233 {
 234   size_t r = full_write (fd, buf, len);
 235
 236   if (r == 0)
 237     edie (errno, "write(%d, %lu)", fd, (unsigned long int)  len);
 238
 239   return r;
 240 }
 241
 242 static inline const char *xttyname (int fd) __returns_nonnull;
 243 static inline const char *
 244 xttyname (int fd)
 245 {
 246   const char *name = ttyname (fd);
 247
 248   if (name == NULL)
 249     edie (errno, "ttyname(%d)", fd);
 250
 251   return name;
 252 }
 253
 254 static inline void *xmalloc (size_t s) __malloc __alloc_size ((1)) __returns_nonnull __warn_unused_result;
 255 static inline void *
 256 xmalloc (size_t s)
 257 {
 258   void *pointer = malloc (s);
 259
 260   if (unlikely (pointer == NULL))
 261     edie (errno, "malloc()");
 262
 263   return pointer;
 264 }
 265
 266 static inline void *xmallocarray (size_t n, size_t m) __malloc __alloc_size ((1, 2)) __returns_nonnull __warn_unused_result;
 267 static inline void *
 268 xmallocarray (size_t n, size_t m)
 269 {
 270   size_t s;
 271
 272   if (unlikely (mul_overflow (n, m, &s)))
 273     edie (ENOMEM, "malloc()");
 274
 275   return xmalloc (s);
 276 }
 277
 278 static inline void *xrealloc (void *pointer, size_t s) __malloc __nonnull ((1)) __alloc_size ((2)) __returns_nonnull __warn_unused_result;
 279 static inline void *
 280 xrealloc (void *pointer, size_t s)
 281 {
 282   pointer = realloc (pointer, s);
 283
 284   if (unlikely (pointer == NULL))
 285     edie (errno, "realloc()");
 286
 287   return pointer;
 288 }
 289
 290 static inline void *xreallocarray (void *pointer, size_t n, size_t m) __malloc __nonnull ((1)) __alloc_size ((2, 3)) __returns_nonnull __warn_unused_result;
 291 static inline void *
 292 xreallocarray (void *pointer, size_t n, size_t m)
 293 {
 294   size_t s;
 295
 296   if (unlikely (mul_overflow (n, m, &s)))
 297     edie (ENOMEM, "realloc()");
 298
 299   pointer = realloc (pointer, s);
 300
 301   if (unlikely (pointer == NULL))
 302     edie (errno, "realloc()");
 303
 304   return pointer;
 305 }
 306
 307 static inline pid_t xfork (void) __warn_unused_result;
 308 static inline pid_t
 309 xfork (void)
 310 {
 311   pid_t pid = fork ();
 312
 313   if (unlikely (pid < 0))
 314     edie (errno, "fork()");
 315
 316   return pid;
 317 }
 318
 319 static inline pid_t xwaitpid (pid_t pid, int *status, int flags) __nonnull ((2));
 320 static inline pid_t
 321 xwaitpid (pid_t pid, int *status, int flags)
 322 {
 323   pid_t r;
 324
 325   while (unlikely ((r = waitpid (pid, status, flags)) < 0))
 326     if (unlikely (errno != EINTR))
 327       edie (errno, "waitpid()");
 328
 329   return r;
 330 }
 331
 332 static inline void xexecvpe (char *file, char **argv, char **envp) __noreturn __nonnull ((1, 2, 3));
 333 static inline void
 334 xexecvpe (char *file, char **argv, char **envp)
 335 {
 336   execvpe (file, argv, envp);
 337   /* Unreachable on success.  */
 338   edie (errno, "execvpe(\"%s\")", file);
 339 }
 340
 341 static inline sighandler_t
 342 xsignal (int signo, sighandler_t handler)
 343 {
 344   sighandler_t previous = signal (signo, handler);
 345
 346   if (previous == SIG_ERR)
 347     edie (errno, "signal(%d)", signo);
 348
 349   return previous;
 350 }
 351
 352 static inline void
 353 xraise (int signo)
 354 {
 355   if (unlikely (raise (signo) != 0))
 356     edie (errno, "raise(%d)", signo);
 357 }
 358
 359 static inline void
 360 xkill (pid_t pid, int signo)
 361 {
 362   if (unlikely (kill (pid, signo) != 0))
 363     edie (errno, "kill(%d, %d)", pid, signo);
 364 }
 365
 366 static inline void xchmod (const char *file_name, mode_t mode) __nonnull ((1));
 367 static inline void
 368 xchmod (const char *file_name, mode_t mode)
 369 {
 370   if (unlikely (chmod (file_name, mode) != 0))
 371     edie (errno, "chmod(%s, %o)", file_name, mode);
 372 }
 373
 374 static inline void xmkdir (const char *directory_name, mode_t mode) __nonnull ((1));
 375 static inline void
 376 xmkdir (const char *directory_name, mode_t mode)
 377 {
 378   if (unlikely (mode & ~07777))
 379     edie (EINVAL, "mkdir(%s, %o)", directory_name, mode);
 380
 381   if (unlikely (mkdir (directory_name, mode) != 0))
 382     {
 383       struct stat sb;
 384
 385       if (unlikely (errno != EEXIST))
 386         edie (errno, "mkdir(%s, %o)", directory_name, mode);
 387       /* Do not die if there is directory with given name.  */
 388
 389       if (unlikely (stat (directory_name, &sb) != 0))
 390         edie (errno, "stat(%s)", directory_name);
 391
 392       if (unlikely (!S_ISDIR (sb.st_mode)))
 393         edie (ENOTDIR, "%s", directory_name);
 394
 395       /* If directory exists make sure that it has required mode.  */
 396       if (unlikely ((sb.st_mode & 07777) != mode))
 397         xchmod (directory_name, mode);
 398     }
 399 }
 400
 401 static inline void xunlinkat (int dd, const char *path) __nonnull ((2));
 402 static inline void
 403 xunlinkat (int dd, const char *path)
 404 {
 405   if (unlinkat (dd, path, 0) < 0 && errno != ENOENT)
 406     edie (errno, "unlinkat(%s)", path);
 407 }
 408
 409 static inline void xrmdir (const char *directory_name) __nonnull ((1));
 410 static inline void
 411 xrmdir (const char *directory_name)
 412 {
 413   if (rmdir (directory_name) != 0 && errno != ENOENT)
 414     edie (errno, "rmdir()");
 415 }
 416
 417 static inline int xsprintf (char *s, const char *fmt, ...) __nonnull ((1, 2)) __format_printf (2, 3);
 418 static inline int
 419 xsprintf (char *s, const char *fmt, ...)
 420 {
 421   int n;
 422   va_list ap;
 423
 424   va_start (ap, fmt);
 425   n = vsprintf (s, fmt, ap);
 426   va_end (ap);
 427
 428   if (n < 0)
 429     edie (errno, "sprintf()");
 430
 431   return n;
 432 }
 433
 434 #if 0
 435 static inline int xasprintf (char **s, const char *fmt, ...) __nonnull ((1, 2)) __format_printf (2, 3);
 436 static inline int
 437 xasprintf (char **s, const char *fmt, ...)
 438 {
 439   int n;
 440   va_list ap, ap2;
 441
 442   va_start (ap, fmt);
 443   va_copy (ap2, ap);
 444
 445   if (unlikely ((n = vsnprintf (NULL, 0, fmt, ap)) < 0))
 446     edie (errno, "vsnprintf()");
 447
 448   va_end (ap);
 449
 450   if (*s == NULL)
 451     *s = xmallocarray (n + 1, sizeof (char));
 452   else
 453     *s = xreallocarray (*s, n + 1, sizeof (char));
 454
 455   if (unlikely ((n = vsnprintf (*s, n + 1, fmt, ap2)) < 0))
 456     edie (errno, "vsnprintf()");
 457
 458   va_end (ap2);
 459
 460   return n;
 461 }
 462
 463 static inline void xastrcat (char **d, const char *s) __nonnull ((1, 2));
 464 static inline void
 465 xastrcat (char **d, const char *s)
 466 {
 467   size_t s_length = strlen (s);
 468   size_t d_length = strlen (*d);
 469   *d = xreallocarray (*d, d_length + s_length + 1, sizeof (char));
 470   strcpy (*d + d_length, s);
 471 }
 472 #endif
 473
 474 static inline uid_t xgetuid (void) __warn_unused_result;
 475 static inline uid_t
 476 xgetuid (void)
 477 {
 478   uid_t uid;
 479   int saved_errno = errno;
 480
 481   errno = 0;
 482
 483   if (unlikely ((uid = getuid ()) == (uid_t) -1 && errno != 0))
 484     edie (errno, "getuid()");
 485
 486   errno = saved_errno;
 487
 488   return uid;
 489 }
 490
 491 static inline struct passwd *xgetpwuid (uid_t uid)
 492   __warn_unused_result __malloc;
 493 static inline struct passwd *
 494 xgetpwuid (uid_t uid)
 495 {
 496   int s;
 497   size_t size = 64;
 498   char *p = xmalloc (sizeof (struct passwd) + size);
 499   struct passwd *result = NULL;
 500
 501   do
 502     {
 503       s = getpwuid_r (uid, (struct passwd *) p, p + sizeof (struct passwd), size, &result);
 504
 505       if (s == EINTR)
 506         continue; /* Try again.  */
 507
 508       if (s == ERANGE)
 509         {
 510           if (mul_overflow (2, size, &size))
 511             edie (ENOMEM, "getpwuid_r(%lu)", (unsigned long int) uid);
 512
 513           p = xrealloc (p, sizeof (struct passwd) + size);
 514           continue;
 515         }
 516
 517       /* We either got an error, or we succeeded and the
 518          returned name fit in the buffer.  */
 519       break;
 520     }
 521   while (true);
 522
 523   if (s != 0)
 524     {
 525       free (p);
 526       result = NULL;
 527       edie (s, "getpwuid_r(%lu)", (unsigned long int) uid);
 528     }
 529   else if (result == NULL)
 530     {
 531       free (p);
 532       edie (0, "no matching password record was found for user with uid %lu",
 533             (unsigned long int) uid);
 534     }
 535
 536   return result;
 537 }
 538
 539 static inline char *xgetwd (void) __returns_nonnull __warn_unused_result __malloc;
 540 static inline char *
 541 xgetwd (void)
 542 {
 543   size_t size = PATH_MAX;
 544   char *buffer = xmalloc (PATH_MAX);
 545   char *p;
 546
 547   while ((p = getcwd (buffer, size)) == NULL)
 548     if (errno == ERANGE)
 549       buffer = xrealloc (buffer, size *= 2);
 550     else
 551       edie (errno, "getcwd()");
 552
 553   return xrealloc (p, strlen (p) + 1);
 554 }
 555
 556 static inline void xtcgetattr (int fd, struct termios *termiosp) __nonnull ((2));
 557 static inline void
 558 xtcgetattr (int fd, struct termios *termiosp)
 559 {
 560   if (tcgetattr (fd, termiosp) < 0)
 561     edie (errno, "tcgetattr()");
 562 }
 563
 564 static inline void xtcsetattr (int fd, int optional_actions, const struct termios *termiosp) __nonnull ((3));
 565 static inline void
 566 xtcsetattr (int fd, int optional_actions, const struct termios *termiosp)
 567 {
 568   if (tcsetattr (fd, optional_actions, termiosp) < 0)
 569     edie (errno, "tcsetattr()");
 570 }
 571
 572 static inline void xatexit (void (*f) (void)) __nonnull ((1));
 573 static inline void
 574 xatexit (void (*f) (void))
 575 {
 576   if (atexit (f) != 0)
 577     edie (errno, "atexit()");
 578 }
 579
 580 static inline int program_get_status (pid_t pid, int flags) __warn_unused_result;
 581 static inline int
 582 program_get_status (pid_t pid, int flags)
 583 {
 584   int status;
 585
 586   xwaitpid (pid, &status, flags);
 587
 588   return status;
 589 }
 590
 591 static inline int wait_program_termination (pid_t pid) __warn_unused_result;
 592 static inline int
 593 wait_program_termination (pid_t pid)
 594 {
 595   int status;
 596
 597   do
 598     xwaitpid (pid, &status, 0);
 599   while (unlikely (!program_terminated (status)));
 600
 601   return status;
 602 }
 603
 604 static inline bool program_is_executing (pid_t pid) __warn_unused_result;
 605 static inline bool
 606 program_is_executing (pid_t pid)
 607 {
 608   /*TODO*/
 609   int status;
 610
 611   xwaitpid (pid, &status, WNOHANG);
 612   return (!program_terminated (status));
 613 }
 614
 615 poison (ttyname);
 616 poison (malloc calloc realloc fork kill raise execvpe waitpid);
 617 poison (chmod chown fchown mkdir rmdir getuid geteuid getgid setuid seteuid);
 618 poison (sprintf snprintf asprintf);
 619 poison (tcgetattr tcsetattr atexit read write lseek unlink nice);
 620
 621 #endif