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