sycls.c

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