nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 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 #if 0
791 /* we only show the first word of the fd_set's; hope this is enough for most
792 cases. */
793 int Pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
794 struct timespec *timeout, const sigset_t *sigmask) {
795 int result, _errno;
796 #if HAVE_FDS_BITS
797 Debug8("pselect(%d, &0x%lx, &0x%lx, &0x%lx, %s%lu.%06u, {0x%lx})",
798 n, readfds->fds_bits[0], writefds->fds_bits[0],
799 exceptfds->fds_bits[0],
800 timeout?"&":"NULL/", timeout?timeout->tv_sec:0,
801 timeout?timeout->tv_nsec:0, /*sigmask->__val[0]*/
802 *(unsigned long *)sigmask);
803 #else
804 Debug8("pselect(%d, &0x%lx, &0x%lx, &0x%lx, %s%lu.%06u, {0x%lx})",
805 n, readfds->__fds_bits[0], writefds->__fds_bits[0],
806 exceptfds->__fds_bits[0],
807 timeout?"&":"NULL/", timeout?timeout->tv_sec:0,
808 timeout?timeout->tv_nsec:0, *(unsigned long *)sigmask);
809 #endif
810 result = pselect(n, readfds, writefds, exceptfds, timeout, sigmask);
811 _errno = errno;
812 #if HAVE_FDS_BITS
813 Debug4("pselect -> (, 0x%lx, 0x%lx, 0x%lx, , ), %d",
814 readfds->fds_bits[0], writefds->fds_bits[0], exceptfds->fds_bits[0],
815 result);
816 #else
817 Debug4("pselect -> (, 0x%lx, 0x%lx, 0x%lx, , ), %d",
818 readfds->__fds_bits[0], writefds->__fds_bits[0],
819 exceptfds->__fds_bits[0],
820 result);
821 #endif
822 errno = _errno;
823 return result;
824 }
825 #endif /* 0 */
826  
827 pid_t Fork(void) {
828 pid_t pid;
829 int _errno;
830 Debug("fork()");
831 pid = fork();
832 _errno = errno;
833 Debug1("fork() -> %d", pid); /* attention: called twice! */
834 errno = _errno;
835 return pid;
836 }
837  
838 pid_t Waitpid(pid_t pid, int *status, int options) {
839 int _errno;
840 pid_t retval;
841 if (!diag_in_handler) diag_flush();
842 Debug3("waitpid("F_pid", %p, %d)", pid, status, options);
843 retval = waitpid(pid, status, options);
844 _errno = errno;
845 if (!diag_in_handler) diag_flush();
846 Debug2("waitpid(, {%d}, ) -> "F_pid, *status, retval);
847 errno = _errno;
848 return retval;
849 }
850  
851 sighandler_t Signal(int signum, sighandler_t handler) {
852 int _errno;
853 sighandler_t retval;
854 Debug2("signal(%d, %p)", signum, handler);
855 retval = signal(signum, handler);
856 _errno = errno;
857 Debug1("signal() -> %p", retval);
858 errno = _errno;
859 return retval;
860 }
861  
862 #if HAVE_SIGACTION
863 int Sigaction(int signum, const struct sigaction *act,
864 struct sigaction *oldact) {
865 int retval;
866 Debug3("sigaction(%d, %p, %p)", signum, act, oldact);
867 retval = sigaction(signum, act, oldact);
868 Debug1("sigaction() -> %d", retval);
869 return retval;
870 }
871 #endif /* HAVE_SIGACTION */
872  
873 int Sigprocmask(int how, const sigset_t *set, sigset_t *oldset) {
874 int _errno, result;
875 Debug3("sigprocmask(%d, {0x%lx}, %p)", how, *(unsigned long *)set, oldset);
876 result = sigprocmask(how, set, oldset);
877 _errno = errno;
878 Debug4("sigprocmask(,,%s%lu%s) -> %d",
879 oldset?" {0x":"", oldset?*(unsigned long *)oldset:0, oldset?"}":"", result);
880 errno = _errno;
881 return result;
882 }
883  
884 unsigned int Alarm(unsigned int seconds) {
885 unsigned int retval;
886 Debug1("alarm(%u)", seconds);
887 retval = alarm(seconds);
888 Debug1("alarm() -> %u", retval);
889 return retval;
890 }
891  
892 int Kill(pid_t pid, int sig) {
893 int retval, _errno;
894 Debug2("kill("F_pid", %d)", pid, sig);
895 retval = kill(pid, sig);
896 _errno = errno;
897 Debug1("kill() -> %d", retval);
898 errno = _errno;
899 return retval;
900 }
901  
902 int Link(const char *oldpath, const char *newpath) {
903 int retval, _errno;
904 Debug2("link(\"%s\", \"%s\")", oldpath, newpath);
905 retval = link(oldpath, newpath);
906 _errno = errno;
907 Debug1("link() -> %d", retval);
908 errno = _errno;
909 return retval;
910 }
911  
912 int Execvp(const char *file, char *const argv[]) {
913 int result, _errno;
914 if (argv[1] == NULL)
915 Debug2("execvp(\"%s\", \"%s\")", file, argv[0]);
916 else if (argv[2] == NULL)
917 Debug3("execvp(\"%s\", \"%s\" \"%s\")", file, argv[0], argv[1]);
918 else if (argv[3] == NULL)
919 Debug4("execvp(\"%s\", \"%s\" \"%s\" \"%s\")", file, argv[0], argv[1], argv[2]);
920 else if (argv[4] == NULL)
921 Debug5("execvp(\"%s\", \"%s\" \"%s\" \"%s\" \"%s\")", file, argv[0], argv[1], argv[2], argv[3]);
922 else if (argv[5] == NULL)
923 Debug6("execvp(\"%s\", \"%s\" \"%s\" \"%s\" \"%s\" \"%s\")", file, argv[0], argv[1], argv[2], argv[3], argv[4]);
924 else
925 Debug6("execvp(\"%s\", \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" ...)", file, argv[0], argv[1], argv[2], argv[3], argv[4]);
926  
927 result = execvp(file, argv);
928 _errno = errno;
929 Debug1("execvp() -> %d", result);
930 errno = _errno;
931 return result;
932 }
933  
934 int System(const char *string) {
935 int result, _errno;
936 Debug1("system(\"%s\")", string);
937 diag_immediate_exit = 1;
938 result = system(string);
939 diag_immediate_exit = 0;
940 _errno = errno;
941 Debug1("system() -> %d", result);
942 errno = _errno;
943 return result;
944 }
945  
946 int Socketpair(int d, int type, int protocol, int sv[2]) {
947 int result, _errno;
948 Debug4("socketpair(%d, %d, %d, %p)", d, type, protocol, sv);
949 result = socketpair(d, type, protocol, sv);
950 _errno = errno;
951 Info6("socketpair(%d, %d, %d, {%d,%d}) -> %d", d, type, protocol, sv[0], sv[1], result);
952 errno = _errno;
953 return result;
954 }
955  
956 #if _WITH_SOCKET
957 int Socket(int domain, int type, int protocol) {
958 int result, _errno;
959 Debug3("socket(%d, %d, %d)", domain, type, protocol);
960 result = socket(domain, type, protocol);
961 _errno = errno;
962 Info4("socket(%d, %d, %d) -> %d", domain, type, protocol, result);
963 errno = _errno;
964 return result;
965 }
966 #endif /* _WITH_SOCKET */
967  
968 #if _WITH_SOCKET
969 int Bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) {
970 int result, _errno;
971 char infobuff[256];
972  
973 sockaddr_info(my_addr, addrlen, infobuff, sizeof(infobuff));
974 Debug3("bind(%d, %s, "F_socklen")", sockfd, infobuff, addrlen);
975 result = bind(sockfd, my_addr, addrlen);
976 _errno = errno;
977 Debug1("bind() -> %d", result);
978 errno = _errno;
979 return result;
980 }
981 #endif /* _WITH_SOCKET */
982  
983 #if _WITH_SOCKET
984 int Connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen) {
985 int result, _errno;
986 char infobuff[256];
987  
988 if (!diag_in_handler) diag_flush();
989 /*sockaddr_info(serv_addr, infobuff, sizeof(infobuff));
990 Debug3("connect(%d, %s, "F_Zd")", sockfd, infobuff, addrlen);*/
991 #if 0
992 Debug18("connect(%d,{0x%02x%02x%02x%02x %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x}, "F_socklen")",
993 sockfd,
994 ((unsigned char *)serv_addr)[0], ((unsigned char *)serv_addr)[1],
995 ((unsigned char *)serv_addr)[2], ((unsigned char *)serv_addr)[3],
996 ((unsigned char *)serv_addr)[4], ((unsigned char *)serv_addr)[5],
997 ((unsigned char *)serv_addr)[6], ((unsigned char *)serv_addr)[7],
998 ((unsigned char *)serv_addr)[8], ((unsigned char *)serv_addr)[9],
999 ((unsigned char *)serv_addr)[10], ((unsigned char *)serv_addr)[11],
1000 ((unsigned char *)serv_addr)[12], ((unsigned char *)serv_addr)[13],
1001 ((unsigned char *)serv_addr)[14], ((unsigned char *)serv_addr)[15],
1002 addrlen);
1003 #else
1004 Debug4("connect(%d, {%d,%s}, "F_Zd")",
1005 sockfd, serv_addr->sa_family,
1006 sockaddr_info(serv_addr, addrlen, infobuff, sizeof(infobuff)),
1007 addrlen);
1008 #endif
1009 result = connect(sockfd, serv_addr, addrlen);
1010 _errno = errno;
1011 if (!diag_in_handler) diag_flush();
1012 Debug1("connect() -> %d", result);
1013 errno = _errno;
1014 return result;
1015 }
1016 #endif /* _WITH_SOCKET */
1017  
1018 #if _WITH_SOCKET
1019 int Listen(int s, int backlog) {
1020 int result, _errno;
1021 Debug2("listen(%d, %d)", s, backlog);
1022 result = listen(s, backlog);
1023 _errno = errno;
1024 Debug1("listen() -> %d", result);
1025 errno = _errno;
1026 return result;
1027 }
1028 #endif /* _WITH_SOCKET */
1029  
1030 #if _WITH_SOCKET
1031 /* don't forget to handle EINTR when using Accept() ! */
1032 int Accept(int s, struct sockaddr *addr, socklen_t *addrlen) {
1033 int result, _errno;
1034 fd_set accept_s;
1035 if (!diag_in_handler) diag_flush();
1036 FD_ZERO(&accept_s);
1037 FD_SET(s, &accept_s);
1038 if (diag_select(s+1, &accept_s, NULL, NULL, NULL) < 0) {
1039 return -1;
1040 }
1041 Debug3("accept(%d, %p, %p)", s, addr, addrlen);
1042 result = accept(s, addr, addrlen);
1043 _errno = errno;
1044 if (!diag_in_handler) diag_flush();
1045 if (result >= 0) {
1046 char infobuff[256];
1047 sockaddr_info(addr, *addrlen, infobuff, sizeof(infobuff));
1048 Info5("accept(%d, {%d, %s}, "F_socklen") -> %d", s,
1049 addr->sa_family,
1050 sockaddr_info(addr, *addrlen, infobuff, sizeof(infobuff)),
1051 *addrlen, result);
1052 } else {
1053 Debug1("accept(,,) -> %d", result);
1054 }
1055 errno = _errno;
1056 return result;
1057 }
1058 #endif /* _WITH_SOCKET */
1059  
1060 #if _WITH_SOCKET
1061 int Getsockname(int s, struct sockaddr *name, socklen_t *namelen) {
1062 int result, _errno;
1063 char infobuff[256];
1064  
1065 Debug4("getsockname(%d, %p, %p{"F_socklen"})", s, name, namelen, *namelen);
1066 result = getsockname(s, name, namelen);
1067 _errno = errno;
1068 /*Debug2("getsockname(,, {"F_socklen"}) -> %d",
1069 *namelen, result);*/
1070 Debug3("getsockname(, {%s}, {"F_socklen"}) -> %d",
1071 sockaddr_info(name, *namelen, infobuff, sizeof(infobuff)),
1072 *namelen, result);
1073 errno = _errno;
1074 return result;
1075 }
1076 #endif /* _WITH_SOCKET */
1077  
1078 #if _WITH_SOCKET
1079 int Getpeername(int s, struct sockaddr *name, socklen_t *namelen) {
1080 int result, _errno;
1081 char infobuff[256];
1082  
1083 Debug4("getpeername(%d, %p, %p{"F_socklen"})", s, name, namelen, *namelen);
1084 result = getpeername(s, name, namelen);
1085 _errno = errno;
1086 sockaddr_info(name, *namelen, infobuff, sizeof(infobuff));
1087 Debug3("getpeername(, {%s}, {"F_socklen"}) -> %d",
1088 infobuff, *namelen, result);
1089 errno = _errno;
1090 return result;
1091 }
1092 #endif /* _WITH_SOCKET */
1093  
1094 #if _WITH_SOCKET
1095 int Getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen) {
1096 int result, _errno;
1097 Debug5("getsockopt(%d, %d, %d, %p, {"F_socklen"})",
1098 s, level, optname, optval, *optlen);
1099 result = getsockopt(s, level, optname, optval, optlen);
1100 _errno = errno;
1101 Debug3("getsockopt() -> (,,, 0x%08x, %d), %d",
1102 *(int *)optval, *optlen, result);
1103 errno = _errno;
1104 return result;
1105 }
1106 #endif /* _WITH_SOCKET */
1107  
1108 #if _WITH_SOCKET
1109 int Setsockopt(int s, int level, int optname, const void *optval, int optlen) {
1110 int result, _errno;
1111 if (optlen <= sizeof(int)) {
1112 Debug5("setsockopt(%d, %d, %d, {0x%x}, %d)",
1113 s, level, optname, *(unsigned int *)optval, optlen);
1114 } else {
1115 Debug6("setsockopt(%d, %d, %d, {0x%08x,%08x}, %d)",
1116 s, level, optname,
1117 ((unsigned int *)optval)[0], ((unsigned int *)optval)[1],
1118 optlen);
1119 }
1120 result = setsockopt(s, level, optname, optval, optlen);
1121 _errno = errno;
1122 Debug1("setsockopt() -> %d", result);
1123 errno = _errno;
1124 return result;
1125 }
1126 #endif /* _WITH_SOCKET */
1127  
1128 #if _WITH_SOCKET
1129 int Recv(int s, void *buf, size_t len, int flags) {
1130 int retval, _errno;
1131 if (!diag_in_handler) diag_flush();
1132 Debug4("recv(%d, %p, "F_Zu", %d)", s, buf, len, flags);
1133 retval = recv(s, buf, len, flags);
1134 _errno = errno;
1135 if (!diag_in_handler) diag_flush();
1136 Debug1("recv() -> %d", retval);
1137 errno = _errno;
1138 return retval;
1139 }
1140 #endif /* _WITH_SOCKET */
1141  
1142 #if _WITH_SOCKET
1143 int Recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from,
1144 socklen_t *fromlen) {
1145 int retval, _errno;
1146 char infobuff[256];
1147 if (!diag_in_handler) diag_flush();
1148 Debug6("recvfrom(%d, %p, "F_Zu", %d, %p, "F_socklen")",
1149 s, buf, len, flags, from, *fromlen);
1150 retval = recvfrom(s, buf, len, flags, from, fromlen);
1151 _errno = errno;
1152 if (!diag_in_handler) diag_flush();
1153 if (from) {
1154 Debug4("recvfrom(,,,, {%d,%s}, "F_socklen") -> %d",
1155 from->sa_family,
1156 sockaddr_info(from, *fromlen, infobuff, sizeof(infobuff)),
1157 *fromlen, retval);
1158 } else {
1159 Debug1("recvfrom(,,,, NULL, NULL) -> %d", retval);
1160 }
1161 errno = _errno;
1162 return retval;
1163 }
1164 #endif /* _WITH_SOCKET */
1165  
1166 #if _WITH_SOCKET
1167 int Recvmsg(int s, struct msghdr *msgh, int flags) {
1168 int retval, _errno;
1169 if (!diag_in_handler) diag_flush();
1170 char infobuff[256];
1171 #if defined(HAVE_STRUCT_MSGHDR_MSGCONTROL) && defined(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN) && defined(HAVE_STRUCT_MSGHDR_MSGFLAGS)
1172 Debug10("recvmsg(%d, %p{%p,%u,%p,%u,%p,%u,%d}, %d)", s, msgh,
1173 msgh->msg_name, msgh->msg_namelen, msgh->msg_iov, msgh->msg_iovlen,
1174 msgh->msg_control, msgh->msg_controllen, msgh->msg_flags, flags);
1175 #else
1176 Debug7("recvmsg(%d, %p{%p,%u,%p,%u}, %d)", s, msgh,
1177 msgh->msg_name, msgh->msg_namelen, msgh->msg_iov, msgh->msg_iovlen,
1178 flags);
1179 #endif
1180 retval = recvmsg(s, msgh, flags);
1181 _errno = errno;
1182 if (!diag_in_handler) diag_flush();
1183 #if defined(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN)
1184 Debug5("recvmsg(, {%s,%u,,"F_Zu",,"F_Zu",}, ) -> %d",
1185 msgh->msg_name?sockaddr_info(msgh->msg_name, msgh->msg_namelen, infobuff, sizeof(infobuff)):"NULL",
1186 msgh->msg_namelen, msgh->msg_iovlen, msgh->msg_controllen,
1187 retval);
1188 #else
1189 Debug4("recvmsg(, {%s,%u,,%u,,}, ) -> %d",
1190 msgh->msg_name?sockaddr_info(msgh->msg_name, msgh->msg_namelen, infobuff, sizeof(infobuff)):"NULL",
1191 msgh->msg_namelen, msgh->msg_iovlen,
1192 retval);
1193 #endif
1194 errno = _errno;
1195 return retval;
1196 }
1197 #endif /* _WITH_SOCKET */
1198  
1199 #if _WITH_SOCKET
1200 int Send(int s, const void *mesg, size_t len, int flags) {
1201 int retval, _errno;
1202 if (!diag_in_handler) diag_flush();
1203 Debug5("send(%d, %p[%08x...], "F_Zu", %d)",
1204 s, mesg, ntohl(*(unsigned long *)mesg), len, flags);
1205 retval = send(s, mesg, len, flags);
1206 _errno = errno;
1207 Debug1("send() -> %d", retval);
1208 errno = _errno;
1209 return retval;
1210 }
1211 #endif /* _WITH_SOCKET */
1212  
1213 #if _WITH_SOCKET
1214 int Sendto(int s, const void *mesg, size_t len, int flags,
1215 const struct sockaddr *to, socklen_t tolen) {
1216 int retval, _errno;
1217 char infobuff[256];
1218  
1219 if (!diag_in_handler) diag_flush();
1220 sockaddr_info(to, tolen, infobuff, sizeof(infobuff));
1221 Debug7("sendto(%d, %p[%08x...], "F_Zu", %d, {%s}, %d)",
1222 s, mesg, htonl(*(unsigned long *)mesg), len, flags, infobuff, tolen);
1223 retval = sendto(s, mesg, len, flags, to, tolen);
1224 _errno = errno;
1225 if (!diag_in_handler) diag_flush();
1226 Debug1("sendto() -> %d", retval);
1227 errno = _errno;
1228 return retval;
1229 }
1230 #endif /* _WITH_SOCKET */
1231  
1232 #if _WITH_SOCKET
1233 int Shutdown(int fd, int how) {
1234 int retval, _errno;
1235 Info2("shutdown(%d, %d)", fd, how);
1236 retval = shutdown(fd, how);
1237 _errno = errno;
1238 Debug1("shutdown() -> %d", retval);
1239 errno = _errno;
1240 return retval;
1241 }
1242 #endif /* _WITH_SOCKET */
1243  
1244 unsigned int Sleep(unsigned int seconds) {
1245 unsigned int retval;
1246 Debug1("sleep(%u)", seconds);
1247 retval = sleep(seconds);
1248 Debug1("sleep() -> %u", retval);
1249 return retval;
1250 }
1251  
1252 /* obsolete by POSIX.1-2001 */
1253 void Usleep(unsigned long usec) {
1254 Debug1("usleep(%lu)", usec);
1255 usleep(usec);
1256 Debug("usleep() ->");
1257 return;
1258 }
1259  
1260 #if HAVE_NANOSLEEP
1261 unsigned int Nanosleep(const struct timespec *req, struct timespec *rem) {
1262 int retval, _errno;
1263 Debug3("nanosleep({"F_time",%ld},%p)", req->tv_sec, req->tv_nsec, rem);
1264 retval = nanosleep(req, rem);
1265 _errno = errno;
1266 if (rem) {
1267 Debug3("nanosleep(,{"F_time",%ld}) -> %d",
1268 rem->tv_sec, rem->tv_nsec, retval);
1269 } else {
1270 Debug1("nanosleep() -> %d", retval);
1271 }
1272 errno = _errno;
1273 return retval;
1274 }
1275 #endif /* HAVE_NANOSLEEP */
1276  
1277 int Pause(void) {
1278 int retval, _errno;
1279 Debug("pause()");
1280 retval = pause();
1281 _errno = errno;
1282 Debug1("pause() -> %d", retval);
1283 errno = _errno;
1284 return retval;
1285 }
1286  
1287 #if _WITH_IP4 || _WITH_IP6
1288 struct hostent *Gethostbyname(const char *name) {
1289 struct hostent *hent;
1290 Debug1("gethostbyname(\"%s\")", name);
1291 hent = gethostbyname(name);
1292 if (hent == NULL) {
1293 Debug("gethostbyname() -> NULL");
1294 } else {
1295 Debug4("gethostbyname() -> %d.%d.%d.%d",
1296 ((unsigned char *)hent->h_addr_list[0])[0],
1297 ((unsigned char *)hent->h_addr_list[0])[1],
1298 ((unsigned char *)hent->h_addr_list[0])[2],
1299 ((unsigned char *)hent->h_addr_list[0])[3]);
1300 }
1301 return hent;
1302 }
1303 #endif /* _WITH_IP4 || _WITH_IP6 */
1304  
1305 #if (_WITH_IP4 || _WITH_IP6) && HAVE_GETADDRINFO
1306 int Getaddrinfo(const char *node, const char *service,
1307 const struct addrinfo *hints, struct addrinfo **res) {
1308 int result;
1309 Debug15("getaddrinfo(%s%s%s, %s%s%s, {%d,%d,%d,%d,"F_socklen",%p,%p,%p}, %p)",
1310 node?"\"":"", node?node:"NULL", node?"\"":"",
1311 service?"\"":"", service?service:"NULL", service?"\"":"",
1312 hints->ai_flags, hints->ai_family, hints->ai_socktype,
1313 hints->ai_protocol, hints->ai_addrlen, hints->ai_addr,
1314 hints->ai_canonname, hints->ai_next, res);
1315 result = getaddrinfo(node, service, hints, res);
1316 if (result == 0) {
1317 char sockbuff[256];
1318 sockaddr_info((*res)->ai_addr, hints->ai_addrlen, sockbuff, sizeof(sockbuff));
1319 Debug2("getaddrinfo(,,,{{%s, %s}) -> 0",
1320 sockbuff,
1321 (*res)->ai_canonname?(*res)->ai_canonname:"");
1322 } else {
1323 Debug2("getaddrinfo(,,,{%p}) -> %d", *res, result);
1324 }
1325 return result;
1326 }
1327 #endif /* (_WITH_IP4 || _WITH_IP6) && HAVE_GETADDRINFO */
1328  
1329 #if (WITH_IP4 || WITH_IP6) && HAVE_PROTOTYPE_LIB_getipnodebyname
1330 struct hostent *Getipnodebyname(const char *name, int af, int flags,
1331 int *error_num) {
1332 struct hostent *result;
1333 Debug4("getipnodebyname(\"%s\", %d, %d, %p)", name, af, flags, error_num);
1334 result = getipnodebyname(name, af, flags, error_num);
1335 if (result == NULL) {
1336 Debug1("getipnodebyname(,,, {%d}) -> NULL", *error_num);
1337 } else {
1338 Debug4("getipnodebyname() -> {\"%s\", %p, %d, %d, ???}",
1339 result->h_name, result->h_aliases, result->h_addrtype,
1340 result->h_length);
1341 }
1342 return result;
1343 }
1344 #endif /* (WITH_IP4 || WITH_IP6) && HAVE_PROTOTYPE_LIB_getipnodebyname */
1345  
1346 void *Malloc(size_t size) {
1347 void *result;
1348 Debug1("malloc("F_Zd")", size);
1349 result = malloc(size);
1350 Debug1("malloc() -> %p", result);
1351 if (result == NULL) {
1352 Error1("malloc("F_Zd"): out of memory", size);
1353 return NULL;
1354 }
1355 return result;
1356 }
1357  
1358 void *Calloc(size_t nmemb, size_t size) {
1359 void *result;
1360 Debug2("calloc("F_Zd", "F_Zd")", nmemb, size);
1361 result = calloc(nmemb, size);
1362 Debug1("calloc() -> %p", result);
1363 if (result == NULL) {
1364 Error2("calloc("F_Zd", "F_Zd"): out of memory", nmemb, size);
1365 return NULL;
1366 }
1367 return result;
1368 }
1369  
1370 void *Realloc(void *ptr, size_t size) {
1371 void *result;
1372 Debug2("realloc(%p, "F_Zd")", ptr, size);
1373 result = realloc(ptr, size);
1374 Debug1("realloc() -> %p", result);
1375 if (result == NULL) {
1376 Error2("realloc(%p, "F_Zd"): out of memory", ptr, size);
1377 return NULL;
1378 }
1379 return result;
1380 }
1381  
1382 #if _WITH_TERMIOS
1383 int Tcgetattr(int fd, struct termios *termios_p) {
1384 int i, result, _errno;
1385 char chars[5*NCCS], *cp = chars;
1386  
1387 Debug2("tcgetattr(%d, %p)", fd, termios_p);
1388 result = tcgetattr(fd, termios_p);
1389 _errno = errno;
1390  
1391 for (i = 0; i < NCCS-1; ++i) {
1392 cp += sprintf(cp, "%02x,", termios_p->c_cc[i]);
1393 }
1394 sprintf(cp, "%02x", termios_p->c_cc[i]);
1395 Debug6("tcgetattr(, {%08x,%08x,%08x,%08x,%s}) -> %d",
1396 termios_p->c_iflag, termios_p->c_oflag,
1397 termios_p->c_cflag, termios_p->c_lflag,
1398 chars, result);
1399 errno = _errno;
1400 return result;
1401 }
1402 #endif /* _WITH_TERMIOS */
1403  
1404 #if _WITH_TERMIOS
1405 int Tcsetattr(int fd, int optional_actions, struct termios *termios_p) {
1406 int i, result, _errno;
1407 char chars[5*NCCS], *cp = chars;
1408  
1409 for (i = 0; i < NCCS-1; ++i) {
1410 cp += sprintf(cp, "%02x,", termios_p->c_cc[i]);
1411 }
1412 sprintf(cp, "%02x", termios_p->c_cc[i]);
1413 Debug7("tcsetattr(%d, %d, {%08x,%08x,%08x,%08x,%s})", fd, optional_actions,
1414 termios_p->c_iflag, termios_p->c_oflag,
1415 termios_p->c_cflag, termios_p->c_lflag, chars);
1416 result = tcsetattr(fd, optional_actions, termios_p);
1417 _errno = errno;
1418 Debug1("tcsetattr() -> %d", result);
1419 errno = _errno;
1420 return result;
1421 }
1422 #endif /* _WITH_TERMIOS */
1423  
1424 char *Ttyname(int fd) {
1425 char *result;
1426 int _errno;
1427 Debug1("ttyname(%d)", fd);
1428 result = ttyname(fd);
1429 _errno = errno;
1430 if (result)
1431 Debug1("ttyname() -> %s", result);
1432 else
1433 Debug("ttyname() -> NULL");
1434 errno = _errno;
1435 return result;
1436 }
1437  
1438 int Isatty(int fd) {
1439 int result, _errno;
1440 Debug1("isatty(%d)", fd);
1441 result = isatty(fd);
1442 _errno = errno;
1443 Debug1("isatty() -> %d", result);
1444 errno = _errno;
1445 return result;
1446 }
1447  
1448 #if HAVE_OPENPTY
1449 int Openpty(int *ptyfd, int *ttyfd, char *ptyname, struct termios *termp,
1450 struct winsize *winp) {
1451 int result, _errno;
1452 Debug5("openpty(%p, %p, %p, %p, %p)", ptyfd, ttyfd, ptyname, termp, winp);
1453 result = openpty(ptyfd, ttyfd, ptyname, termp, winp);
1454 _errno = errno;
1455 Info4("openpty({%d}, {%d}, {\"%s\"},,) -> %d", *ptyfd, *ttyfd, ptyname,
1456 result);
1457 errno = _errno;
1458 return result;
1459 }
1460 #endif /* HAVE_OPENPTY */
1461  
1462 #if HAVE_GRANTPT
1463 int Grantpt(int fd) {
1464 int result, _errno;
1465 Debug1("grantpt(%d)", fd);
1466 result = grantpt(fd);
1467 _errno = errno;
1468 Debug1("grantpt() -> %d", result);
1469 errno = _errno;
1470 return result;
1471 }
1472 #endif /* HAVE_GRANTPT */
1473  
1474 #if HAVE_UNLOCKPT
1475 int Unlockpt(int fd) {
1476 int result, _errno;
1477 Debug1("unlockpt(%d)", fd);
1478 result = unlockpt(fd);
1479 _errno = errno;
1480 Debug1("unlockpt() -> %d", result);
1481 errno = _errno;
1482 return result;
1483 }
1484 #endif /* HAVE_UNLOCKPT */
1485  
1486 #if HAVE_PROTOTYPE_LIB_ptsname /* AIX, not Linux */
1487 char *Ptsname(int fd) {
1488 char *result;
1489 int _errno;
1490 Debug1("ptsname(%d)", fd);
1491 result = ptsname(fd);
1492 _errno = errno;
1493 if (result)
1494 Debug1("ptsname() -> %s", result);
1495 else
1496 Debug("ptsname() -> NULL");
1497 errno = _errno;
1498 return result;
1499 }
1500 #endif /* HAVE_PROTOTYPE_LIB_ptsname */
1501  
1502 int Uname(struct utsname *buf) {
1503 int result, _errno;
1504 Debug1("uname(%p)", buf);
1505 result = uname(buf);
1506 _errno = errno;
1507 #if UNAME_DOMAINNAME
1508 Debug6("uname({%s, %s, %s, %s, %s, %s})",
1509 buf->sysname, buf->nodename, buf->release,
1510 buf->version, buf->machine, buf->domainname);
1511 #else
1512 Debug5("uname({%s, %s, %s, %s, %s})",
1513 buf->sysname, buf->nodename, buf->release,
1514 buf->version, buf->machine);
1515 #endif
1516 errno = _errno;
1517 return result;
1518 }
1519  
1520 int Gethostname(char *name, size_t len) {
1521 int result, _errno;
1522 Debug2("gethostname(%p, "F_Zu")", name, len);
1523 result = gethostname(name, len);
1524 _errno = errno;
1525 Debug2("gethostname(\"%s\", ) -> %d", name, result);
1526 errno = _errno;
1527 return result;
1528 }
1529  
1530 /* due to Linux docu, it does not set errno */
1531 int Atexit(void (*func)(void)) {
1532 int result;
1533 Debug1("atexit(%p)", func);
1534 result = atexit(func);
1535 Debug1("atexit() -> %d", result);
1536 return result;
1537 }
1538  
1539  
1540 void Exit(int status) {
1541 diag_flush();
1542 Debug1("exit(%d)", status);
1543 exit(status);
1544 }
1545  
1546 void Abort(void) {
1547 Debug("abort()");
1548 abort();
1549 }
1550  
1551 int Pthread_create(pthread_t *thread, const pthread_attr_t *attr,
1552 void *(*start_routine)(void *), void *arg) {
1553 int result, _errno;
1554 Debug4("pthread_create(%p, %p, %p, %p)", thread, attr, start_routine, arg);
1555 result = pthread_create(thread, attr, start_routine, arg);
1556 _errno = errno;
1557 Debug1("pthread_create() -> %d", errno);
1558 errno = _errno;
1559 return result;
1560 }
1561  
1562 int Pthread_join(pthread_t thread, void **value_ptr) {
1563 int result, _errno;
1564 Debug2("pthread_join(%p, %p)", thread, value_ptr);
1565 result = pthread_join(thread, value_ptr);
1566 _errno = errno;
1567 Debug1("pthread_join() -> %d", errno);
1568 errno = _errno;
1569 return result;
1570 }
1571  
1572 int Mkstemp(char *template) {
1573 int result, _errno;
1574 Debug1("mkstemp(\"%s\")", template);
1575 result = mkstemp(template);
1576 _errno = errno;
1577 Info2("mkstemp({%s}) -> %d", template, result);
1578 errno = _errno;
1579 return result;
1580 }
1581  
1582 int Setenv(const char *name, const char *value, int overwrite) {
1583 int result, _errno;
1584 Debug3("setenv(\"%s\", \"%s\", %d)", name, value, overwrite);
1585 result = setenv(name, value, overwrite);
1586 _errno = errno;
1587 Debug1("setenv() -> %d", result);
1588 errno = _errno;
1589 return result;
1590 }
1591  
1592 #if HAVE_UNSETENV
1593 /* on Linux it returns int but on FreeBSD void.
1594 we do not expect many errors, so we take void which works on all systems. */
1595 void Unsetenv(const char *name) {
1596 int _errno;
1597 Debug1("unsetenv(\"%s\")", name);
1598 unsetenv(name);
1599 _errno = errno;
1600 Debug("unsetenv() ->");
1601 errno = _errno;
1602 return;
1603 }
1604 #endif
1605  
1606 #if WITH_READLINE
1607  
1608 char *Readline(const char *prompt) {
1609 char *result;
1610  
1611 if (prompt) {
1612 Debug1("readline(\"%s\")", prompt);
1613 } else {
1614 Debug("readline(NULL)");
1615 }
1616 result = readline(prompt);
1617 if (result) {
1618 Debug("readline() -> \"...\"");
1619 } else {
1620 Debug("readline() -> NULL");
1621 }
1622 return result;
1623 }
1624  
1625 void Using_history(void) {
1626 Debug("using_history()");
1627 using_history();
1628 Debug("using_history() ->");
1629 }
1630  
1631 int Read_history(const char *filename) {
1632 int result;
1633  
1634 if (filename) {
1635 Debug1("read_history(\"%s\")", filename);
1636 } else {
1637 Debug("read_history(NULL)");
1638 }
1639 result = read_history(filename);
1640 if (result) {
1641 Debug1("read_history() -> %d", result);
1642 } else {
1643 Debug("read_history() -> 0");
1644 }
1645 return result;
1646 }
1647  
1648 int Write_history(const char *filename) {
1649 int result;
1650  
1651 if (filename) {
1652 Debug1("write_history(\"%s\")", filename);
1653 } else {
1654 Debug("write_history(NULL)");
1655 }
1656 result = write_history(filename);
1657 if (result) {
1658 Debug1("write_history() -> %d", result);
1659 } else {
1660 Debug("write_history() -> 0");
1661 }
1662 return result;
1663 }
1664  
1665 int Append_history(int nelements, const char *filename) {
1666 int result;
1667  
1668 if (filename) {
1669 Debug2("append_history(%d, \"%s\")", nelements, filename);
1670 } else {
1671 Debug1("append_history(%d, NULL)", nelements);
1672 }
1673 result = append_history(nelements, filename);
1674 if (result) {
1675 Debug1("append_history() -> %d", result);
1676 } else {
1677 Debug("append_history() -> 0");
1678 }
1679 return result;
1680 }
1681  
1682 int Where_history(void) {
1683 int result;
1684  
1685 Debug("where_history()");
1686 result = where_history();
1687 Debug1("where_history() -> %d", result);
1688 return result;
1689 }
1690  
1691 void Add_history(const char *string) {
1692 Debug1("add_history(\"%s\")", string);
1693 add_history(string);
1694 Debug("add_history() ->");
1695 }
1696  
1697 #endif /* WITH_READLINE */
1698  
1699 #if WITH_GZIP
1700  
1701 gzFile Gzdopen(int fd, const char *mode) {
1702 gzFile result;
1703 Debug2("gzdopen(%d, \"%s\")", fd, mode);
1704 result = gzdopen(fd, mode);
1705 Debug1("gzdopen() -> %p", result);
1706 return result;
1707 }
1708  
1709 int Gzread(gzFile file, voidp buf, unsigned len) {
1710 int result;
1711 Debug3("gzread(%p, %p, %u)", file, buf, len);
1712 result = gzread(file, buf, len);
1713 Debug1("gzread() -> %d", result);
1714 return result;
1715 }
1716  
1717 int Gzwrite(gzFile file, const voidp buf, unsigned len) {
1718 int result;
1719 Debug3("gzwrite(%p, %p, %u)", file, buf, len);
1720 result = gzwrite(file, buf, len);
1721 Debug1("gzwrite() -> %d", result);
1722 return result;
1723 }
1724  
1725 int Gzclose(gzFile file) {
1726 int result;
1727 Debug1("gzclose(%p)", file);
1728 result = gzclose(file);
1729 Debug1("gzclose() -> %d", result);
1730 return result;
1731 }
1732  
1733 #endif /* WITH_GZIP */
1734  
1735 #endif /* WITH_SYCLS */