sycls.c

   1 /* source: sycls.c */
   2 /* Copyright Gerhard Rieger */
   3 /* Published under the GNU General Public License V.2, see file COPYING */
   4
   5 /* explicit system call and C library trace function, for those who miss strace
   6  */
   7
   8 #include "config.h"
   9 #include "xioconfig.h"  /* what features are enabled */
  10
  11 #if WITH_SYCLS
  12
  13 #include "sysincludes.h"
  14
  15 #include "mytypes.h"
  16 #include "compat.h"
  17 #include "errno.h"
  18
  19 #include "error.h"
  20 #include "filan.h"
  21 #include "utils.h"
  22 #include "sysutils.h"
  23 #include "sycls.h"
  24
  25
  26 mode_t Umask(mode_t mask) {
  27    mode_t result;
  28    int _errno;
  29    Debug1("umask("F_mode")", mask);
  30    result = umask(mask);
  31    _errno = errno;
  32    Debug1("umask() -> "F_mode, result);
  33    errno = _errno;
  34    return result;
  35 }
  36
  37 int Open(const char *pathname, int flags, mode_t mode) {
  38    int result, _errno;
  39    if (!diag_in_handler) diag_flush();
  40    Debug3("open(\"%s\", 0%o, 0%03o)", pathname, flags, mode);
  41    result = open(pathname, flags, mode);
  42    _errno = errno;
  43    if (!diag_in_handler) diag_flush();
  44    Info4("open(\"%s\", 0%o, 0%03o) -> %d", pathname, flags, mode, result);
  45    errno = _errno;
  46    return result;
  47 }
  48
  49 int Creat(const char *pathname, mode_t mode) {
  50    int result, _errno;
  51    Debug2("creat(\"%s\", 0%03o)", pathname, mode);
  52    result = creat(pathname, mode);
  53    _errno = errno;
  54    Info3("creat(\"%s\", 0%03o) -> %d", pathname, mode, result);
  55    errno = _errno;
  56    return result;
  57 }
  58
  59 off_t Lseek(int fildes, off_t offset, int whence) {
  60    int _errno;
  61    off_t result;
  62    Debug3("lseek(%d, "F_off", %d)", fildes, offset, whence);
  63    result = lseek(fildes, offset, whence);
  64    _errno = errno;
  65    Debug1("lseek() -> "F_off, result);
  66    errno = _errno;
  67    return result;
  68 }
  69
  70 #if HAVE_LSEEK64
  71 off64_t Lseek64(int fildes, off64_t offset, int whence) {
  72    int _errno;
  73    off64_t result;
  74    Debug3("lseek64(%d, "F_off64", %d)", fildes, offset, whence);
  75    result = lseek64(fildes, offset, whence);
  76    _errno = errno;
  77    Debug1("lseek64() -> "F_off64, result);
  78    errno = _errno;
  79    return result;
  80 }
  81 #endif /* HAVE_LSEEK64 */
  82
  83 pid_t Getpid(void) {
  84    pid_t result;
  85    int _errno;
  86    Debug("getpid()");
  87    result = getpid();
  88    _errno = errno;
  89    Debug1("getpid() -> "F_pid, result);
  90    errno = _errno;
  91    return result;
  92 }
  93
  94 pid_t Getppid(void) {
  95    pid_t result;
  96    int _errno;
  97    Debug("getppid()");
  98    result = getppid();
  99    _errno = errno;
 100    Debug1("getppid() -> "F_pid, result);
 101    errno = _errno;
 102    return result;
 103 }
 104
 105 pid_t Getpgrp(void) {
 106    pid_t result;
 107    int _errno;
 108    Debug("getpgrp()");
 109    result = getpgrp();
 110    _errno = errno;
 111    Debug1("getpgrp() -> "F_pid, result);
 112    errno = _errno;
 113    return result;
 114 }
 115
 116 #if 0   /* does not compile for FreeBSD */
 117 /* setpgrp() is not BSD compatible, needs setpgid(..., ...) instead */
 118 int Setpgrp(void) {
 119    int result, _errno;
 120    Debug("setpgrp()");
 121    result = setpgrp();
 122    _errno = errno;
 123    Debug1("setpgrp() -> %d", result);
 124    errno = _errno;
 125    return result;
 126 }
 127 #endif
 128
 129 #if HAVE_GETPGID
 130 int Getpgid(pid_t pid) {
 131    pid_t result;
 132    int _errno;
 133    Debug1("getpgid("F_pid")", pid);
 134    result = getpgid(pid);
 135    _errno = errno;
 136    Debug1("getpgid() -> "F_pid, result);
 137    errno = _errno;
 138    return result;
 139 }
 140 #endif
 141
 142 int Setpgid(pid_t pid, pid_t pgid) {
 143    int result, _errno;
 144    Debug2("setpgid("F_pid", "F_pid")", pid, pgid);
 145    result = setpgid(pid, pgid);
 146    _errno = errno;
 147    Debug1("setpgid() -> %d", result);
 148    errno = _errno;
 149    return result;
 150 }
 151
 152 pid_t Tcgetpgrp(int fd) {
 153    int result, _errno;
 154    Debug1("tcgetpgrp(%d)", fd);
 155    result = tcgetpgrp(fd);
 156    _errno = errno;
 157    Debug1("tcgetpgrp() -> %d", result);
 158    errno = _errno;
 159    return result;
 160 }
 161
 162 int Tcsetpgrp(int fd, pid_t pgrpid) {
 163    int result, _errno;
 164    Debug2("tcsetpgrp(%d, "F_pid")", fd, pgrpid);
 165    result = tcsetpgrp(fd, pgrpid);
 166    _errno = errno;
 167    Debug1("tcsetpgrp() -> %d", result);
 168    errno = _errno;
 169    return result;
 170 }
 171
 172 #if HAVE_GETSID
 173 pid_t Getsid(pid_t pid) {
 174    int result, _errno;
 175    Debug1("getsid("F_pid")", pid);
 176    result = getsid(pid);
 177    _errno = errno;
 178    Debug1("getsid() -> "F_pid, result);
 179    errno = _errno;
 180    return result;
 181 }
 182 #endif
 183
 184 pid_t Setsid(void) {
 185    int result, _errno;
 186    Debug("setsid()");
 187    result = setsid();
 188    _errno = errno;
 189    Debug1("setsid() -> "F_pid, result);
 190    errno = _errno;
 191    return result;
 192 }
 193
 194 uid_t Getuid(void) {
 195    uid_t result;
 196    int _errno;
 197    Debug("getuid()");
 198    result = getuid();
 199    _errno = errno;
 200    Debug1("getuid() -> "F_uid, result);
 201    errno = _errno;
 202    return result;
 203 }
 204
 205 uid_t Geteuid(void) {
 206    uid_t result;
 207    int _errno;
 208    Debug("geteuid()");
 209    result = geteuid();
 210    _errno = errno;
 211    Debug1("geteuid() -> "F_uid, result);
 212    errno = _errno;
 213    return result;
 214 }
 215
 216 int Setuid(uid_t uid) {
 217    int result, _errno;
 218    Debug1("setuid("F_uid")", uid);
 219    result = setuid(uid);
 220    _errno = errno;
 221    Debug1("setuid() -> %d", result);
 222    errno = _errno;
 223    return result;
 224 }
 225
 226 gid_t Getgid(void) {
 227    gid_t result;
 228    int _errno;
 229    Debug("getgid()");
 230    result = getgid();
 231    _errno = errno;
 232    Debug1("getgid() -> "F_gid, result);
 233    errno = _errno;
 234    return result;
 235 }
 236
 237 gid_t Getegid(void) {
 238    gid_t result;
 239    int _errno;
 240    Debug("getegid()");
 241    result = getegid();
 242    _errno = errno;
 243    Debug1("getegid() -> "F_gid, result);
 244    errno = _errno;
 245    return result;
 246 }
 247
 248 int Setgid(gid_t gid) {
 249    int result, _errno;
 250    Debug1("setgid("F_gid")", gid);
 251    result = setgid(gid);
 252    _errno = errno;
 253    Debug1("setgid() -> %d", result);
 254    errno = _errno;
 255    return result;
 256 }
 257
 258 int Initgroups(const char *user, gid_t group) {
 259    int result, _errno;
 260    Debug2("initgroups(\"%s\", "F_gid")", user, group);
 261    result = initgroups(user, group);
 262    _errno = errno;
 263    Debug1("initgroups() -> %d", result);
 264    errno = _errno;
 265    return result;
 266 }
 267
 268 int Getgroups(int size, gid_t list[]) {
 269    int result, _errno;
 270    Debug2("getgroups(%d, "F_gid",...)", size, list[0]);
 271    result = getgroups(size, list);
 272    _errno = errno;
 273    Debug1("getgroups() -> %d", result);
 274    errno = _errno;
 275    return result;
 276 }
 277
 278 #if HAVE_SETGROUPS
 279 int Setgroups(size_t size, const gid_t *list) {
 280    int result, _errno;
 281    switch (size) {
 282    case 0: Debug1("setgroups("F_Zu", [])", size); break;;
 283    case 1: Debug2("setgroups("F_Zu", ["F_gid"])", size, list[0]); break;;
 284    case 2: Debug3("setgroups("F_Zu", ["F_gid","F_gid"])", size, list[0], list[1]); break;;
 285    default: Debug3("setgroups("F_Zu", ["F_gid","F_gid",...])", size, list[0], list[1]); break;;
 286    }
 287    result = setgroups(size, list);
 288    _errno = errno;
 289    Debug1("setgroups() -> %d", result);
 290    errno = _errno;
 291    return result;
 292 }
 293 #endif
 294
 295 #if HAVE_GETGROUPLIST
 296 int Getgrouplist(const char *user, gid_t group, gid_t *groups, int *ngroups) {
 297    int n = *ngroups, result;
 298    Debug4("getgrouplist(\"%s\", "F_gid", %p, [%d])", user, group, groups, n);
 299    result = getgrouplist(user, group, groups, ngroups);
 300    switch (Min(n,*ngroups)) {
 301    case 0:  Debug2("getgrouplist(,, [], [%d]) -> %d", *ngroups, result); break;
 302    case 1:  Debug3("getgrouplist(,, ["F_gid"], [%d]) -> %d", groups[0], *ngroups, result); break;
 303    case 2:  Debug4("getgrouplist(,, ["F_gid","F_gid"], [%d]) -> %d", groups[0], groups[1], *ngroups, result); break;
 304    default: Debug4("getgrouplist(,, ["F_gid","F_gid",...], [%d]) -> %d", groups[0], groups[1], *ngroups, result); break;
 305    }
 306    return result;
 307 }
 308 #endif
 309
 310 int Chdir(const char *path) {
 311    int result, _errno;
 312    Debug1("chdir(\"%s\")", path);
 313    result = chdir(path);
 314    _errno = errno;
 315    Debug1("chdir() -> %d", result);
 316    errno = _errno;
 317    return result;
 318 }
 319
 320 int Chroot(const char *path) {
 321    int result, _errno;
 322    Debug1("chroot(\"%s\")", path);
 323    result = chroot(path);
 324    _errno = errno;
 325    Debug1("chroot() -> %d", result);
 326    errno = _errno;
 327    return result;
 328 }
 329
 330 int Gettimeofday(struct timeval *tv, struct timezone *tz) {
 331    int result, _errno;
 332 #if WITH_MSGLEVEL <= E_DEBUG
 333    if (tz) {
 334       Debug3("gettimeofday(%p, {%d,%d})",
 335              tv, tz->tz_minuteswest, tz->tz_dsttime);
 336    } else {
 337       Debug1("gettimeofday(%p, NULL)", tv);
 338    }
 339 #endif /* WITH_MSGLEVEL <= E_DEBUG */
 340    result = gettimeofday(tv, tz);
 341    _errno = errno;
 342 #if WITH_MSGLEVEL <= E_DEBUG
 343    if (tz) {
 344       Debug5("gettimeofday({%ld,%ld}, {%d,%d}) -> %d",
 345              tv->tv_sec, tv->tv_usec, tz->tz_minuteswest, tz->tz_dsttime,
 346              result);
 347    } else {
 348       Debug3("gettimeofday({%ld,%ld},) -> %d",
 349              tv->tv_sec, tv->tv_usec, result);
 350    }
 351 #endif /* WITH_MSGLEVEL <= E_DEBUG */
 352    errno = _errno;
 353    return result;
 354 }
 355
 356 int Mknod(const char *pathname, mode_t mode, dev_t dev) {
 357    int result, _errno;
 358    Debug3("mknod(\"%s\", 0%o, "F_dev")", pathname, mode, dev);
 359    result = mknod(pathname, mode, dev);
 360    _errno = errno;
 361    Debug1("mknod() -> %d", result);
 362    errno = _errno;
 363    return result;
 364 }
 365
 366 int Mkfifo(const char *pathname, mode_t mode) {
 367    int result, _errno;
 368    Debug2("mkfifo(\"%s\", 0%o)", pathname, mode);
 369    result = mkfifo(pathname, mode);
 370    _errno = errno;
 371    Debug1("mkfifo() -> %d", result);
 372    errno = _errno;
 373    return result;
 374 }
 375
 376 static void prtstat(const char *func, struct stat *buf, int result) {
 377    char txt[256], *t = txt;
 378
 379    t += sprintf(t, "%s(, {"F_dev","F_st_ino","F_mode","F_st_nlink","F_uid","F_gid,
 380                 func, buf->st_dev, buf->st_ino,
 381                 buf->st_mode, buf->st_nlink, buf->st_uid, buf->st_gid);
 382 #if HAVE_ST_RDEV
 383    t += sprintf(t, ","F_dev, buf->st_rdev);
 384 #endif
 385    t += sprintf(t, ","F_st_size, buf->st_size);
 386 #if HAVE_ST_BLKSIZE
 387    t += sprintf(t, ","F_st_blksize, buf->st_blksize);
 388 #endif
 389 #if HAVE_ST_BLOCKS
 390    t += sprintf(t, ","F_st_blocks, buf->st_blocks);
 391 #endif
 392    sprintf(t, ",...}) -> %d", result);
 393    Debug(txt);
 394 }
 395
 396 #if defined(HAVE_STAT64) || defined(HAVE_FSTAT64) || defined(HAVE_LSTAT64)
 397 static void prtstat64(const char *func, struct stat64 *buf, int result) {
 398    char txt[256], *t = txt;
 399
 400    if (result < 0) {
 401       sprintf(t, "%s(, {}) -> %d", func, result);
 402    } else {
 403    t += sprintf(t, "%s(, {"F_dev","F_st64_ino","F_mode","F_st_nlink","F_uid","F_gid,
 404                 func, buf->st_dev, buf->st_ino,
 405                 buf->st_mode, buf->st_nlink, buf->st_uid, buf->st_gid);
 406 #if HAVE_ST_RDEV
 407    t += sprintf(t, ","F_dev, buf->st_rdev);
 408 #endif
 409    t += sprintf(t, ","F_st64_size, buf->st_size);
 410 #if HAVE_ST_BLKSIZE
 411    t += sprintf(t, ","F_st_blksize, buf->st_blksize);
 412 #endif
 413 #if HAVE_ST_BLOCKS
 414    t += sprintf(t, ","F_st64_blocks, buf->st_blocks);
 415 #endif
 416    sprintf(t, ",...}) -> %d", result);
 417    }
 418    Debug(txt);
 419 }
 420 #endif /* defined(HAVE_STAT64) || defined(HAVE_FSTAT64) || defined(HAVE_LSTAT64) */
 421
 422 int Stat(const char *file_name, struct stat *buf) {
 423    int result, _errno;
 424    Debug2("stat(%s, %p)", file_name, buf);
 425    result = stat(file_name, buf);
 426    _errno = errno;
 427    prtstat("stat", buf, result);
 428    errno = _errno;
 429    return result;
 430 }
 431
 432 #if HAVE_STAT64
 433 int Stat64(const char *file_name, struct stat64 *buf) {
 434    int result, _errno;
 435    Debug2("stat64(%s, %p)", file_name, buf);
 436    result = stat64(file_name, buf);
 437    _errno = errno;
 438    prtstat64("stat64", buf, result);
 439    errno = _errno;
 440    return result;
 441 }
 442 #endif /* HAVE_STAT64 */
 443
 444 int Fstat(int filedes, struct stat *buf) {
 445    int result, _errno;
 446    Debug2("fstat(%d, %p)", filedes, buf);
 447    result = fstat(filedes, buf);
 448    _errno = errno;
 449    prtstat("fstat", buf, result);
 450    errno = _errno;
 451    return result;
 452 }
 453
 454 #if HAVE_FSTAT64
 455 int Fstat64(int filedes, struct stat64 *buf) {
 456    int result, _errno;
 457    Debug2("fstat64(%d, %p)", filedes, buf);
 458    result = fstat64(filedes, buf);
 459    _errno = errno;
 460    prtstat64("fstat64", buf, result);
 461    errno = _errno;
 462    return result;
 463 }
 464 #endif /* HAVE_FSTAT64 */
 465
 466 int Lstat(const char *file_name, struct stat *buf) {
 467    int result, _errno;
 468    Debug2("lstat(%s, %p)", file_name, buf);
 469    result = lstat(file_name, buf);
 470    _errno = errno;
 471    prtstat("lstat", buf, result);
 472    errno = _errno;
 473    return result;
 474 }
 475
 476 #if HAVE_LSTAT64
 477 int Lstat64(const char *file_name, struct stat64 *buf) {
 478    int result, _errno;
 479    Debug2("lstat64(%s, %p)", file_name, buf);
 480    result = lstat64(file_name, buf);
 481    _errno = errno;
 482    prtstat64("lstat64", buf, result);
 483    errno = _errno;
 484    return result;
 485 }
 486 #endif /* HAVE_LSTAT64 */
 487
 488 int Dup(int oldfd) {
 489    int newfd, _errno;
 490    Debug1("dup(%d)", oldfd);
 491    newfd = dup(oldfd);
 492    _errno = errno;
 493    Info2("dup(%d) -> %d", oldfd, newfd);
 494    errno = _errno;
 495    return newfd;
 496 }
 497
 498 int Dup2(int oldfd, int newfd) {
 499    int result, _errno;
 500    Debug2("dup2(%d, %d)", oldfd, newfd);
 501    result = dup2(oldfd, newfd);
 502    _errno = errno;
 503    Info3("dup2(%d, %d) -> %d", oldfd, newfd, result);
 504    errno = _errno;
 505    return result;
 506 }
 507
 508 int Pipe(int filedes[2]) {
 509    int result, _errno;
 510    Debug1("pipe(%p)", filedes);
 511    result = pipe(filedes);
 512    _errno = errno;
 513    Info3("pipe({%d,%d}) -> %d", filedes[0], filedes[1], result);
 514    errno = _errno;
 515    return result;
 516 }
 517
 518 ssize_t Read(int fd, void *buf, size_t count) {
 519    ssize_t result;
 520    int _errno;
 521    if (!diag_in_handler) diag_flush();
 522    Debug3("read(%d, %p, "F_Zu")", fd, buf, count);
 523    result = read(fd, buf, count);
 524    _errno = errno;
 525    if (!diag_in_handler) diag_flush();
 526    Debug1("read -> "F_Zd, result);
 527    errno = _errno;
 528    return result;
 529 }
 530
 531 ssize_t Write(int fd, const void *buf, size_t count) {
 532    ssize_t result;
 533    int _errno;
 534    if (!diag_in_handler) diag_flush();
 535    Debug3("write(%d, %p, "F_Zu")", fd, buf, count);
 536    result = write(fd, buf, count);
 537    _errno = errno;
 538    if (!diag_in_handler) diag_flush();
 539    Debug1("write -> "F_Zd, result);
 540    errno = _errno;
 541    return result;
 542 }
 543
 544 int Fcntl(int fd, int cmd) {
 545    int result, _errno;
 546    if (!diag_in_handler) diag_flush();
 547    Debug2("fcntl(%d, %d)", fd, cmd);
 548    result = fcntl(fd, cmd);
 549    if (!diag_in_handler) diag_flush();
 550    _errno = errno;
 551    Debug1("fcntl() -> %d", result);
 552    errno = _errno;
 553    return result;
 554 }
 555
 556 int Fcntl_l(int fd, int cmd, long arg) {
 557    int result, _errno;
 558    if (!diag_in_handler) diag_flush();
 559    Debug3("fcntl(%d, %d, %ld)", fd, cmd, arg);
 560    result = fcntl(fd, cmd, arg);
 561    _errno = errno;
 562    if (!diag_in_handler) diag_flush();
 563    Debug1("fcntl() -> %d", result);
 564    errno = _errno;
 565    return result;
 566 }
 567
 568 int Fcntl_lock(int fd, int cmd, struct flock *l) {
 569    int result, _errno;
 570    if (!diag_in_handler) diag_flush();
 571    Debug7("fcntl(%d, %d, {type=%hd,whence=%hd,start="F_off",len="F_off",pid="F_pid"})",
 572           fd, cmd, l->l_type, l->l_whence, l->l_start, l->l_len, l->l_pid);
 573    result = fcntl(fd, cmd, l);
 574    _errno = errno;
 575    if (!diag_in_handler) diag_flush();
 576    Debug1("fcntl() -> %d", result);
 577    errno = _errno;
 578    return result;
 579 }
 580
 581 int Ftruncate(int fd, off_t length) {
 582    int retval, _errno;
 583    Debug2("ftruncate(%d, "F_off")", fd, length);
 584    retval = ftruncate(fd, length);
 585    _errno = errno;
 586    Debug1("ftruncate() -> %d", retval);
 587    errno = _errno;
 588    return retval;
 589 }
 590
 591 #if HAVE_FTRUNCATE64
 592 int Ftruncate64(int fd, off64_t length) {
 593    int retval, _errno;
 594    Debug2("ftruncate64(%d, "F_off64")", fd, length);
 595    retval = ftruncate64(fd, length);
 596    _errno = errno;
 597    Debug1("ftruncate64() -> %d", retval);
 598    errno = _errno;
 599    return retval;
 600 }
 601 #endif /* HAVE_FTRUNCATE64 */
 602
 603 #if HAVE_FLOCK
 604 int Flock(int fd, int operation) {
 605    int retval, _errno;
 606    if (!diag_in_handler) diag_flush();
 607    Debug2("flock(%d, %d)", fd, operation);
 608    retval = flock(fd, operation);
 609    _errno = errno;
 610    if (!diag_in_handler) diag_flush();
 611    Debug1("flock() -> %d", retval);
 612    errno = _errno;
 613    return retval;
 614 }
 615 #endif /* HAVE_FLOCK */
 616
 617 int Ioctl(int d, int request, void *argp) {
 618    int retval, _errno;
 619    if (!diag_in_handler) diag_flush();
 620    if (argp > (void *)0x10000) {        /* fuzzy...*/
 621       Debug4("ioctl(%d, 0x%x, %p{%lu})", d, request, argp, *(unsigned long *)argp);
 622    } else {
 623       Debug3("ioctl(%d, 0x%x, 0x%p)", d, request, argp);
 624    }
 625    retval = ioctl(d, request, argp);
 626    _errno = errno;
 627    if (!diag_in_handler) diag_flush();
 628    Debug1("ioctl() -> %d", retval);
 629    errno = _errno;
 630    return retval;
 631 }
 632
 633 int Ioctl_int(int d, int request, int arg) {
 634    int retval, _errno;
 635    Debug3("ioctl(%d, 0x%x, %d)", d, request, arg);
 636    retval = ioctl(d, request, arg);
 637    _errno = errno;
 638    Debug1("ioctl() -> %d", retval);
 639    errno = _errno;
 640    return retval;
 641 }
 642
 643 int Close(int fd) {
 644    int retval, _errno;
 645    Info1("close(%d)", fd);
 646    retval = close(fd);
 647    _errno = errno;
 648    Debug1("close()  -> %d", retval);
 649    errno = _errno;
 650    return retval;
 651 }
 652
 653 int Fchown(int fd, uid_t owner, gid_t group) {
 654    int retval, _errno;
 655    Debug3("fchown(%d, "F_uid", "F_gid")", fd, owner, group);
 656    retval = fchown(fd, owner, group);
 657    _errno = errno;
 658    Debug1("fchown() -> %d", retval);
 659    errno = _errno;
 660    return retval;
 661 }
 662
 663 int Fchmod(int fd, mode_t mode) {
 664    int retval, _errno;
 665    Debug2("fchmod(%d, 0%o)", fd, mode);
 666    retval = fchmod(fd, mode);
 667    _errno = errno;
 668    Debug1("fchmod()  -> %d", retval);
 669    errno = _errno;
 670    return retval;
 671 }
 672
 673 int Unlink(const char *pathname) {
 674    int retval, _errno;
 675    Debug1("unlink(\"%s\")", pathname);
 676    retval = unlink(pathname);
 677    _errno = errno;
 678    Debug1("unlink()  -> %d", retval);
 679    errno = _errno;
 680    return retval;
 681 }
 682
 683 int Symlink(const char *oldpath, const char *newpath) {
 684    int retval, _errno;
 685    Debug2("symlink(\"%s\", \"%s\")", oldpath, newpath);
 686    retval = symlink(oldpath, newpath);
 687    _errno = errno;
 688    Debug1("symlink()  -> %d", retval);
 689    errno = _errno;
 690    return retval;
 691 }
 692
 693 int Readlink(const char *path, char *buf, size_t bufsiz) {
 694    int retval, _errno;
 695    Debug3("readlink(\"%s\", %p, "F_Zu")", path, buf, bufsiz);
 696    retval = readlink(path, buf, bufsiz);
 697    _errno = errno;
 698    Debug1("readlink() -> %d", retval);
 699    errno = _errno;
 700    return retval;
 701 }
 702
 703 int Chown(const char *path, uid_t owner, gid_t group) {
 704    int retval, _errno;
 705    Debug3("chown(\"%s\", "F_uid", "F_gid")", path, owner, group);
 706    retval = chown(path, owner, group);
 707    _errno = errno;
 708    Debug1("chown()  -> %d", retval);
 709    errno = _errno;
 710    return retval;
 711 }
 712
 713 int Chmod(const char *path, mode_t mode) {
 714    int retval, _errno;
 715    Debug2("chmod(\"%s\", 0%o)", path, mode);
 716    retval = chmod(path, mode);
 717    _errno = errno;
 718    Debug1("chmod()  -> %d", retval);
 719    errno = _errno;
 720    return retval;
 721 }
 722
 723 #if HAVE_POLL
 724 /* we only show the first struct pollfd; hope this is enough for most cases. */
 725 int Poll(struct pollfd *ufds, unsigned int nfds, int timeout) {
 726    int _errno, result;
 727    if (!diag_in_handler) diag_flush();
 728    if (nfds == 4) {
 729       Debug10("poll({%d,0x%02hx,}{%d,0x%02hx,}{%d,0x%02hx,}{%d,0x%02hx,}, %u, %d)",
 730               ufds[0].fd, ufds[0].events, ufds[1].fd, ufds[1].events,
 731               ufds[2].fd, ufds[2].events, ufds[3].fd, ufds[3].events,
 732               nfds, timeout);
 733    } else {
 734       Debug4("poll({%d,0x%02hx,}, , %u, %d)", ufds[0].fd, ufds[0].events, nfds, timeout);
 735    }
 736    result = poll(ufds, nfds, timeout);
 737    _errno = errno;
 738    if (!diag_in_handler) diag_flush();
 739    if (nfds == 4) {
 740       Debug5("poll(, {,,0x%02hx}{,,0x%02hx}{,,0x%02hx}{,,0x%02hx}) -> %d",
 741              ufds[0].revents, ufds[1].revents, ufds[2].revents, ufds[3].revents, result);
 742    } else {
 743       Debug2("poll(, {,,0x%02hx}) -> %d", ufds[0].revents, result);
 744    }
 745    errno = _errno;
 746    return result;
 747 }
 748 #endif /* HAVE_POLL */
 749
 750 /* we only show the first word of the fd_set's; hope this is enough for most
 751    cases. */
 752 int Select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 753            struct timeval *timeout) {
 754    int result, _errno;
 755    if (!diag_in_handler) diag_flush();
 756 #if HAVE_FDS_BITS
 757    Debug7("select(%d, &0x%lx, &0x%lx, &0x%lx, %s%lu."F_tv_usec")",
 758           n, readfds?readfds->fds_bits[0]:0, writefds?writefds->fds_bits[0]:0,
 759           exceptfds?exceptfds->fds_bits[0]:0,
 760           timeout?"&":"NULL/", timeout?timeout->tv_sec:0,
 761           timeout?timeout->tv_usec:0);
 762 #else
 763    Debug7("select(%d, &0x%lx, &0x%lx, &0x%lx, %s%lu.%06u)",
 764           n, readfds?readfds->__fds_bits[0]:0, writefds?writefds->__fds_bits[0]:0,
 765           exceptfds?exceptfds->__fds_bits[0]:0,
 766           timeout?"&":"NULL/", timeout?timeout->tv_sec:0,
 767           timeout?timeout->tv_usec:0);
 768 #endif
 769    result = select(n, readfds, writefds, exceptfds, timeout);
 770    _errno = errno;
 771    if (!diag_in_handler) diag_flush();
 772 #if HAVE_FDS_BITS
 773    Debug7("select -> (, 0x%lx, 0x%lx, 0x%lx, %s%lu."F_tv_usec"), %d",
 774           readfds?readfds->fds_bits[0]:0, writefds?writefds->fds_bits[0]:0,
 775           exceptfds?exceptfds->fds_bits[0]:0,
 776           timeout?"&":"NULL/", timeout?timeout->tv_sec:0,
 777           timeout?timeout->tv_usec:0, result);
 778 #else
 779    Debug7("select -> (, 0x%lx, 0x%lx, 0x%lx, %s%lu.%06u), %d",
 780           readfds?readfds->__fds_bits[0]:0, writefds?writefds->__fds_bits[0]:0,
 781           exceptfds?exceptfds->__fds_bits[0]:0,
 782           timeout?"&":"NULL/", timeout?timeout->tv_sec:0,
 783           timeout?timeout->tv_usec:0, result);
 784 #endif
 785    errno = _errno;
 786
 787    return result;
 788 }
 789
 790 pid_t Fork(void) {
 791    pid_t pid;
 792    int _errno;
 793    Debug("fork()");
 794    pid = fork();
 795    _errno = errno;
 796    Debug1("fork() -> %d", pid); /* attention: called twice! */
 797    errno = _errno;
 798    return pid;
 799 }
 800
 801 pid_t Waitpid(pid_t pid, int *status, int options) {
 802    int _errno;
 803    pid_t retval;
 804    if (!diag_in_handler) diag_flush();
 805    Debug3("waitpid("F_pid", %p, %d)", pid, status, options);
 806    retval = waitpid(pid, status, options);
 807    _errno = errno;
 808    if (!diag_in_handler) diag_flush();
 809    Debug2("waitpid(, {%d}, ) -> "F_pid, *status, retval);
 810    errno = _errno;
 811    return retval;
 812 }
 813
 814 sighandler_t Signal(int signum, sighandler_t handler) {
 815    int _errno;
 816    sighandler_t retval;
 817    Debug2("signal(%d, %p)", signum, handler);
 818    retval = signal(signum, handler);
 819    _errno = errno;
 820    Debug1("signal() -> %p", retval);
 821    errno = _errno;
 822    return retval;
 823 }
 824
 825 #if HAVE_SIGACTION
 826 int Sigaction(int signum, const struct sigaction *act,
 827               struct sigaction *oldact) {
 828    int retval;
 829    Debug3("sigaction(%d, %p, %p)", signum, act, oldact);
 830    retval = sigaction(signum, act, oldact);
 831    Debug1("sigaction() -> %d", retval);
 832    return retval;
 833 }
 834 #endif /* HAVE_SIGACTION */
 835
 836 int Sigprocmask(int how, const sigset_t *set, sigset_t *oset) {
 837    int retval;
 838    Debug3("sigprocmask(%d, %p, %p)", how, set, oset);
 839    retval = sigprocmask(how, set, oset);
 840    Debug1("sigprocmask() -> %d", retval);
 841    return retval;
 842 }
 843
 844 unsigned int Alarm(unsigned int seconds) {
 845    unsigned int retval;
 846    Debug1("alarm(%u)", seconds);
 847    retval = alarm(seconds);
 848    Debug1("alarm() -> %u", retval);
 849    return retval;
 850 }
 851
 852 int Kill(pid_t pid, int sig) {
 853    int retval, _errno;
 854    Debug2("kill("F_pid", %d)", pid, sig);
 855    retval = kill(pid, sig);
 856    _errno = errno;
 857    Debug1("kill() -> %d", retval);
 858    errno = _errno;
 859    return retval;
 860 }
 861
 862 int Link(const char *oldpath, const char *newpath) {
 863    int retval, _errno;
 864    Debug2("link(\"%s\", \"%s\")", oldpath, newpath);
 865    retval = link(oldpath, newpath);
 866    _errno = errno;
 867    Debug1("link() -> %d", retval);
 868    errno = _errno;
 869    return retval;
 870 }
 871
 872 int Execvp(const char *file, char *const argv[]) {
 873    int result, _errno;
 874    if (argv[1] == NULL)
 875       Debug2("execvp(\"%s\", \"%s\")", file, argv[0]);
 876    else if (argv[2] == NULL)
 877       Debug3("execvp(\"%s\", \"%s\" \"%s\")", file, argv[0], argv[1]);
 878    else if (argv[3] == NULL)
 879       Debug4("execvp(\"%s\", \"%s\" \"%s\" \"%s\")", file, argv[0], argv[1], argv[2]);
 880    else if (argv[4] == NULL)
 881       Debug5("execvp(\"%s\", \"%s\" \"%s\" \"%s\" \"%s\")", file, argv[0], argv[1], argv[2], argv[3]);
 882    else if (argv[5] == NULL)
 883       Debug6("execvp(\"%s\", \"%s\" \"%s\" \"%s\" \"%s\" \"%s\")", file, argv[0], argv[1], argv[2], argv[3], argv[4]);
 884    else
 885       Debug6("execvp(\"%s\", \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" ...)", file, argv[0], argv[1], argv[2], argv[3], argv[4]);
 886
 887    result = execvp(file, argv);
 888    _errno = errno;
 889    Debug1("execvp() -> %d", result);
 890    errno = _errno;
 891    return result;
 892 }
 893
 894 int System(const char *string) {
 895    int result, _errno;
 896    Debug1("system(\"%s\")", string);
 897    diag_immediate_exit = 1;
 898    result = system(string);
 899    diag_immediate_exit = 0;
 900    _errno = errno;
 901    Debug1("system() -> %d", result);
 902    errno = _errno;
 903    return result;
 904 }
 905
 906 int Socketpair(int d, int type, int protocol, int sv[2]) {
 907    int result, _errno;
 908    Debug4("socketpair(%d, %d, %d, %p)", d, type, protocol, sv);
 909    result = socketpair(d, type, protocol, sv);
 910    _errno = errno;
 911    Info6("socketpair(%d, %d, %d, {%d,%d}) -> %d", d, type, protocol, sv[0], sv[1], result);
 912    errno = _errno;
 913    return result;
 914 }
 915
 916 #if _WITH_SOCKET
 917 int Socket(int domain, int type, int protocol) {
 918    int result, _errno;
 919    Debug3("socket(%d, %d, %d)", domain, type, protocol);
 920    result = socket(domain, type, protocol);
 921    _errno = errno;
 922    Info4("socket(%d, %d, %d) -> %d", domain, type, protocol, result);
 923    errno = _errno;
 924    return result;
 925 }
 926 #endif /* _WITH_SOCKET */
 927
 928 #if _WITH_SOCKET
 929 int Bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) {
 930    int result, _errno;
 931    char infobuff[256];
 932
 933    sockaddr_info(my_addr, addrlen, infobuff, sizeof(infobuff));
 934    Debug3("bind(%d, %s, "F_socklen")", sockfd, infobuff, addrlen);
 935    result = bind(sockfd, my_addr, addrlen);
 936    _errno = errno;
 937    Debug1("bind() -> %d", result);
 938    errno = _errno;
 939    return result;
 940 }
 941 #endif /* _WITH_SOCKET */
 942
 943 #if _WITH_SOCKET
 944 int Connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen) {
 945    int result, _errno;
 946    char infobuff[256];
 947
 948    if (!diag_in_handler) diag_flush();
 949    /*sockaddr_info(serv_addr, infobuff, sizeof(infobuff));
 950    Debug3("connect(%d, %s, "F_Zd")", sockfd, infobuff, addrlen);*/
 951 #if 0
 952    Debug18("connect(%d,{0x%02x%02x%02x%02x %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x}, "F_Zd")",
 953            sockfd,
 954            ((unsigned char *)serv_addr)[0],  ((unsigned char *)serv_addr)[1],
 955            ((unsigned char *)serv_addr)[2],  ((unsigned char *)serv_addr)[3],
 956            ((unsigned char *)serv_addr)[4],  ((unsigned char *)serv_addr)[5],
 957            ((unsigned char *)serv_addr)[6],  ((unsigned char *)serv_addr)[7],
 958            ((unsigned char *)serv_addr)[8],  ((unsigned char *)serv_addr)[9],
 959            ((unsigned char *)serv_addr)[10], ((unsigned char *)serv_addr)[11],
 960            ((unsigned char *)serv_addr)[12], ((unsigned char *)serv_addr)[13],
 961            ((unsigned char *)serv_addr)[14], ((unsigned char *)serv_addr)[15],
 962            addrlen);
 963 #else
 964    Debug4("connect(%d, {%d,%s}, "F_socklen")",
 965           sockfd, serv_addr->sa_family,
 966           sockaddr_info(serv_addr, addrlen, infobuff, sizeof(infobuff)),
 967           addrlen);
 968 #endif
 969    result = connect(sockfd, serv_addr, addrlen);
 970    _errno = errno;
 971    if (!diag_in_handler) diag_flush();
 972    Debug1("connect() -> %d", result);
 973    errno = _errno;
 974    return result;
 975 }
 976 #endif /* _WITH_SOCKET */
 977
 978 #if _WITH_SOCKET
 979 int Listen(int s, int backlog) {
 980    int result, _errno;
 981    Debug2("listen(%d, %d)", s, backlog);
 982    result = listen(s, backlog);
 983    _errno = errno;
 984    Debug1("listen() -> %d", result);
 985    errno = _errno;
 986    return result;
 987 }
 988 #endif /* _WITH_SOCKET */
 989
 990 #if _WITH_SOCKET
 991 /* don't forget to handle EINTR when using Accept() ! */
 992 int Accept(int s, struct sockaddr *addr, socklen_t *addrlen) {
 993    int result, _errno;
 994    fd_set accept_s;
 995    if (!diag_in_handler) diag_flush();
 996    FD_ZERO(&accept_s);
 997    FD_SET(s, &accept_s);
 998    if (diag_select(s+1, &accept_s, NULL, NULL, NULL) < 0) {
 999       return -1;
1000    }
1001    Debug3("accept(%d, %p, %p)", s, addr, addrlen);
1002    result = accept(s, addr, addrlen);
1003    _errno = errno;
1004    if (!diag_in_handler) diag_flush();
1005    if (result >= 0) {
1006       char infobuff[256];
1007       sockaddr_info(addr, *addrlen, infobuff, sizeof(infobuff));
1008       Info5("accept(%d, {%d, %s}, "F_socklen") -> %d", s,
1009             addr->sa_family,
1010             sockaddr_info(addr, *addrlen, infobuff, sizeof(infobuff)),
1011             *addrlen, result);
1012    } else {
1013       Debug1("accept(,,) -> %d", result);
1014    }
1015    errno = _errno;
1016    return result;
1017 }
1018 #endif /* _WITH_SOCKET */
1019
1020 #if _WITH_SOCKET
1021 int Getsockname(int s, struct sockaddr *name, socklen_t *namelen) {
1022    int result, _errno;
1023    char infobuff[256];
1024
1025    Debug4("getsockname(%d, %p, %p{"F_socklen"})", s, name, namelen, *namelen);
1026    result = getsockname(s, name, namelen);
1027    _errno = errno;
1028    /*Debug2("getsockname(,, {"F_socklen"}) -> %d",
1029       *namelen, result);*/
1030    Debug3("getsockname(, {%s}, {"F_socklen"}) -> %d",
1031           sockaddr_info(name, *namelen, infobuff, sizeof(infobuff)),
1032           *namelen, result);
1033    errno = _errno;
1034    return result;
1035 }
1036 #endif /* _WITH_SOCKET */
1037
1038 #if _WITH_SOCKET
1039 int Getpeername(int s, struct sockaddr *name, socklen_t *namelen) {
1040    int result, _errno;
1041    char infobuff[256];
1042
1043    Debug4("getpeername(%d, %p, %p{"F_socklen"})", s, name, namelen, *namelen);
1044    result = getpeername(s, name, namelen);
1045    _errno = errno;
1046    sockaddr_info(name, *namelen, infobuff, sizeof(infobuff));
1047    Debug3("getpeername(, {%s}, {"F_socklen"}) -> %d",
1048           infobuff, *namelen, result);
1049    errno = _errno;
1050    return result;
1051 }
1052 #endif /* _WITH_SOCKET */
1053
1054 #if _WITH_SOCKET
1055 int Getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen) {
1056    int result, _errno;
1057    Debug5("getsockopt(%d, %d, %d, %p, {"F_socklen"})",
1058           s, level, optname, optval, *optlen);
1059    result = getsockopt(s, level, optname, optval, optlen);
1060    _errno = errno;
1061    Debug3("getsockopt() -> (,,, 0x%08x, %d), %d",
1062           *(int *)optval, *optlen, result);
1063    errno = _errno;
1064    return result;
1065 }
1066 #endif /* _WITH_SOCKET */
1067
1068 #if _WITH_SOCKET
1069 int Setsockopt(int s, int level, int optname, const void *optval, int optlen) {
1070    int result, _errno;
1071    if (optlen <= sizeof(int)) {
1072       Debug5("setsockopt(%d, %d, %d, {0x%x}, %d)",
1073        s, level, optname, *(unsigned int *)optval, optlen);
1074    } else {
1075       Debug6("setsockopt(%d, %d, %d, {0x%08x,%08x}, %d)",
1076              s, level, optname,
1077              ((unsigned int *)optval)[0], ((unsigned int *)optval)[1],
1078              optlen);
1079    }
1080    result = setsockopt(s, level, optname, optval, optlen);
1081    _errno = errno;
1082    Debug1("setsockopt() -> %d", result);
1083    errno = _errno;
1084    return result;
1085 }
1086 #endif /* _WITH_SOCKET */
1087
1088 #if _WITH_SOCKET
1089 int Recv(int s, void *buf, size_t len, int flags) {
1090    int retval, _errno;
1091    if (!diag_in_handler) diag_flush();
1092    Debug4("recv(%d, %p, "F_Zu", %d)", s, buf, len, flags);
1093    retval = recv(s, buf, len, flags);
1094    _errno = errno;
1095    if (!diag_in_handler) diag_flush();
1096    Debug1("recv() -> %d", retval);
1097    errno = _errno;
1098    return retval;
1099 }
1100 #endif /* _WITH_SOCKET */
1101
1102 #if _WITH_SOCKET
1103 int Recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from,
1104              socklen_t *fromlen) {
1105    int retval, _errno;
1106    char infobuff[256];
1107    if (!diag_in_handler) diag_flush();
1108    Debug6("recvfrom(%d, %p, "F_Zu", %d, %p, "F_socklen")",
1109           s, buf, len, flags, from, *fromlen);
1110    retval = recvfrom(s, buf, len, flags, from, fromlen);
1111    _errno = errno;
1112    if (!diag_in_handler) diag_flush();
1113    if (from) {
1114       Debug4("recvfrom(,,,, {%d,%s}, "F_socklen") -> %d",
1115              from->sa_family,
1116              sockaddr_info(from, *fromlen, infobuff, sizeof(infobuff)),
1117              *fromlen, retval);
1118    } else {
1119       Debug1("recvfrom(,,,, NULL, NULL) -> %d", retval);
1120    }
1121    errno = _errno;
1122    return retval;
1123 }
1124 #endif /* _WITH_SOCKET */
1125
1126 #if _WITH_SOCKET
1127 int Recvmsg(int s, struct msghdr *msgh, int flags) {
1128    int retval, _errno;
1129    if (!diag_in_handler) diag_flush();
1130    char infobuff[256];
1131 #if defined(HAVE_STRUCT_MSGHDR_MSGCONTROL) && defined(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN) && defined(HAVE_STRUCT_MSGHDR_MSGFLAGS)
1132    Debug10("recvmsg(%d, %p{%p,%u,%p,"F_Zu",%p,"F_Zu",%d}, %d)", s, msgh,
1133           msgh->msg_name, msgh->msg_namelen,  msgh->msg_iov,  msgh->msg_iovlen,
1134           msgh->msg_control,  msgh->msg_controllen,  msgh->msg_flags, flags);
1135 #else
1136    Debug7("recvmsg(%d, %p{%p,%u,%p,%u}, %d)", s, msgh,
1137           msgh->msg_name, msgh->msg_namelen,  msgh->msg_iov,  msgh->msg_iovlen,
1138           flags);
1139 #endif
1140    retval = recvmsg(s, msgh, flags);
1141    _errno = errno;
1142    if (!diag_in_handler) diag_flush();
1143 #if defined(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN)
1144    Debug5("recvmsg(, {%s,%u,,"F_Zu",,"F_Zu",}, ) -> %d",
1145           msgh->msg_name?sockaddr_info(msgh->msg_name, msgh->msg_namelen, infobuff, sizeof(infobuff)):"NULL",
1146           msgh->msg_namelen, msgh->msg_iovlen, msgh->msg_controllen,
1147           retval);
1148 #else
1149    Debug4("recvmsg(, {%s,%u,,%u,,}, ) -> %d",
1150           msgh->msg_name?sockaddr_info(msgh->msg_name, msgh->msg_namelen, infobuff, sizeof(infobuff)):"NULL",
1151           msgh->msg_namelen, msgh->msg_iovlen,
1152           retval);
1153 #endif
1154    errno = _errno;
1155    return retval;
1156 }
1157 #endif /* _WITH_SOCKET */
1158
1159 #if _WITH_SOCKET
1160 int Send(int s, const void *mesg, size_t len, int flags) {
1161    int retval, _errno;
1162    if (!diag_in_handler) diag_flush();
1163    Debug5("send(%d, %p[%08x...], "F_Zu", %d)",
1164           s, mesg, ntohl(*(unsigned long *)mesg), len, flags);
1165    retval = send(s, mesg, len, flags);
1166    _errno = errno;
1167    if (!diag_in_handler) diag_flush();
1168    Debug1("send() -> %d", retval);
1169    errno = _errno;
1170    return retval;
1171 }
1172 #endif /* _WITH_SOCKET */
1173
1174 #if _WITH_SOCKET
1175 int Sendto(int s, const void *mesg, size_t len, int flags,
1176            const struct sockaddr *to, socklen_t tolen) {
1177    int retval, _errno;
1178    char infobuff[256];
1179
1180    if (!diag_in_handler) diag_flush();
1181    sockaddr_info(to, tolen, infobuff, sizeof(infobuff));
1182    Debug7("sendto(%d, %p[%08x...], "F_Zu", %d, {%s}, %d)",
1183           s, mesg, htonl(*(unsigned long *)mesg), len, flags, infobuff, tolen);
1184    retval = sendto(s, mesg, len, flags, to, tolen);
1185    _errno = errno;
1186    if (!diag_in_handler) diag_flush();
1187    Debug1("sendto() -> %d", retval);
1188    errno = _errno;
1189    return retval;
1190 }
1191 #endif /* _WITH_SOCKET */
1192
1193 #if _WITH_SOCKET
1194 int Shutdown(int fd, int how) {
1195    int retval, _errno;
1196    Info2("shutdown(%d, %d)", fd, how);
1197    retval = shutdown(fd, how);
1198    _errno = errno;
1199    Debug1("shutdown()  -> %d", retval);
1200    errno = _errno;
1201    return retval;
1202 }
1203 #endif /* _WITH_SOCKET */
1204
1205 unsigned int Sleep(unsigned int seconds) {
1206    unsigned int retval;
1207    Debug1("sleep(%u)", seconds);
1208    retval = sleep(seconds);
1209    Debug1("sleep() -> %u", retval);
1210    return retval;
1211 }
1212
1213 /* obsolete by POSIX.1-2001 */
1214 void Usleep(unsigned long usec) {
1215    Debug1("usleep(%lu)", usec);
1216    usleep(usec);
1217    Debug("usleep() ->");
1218    return;
1219 }
1220
1221 #if HAVE_NANOSLEEP
1222 unsigned int Nanosleep(const struct timespec *req, struct timespec *rem) {
1223    int retval, _errno;
1224    Debug3("nanosleep({"F_time",%ld},%p)", req->tv_sec, req->tv_nsec, rem);
1225    retval = nanosleep(req, rem);
1226    _errno = errno;
1227    if (rem) {
1228       Debug3("nanosleep(,{"F_time",%ld}) -> %d",
1229              rem->tv_sec, rem->tv_nsec, retval);
1230    } else {
1231       Debug1("nanosleep() -> %d", retval);
1232    }
1233    errno = _errno;
1234    return retval;
1235 }
1236 #endif /* HAVE_NANOSLEEP */
1237
1238 int Pause(void) {
1239    int retval, _errno;
1240    Debug("pause()");
1241    retval = pause();
1242    _errno = errno;
1243    Debug1("pause() -> %d", retval);
1244    errno = _errno;
1245    return retval;
1246 }
1247
1248 #if WITH_IP4 || WITH_IP6
1249 struct hostent *Gethostbyname(const char *name) {
1250    struct hostent *hent;
1251    Debug1("gethostbyname(\"%s\")", name);
1252    hent = gethostbyname(name);
1253    if (hent == NULL) {
1254       Debug("gethostbyname() -> NULL");
1255    } else {
1256       Debug4("gethostbyname() -> %d.%d.%d.%d",
1257              ((unsigned char *)hent->h_addr_list[0])[0],
1258              ((unsigned char *)hent->h_addr_list[0])[1],
1259              ((unsigned char *)hent->h_addr_list[0])[2],
1260              ((unsigned char *)hent->h_addr_list[0])[3]);
1261    }
1262    return hent;
1263 }
1264 #endif /* WITH_IP4 || WITH_IP6 */
1265
1266 #if (_WITH_IP4 || _WITH_IP6) && HAVE_GETADDRINFO
1267 int Getaddrinfo(const char *node, const char *service,
1268                 const struct addrinfo *hints, struct addrinfo **res) {
1269    int result;
1270    Debug15("getaddrinfo(%s%s%s, %s%s%s, {%d,%d,%d,%d,"F_socklen",%p,%p,%p}, %p)",
1271            node?"\"":"", node?node:"NULL", node?"\"":"",
1272            service?"\"":"", service?service:"NULL", service?"\"":"",
1273            hints->ai_flags, hints->ai_family, hints->ai_socktype,
1274            hints->ai_protocol, hints->ai_addrlen, hints->ai_addr,
1275            hints->ai_canonname, hints->ai_next, res);
1276    result = getaddrinfo(node, service, hints, res);
1277    if (result == 0) {
1278       char sockbuff[256];
1279       sockaddr_info((*res)->ai_addr, hints->ai_addrlen, sockbuff, sizeof(sockbuff));
1280       Debug2("getaddrinfo(,,,{{%s, %s}) -> 0",
1281              sockbuff,
1282             (*res)->ai_canonname?(*res)->ai_canonname:"");
1283    } else {
1284       Debug2("getaddrinfo(,,,{%p}) -> %d", *res, result);
1285    }
1286    return result;
1287 }
1288 #endif /* (_WITH_IP4 || _WITH_IP6) && HAVE_GETADDRINFO */
1289
1290 #if (WITH_IP4 || WITH_IP6) && HAVE_PROTOTYPE_LIB_getipnodebyname
1291 struct hostent *Getipnodebyname(const char *name, int af, int flags,
1292                                 int *error_num) {
1293    struct hostent *result;
1294    Debug4("getipnodebyname(\"%s\", %d, %d, %p)", name, af, flags, error_num);
1295    result = getipnodebyname(name, af, flags, error_num);
1296    if (result == NULL) {
1297       Debug1("getipnodebyname(,,, {%d}) -> NULL", *error_num);
1298    } else {
1299       Debug4("getipnodebyname() -> {\"%s\", %p, %d, %d, ???}",
1300              result->h_name, result->h_aliases, result->h_addrtype,
1301              result->h_length);
1302    }
1303    return result;
1304 }
1305 #endif /* (WITH_IP4 || WITH_IP6) && HAVE_PROTOTYPE_LIB_getipnodebyname */
1306
1307 void *Malloc(size_t size) {
1308    void *result;
1309    Debug1("malloc("F_Zd")", size);
1310    result = malloc(size);
1311    Debug1("malloc() -> %p", result);
1312    if (result == NULL) {
1313       Error1("malloc("F_Zd"): out of memory", size);
1314       return NULL;
1315    }
1316    return result;
1317 }
1318
1319 void *Calloc(size_t nmemb, size_t size) {
1320    void *result;
1321    Debug2("calloc("F_Zd", "F_Zd")", nmemb, size);
1322    result = calloc(nmemb, size);
1323    Debug1("calloc() -> %p", result);
1324    if (result == NULL) {
1325       Error2("calloc("F_Zd", "F_Zd"): out of memory", nmemb, size);
1326       return NULL;
1327    }
1328    return result;
1329 }
1330
1331 void *Realloc(void *ptr, size_t size) {
1332    void *result;
1333    Debug2("realloc(%p, "F_Zd")", ptr, size);
1334    result = realloc(ptr, size);
1335    Debug1("realloc() -> %p", result);
1336    if (result == NULL) {
1337       Error2("realloc(%p, "F_Zd"): out of memory", ptr, size);
1338       return NULL;
1339    }
1340    return result;
1341 }
1342
1343 #if _WITH_TERMIOS
1344 int Tcgetattr(int fd, struct termios *termios_p) {
1345    int i, result, _errno;
1346    char chars[5*NCCS], *cp = chars;
1347
1348    Debug2("tcgetattr(%d, %p)", fd, termios_p);
1349    result = tcgetattr(fd, termios_p);
1350    _errno = errno;
1351
1352    for (i = 0; i < NCCS-1; ++i) {
1353       cp += sprintf(cp, "%02x,", termios_p->c_cc[i]);
1354    }
1355    sprintf(cp, "%02x", termios_p->c_cc[i]);
1356    Debug6("tcgetattr(, {%08x,%08x,%08x,%08x,%s}) -> %d",
1357           termios_p->c_iflag, termios_p->c_oflag,
1358           termios_p->c_cflag, termios_p->c_lflag,
1359           chars, result);
1360    errno = _errno;
1361    return result;
1362 }
1363 #endif /* _WITH_TERMIOS */
1364
1365 #if _WITH_TERMIOS
1366 int Tcsetattr(int fd, int optional_actions, struct termios *termios_p) {
1367    int i, result, _errno;
1368    char chars[5*NCCS], *cp = chars;
1369
1370    for (i = 0; i < NCCS-1; ++i) {
1371       cp += sprintf(cp, "%02x,", termios_p->c_cc[i]);
1372    }
1373    sprintf(cp, "%02x", termios_p->c_cc[i]);
1374    Debug7("tcsetattr(%d, %d, {%08x,%08x,%08x,%08x,%s})", fd, optional_actions,
1375           termios_p->c_iflag, termios_p->c_oflag,
1376           termios_p->c_cflag, termios_p->c_lflag, chars);
1377    result = tcsetattr(fd, optional_actions, termios_p);
1378    _errno = errno;
1379    Debug1("tcsetattr() -> %d", result);
1380    errno = _errno;
1381    return result;
1382 }
1383 #endif /* _WITH_TERMIOS */
1384
1385 char *Ttyname(int fd) {
1386    char *result;
1387    int _errno;
1388    Debug1("ttyname(%d)", fd);
1389    result = ttyname(fd);
1390    _errno = errno;
1391    if (result)
1392       Debug1("ttyname() -> %s", result);
1393    else
1394       Debug("ttyname() -> NULL");
1395    errno = _errno;
1396    return result;
1397 }
1398
1399 int Isatty(int fd) {
1400    int result, _errno;
1401    Debug1("isatty(%d)", fd);
1402    result = isatty(fd);
1403    _errno = errno;
1404    Debug1("isatty() -> %d", result);
1405    errno = _errno;
1406    return result;
1407 }
1408
1409 #if HAVE_OPENPTY
1410 int Openpty(int *ptyfd, int *ttyfd, char *ptyname, struct termios *termp,
1411             struct winsize *winp) {
1412    int result, _errno;
1413    Debug5("openpty(%p, %p, %p, %p, %p)", ptyfd, ttyfd, ptyname, termp, winp);
1414    result = openpty(ptyfd, ttyfd, ptyname, termp, winp);
1415    _errno = errno;
1416    Info4("openpty({%d}, {%d}, {\"%s\"},,) -> %d", *ptyfd, *ttyfd, ptyname,
1417           result);
1418    errno = _errno;
1419    return result;
1420 }
1421 #endif /* HAVE_OPENPTY */
1422
1423 #if HAVE_GRANTPT
1424 int Grantpt(int fd) {
1425    int result, _errno;
1426    Debug1("grantpt(%d)", fd);
1427    result = grantpt(fd);
1428    _errno = errno;
1429    Debug1("grantpt() -> %d", result);
1430    errno = _errno;
1431    return result;
1432 }
1433 #endif /* HAVE_GRANTPT */
1434
1435 #if HAVE_UNLOCKPT
1436 int Unlockpt(int fd) {
1437    int result, _errno;
1438    Debug1("unlockpt(%d)", fd);
1439    result = unlockpt(fd);
1440    _errno = errno;
1441    Debug1("unlockpt() -> %d", result);
1442    errno = _errno;
1443    return result;
1444 }
1445 #endif /* HAVE_UNLOCKPT */
1446
1447 #if HAVE_PROTOTYPE_LIB_ptsname  /* AIX, not Linux */
1448 char *Ptsname(int fd) {
1449    char *result;
1450    int _errno;
1451    Debug1("ptsname(%d)", fd);
1452    result = ptsname(fd);
1453    _errno = errno;
1454    if (result)
1455       Debug1("ptsname() -> %s", result);
1456    else
1457       Debug("ptsname() -> NULL");
1458    errno = _errno;
1459    return result;
1460 }
1461 #endif /* HAVE_PROTOTYPE_LIB_ptsname */
1462
1463 int Uname(struct utsname *buf) {
1464    int result, _errno;
1465    Debug1("uname(%p)", buf);
1466    result = uname(buf);
1467    _errno = errno;
1468 #if UNAME_DOMAINNAME
1469    Debug6("uname({%s, %s, %s, %s, %s, %s})",
1470           buf->sysname, buf->nodename, buf->release,
1471           buf->version, buf->machine, buf->domainname);
1472 #else
1473    Debug5("uname({%s, %s, %s, %s, %s})",
1474           buf->sysname, buf->nodename, buf->release,
1475           buf->version, buf->machine);
1476 #endif
1477    errno = _errno;
1478    return result;
1479 }
1480
1481 int Gethostname(char *name, size_t len) {
1482    int result, _errno;
1483    Debug2("gethostname(%p, "F_Zu")", name, len);
1484    result = gethostname(name, len);
1485    _errno = errno;
1486    Debug2("gethostname(\"%s\", ) -> %d", name, result);
1487    errno = _errno;
1488    return result;
1489 }
1490
1491 /* due to Linux docu, it does not set errno */
1492 int Atexit(void (*func)(void)) {
1493    int result;
1494    Debug1("atexit(%p)", func);
1495    result = atexit(func);
1496    Debug1("atexit() -> %d", result);
1497    return result;
1498 }
1499
1500
1501 void Exit(int status) {
1502    if (!diag_in_handler) diag_flush();
1503    Debug1("exit(%d)", status);
1504    exit(status);
1505 }
1506
1507 void Abort(void) {
1508    Debug("abort()");
1509    abort();
1510 }
1511
1512 int Mkstemp(char *template) {
1513    int result, _errno;
1514    Debug1("mkstemp(\"%s\")", template);
1515    result = mkstemp(template);
1516    _errno = errno;
1517    Info2("mkstemp({%s}) -> %d", template, result);
1518    errno = _errno;
1519    return result;
1520 }
1521
1522 int Setenv(const char *name, const char *value, int overwrite) {
1523    int result, _errno;
1524    Debug3("setenv(\"%s\", \"%s\", %d)", name, value, overwrite);
1525    result = setenv(name, value, overwrite);
1526    _errno = errno;
1527    Debug1("setenv() -> %d", result);
1528    errno = _errno;
1529    return result;
1530 }
1531
1532 #if HAVE_UNSETENV
1533 /* on Linux it returns int but on FreeBSD void.
1534    we do not expect many errors, so we take void which works on all systems. */
1535 void Unsetenv(const char *name) {
1536    int _errno;
1537    Debug1("unsetenv(\"%s\")", name);
1538    unsetenv(name);
1539    _errno = errno;
1540    Debug("unsetenv() ->");
1541    errno = _errno;
1542    return;
1543 }
1544 #endif
1545
1546 #if WITH_READLINE
1547
1548 char *Readline(const char *prompt) {
1549    char *result;
1550
1551    if (prompt) {
1552       Debug1("readline(\"%s\")", prompt);
1553    } else {
1554       Debug("readline(NULL)");
1555    }
1556    result = readline(prompt);
1557    if (result) {
1558       Debug("readline() -> \"...\"");
1559    } else {
1560       Debug("readline() -> NULL");
1561    }
1562    return result;
1563 }
1564
1565 void Using_history(void) {
1566    Debug("using_history()");
1567    using_history();
1568    Debug("using_history() ->");
1569 }
1570
1571 int Read_history(const char *filename) {
1572    int result;
1573
1574    if (filename) {
1575       Debug1("read_history(\"%s\")", filename);
1576    } else {
1577       Debug("read_history(NULL)");
1578    }
1579    result = read_history(filename);
1580    if (result) {
1581       Debug1("read_history() -> %d", result);
1582    } else {
1583       Debug("read_history() -> 0");
1584    }
1585    return result;
1586 }
1587
1588 int Write_history(const char *filename) {
1589    int result;
1590
1591    if (filename) {
1592       Debug1("write_history(\"%s\")", filename);
1593    } else {
1594       Debug("write_history(NULL)");
1595    }
1596    result = write_history(filename);
1597    if (result) {
1598       Debug1("write_history() -> %d", result);
1599    } else {
1600       Debug("write_history() -> 0");
1601    }
1602    return result;
1603 }
1604
1605 int Append_history(int nelements, const char *filename) {
1606    int result;
1607
1608    if (filename) {
1609       Debug2("append_history(%d, \"%s\")", nelements, filename);
1610    } else {
1611       Debug1("append_history(%d, NULL)", nelements);
1612    }
1613    result = append_history(nelements, filename);
1614    if (result) {
1615       Debug1("append_history() -> %d", result);
1616    } else {
1617       Debug("append_history() -> 0");
1618    }
1619    return result;
1620 }
1621
1622 int Where_history(void) {
1623    int result;
1624
1625    Debug("where_history()");
1626    result = where_history();
1627    Debug1("where_history() -> %d", result);
1628    return result;
1629 }
1630
1631 void Add_history(const char *string) {
1632    Debug1("add_history(\"%s\")", string);
1633    add_history(string);
1634    Debug("add_history() ->");
1635 }
1636
1637 #endif /* WITH_READLINE */
1638
1639 #endif /* WITH_SYCLS */