GET_REAL_FUNC(FUNCNAME, LIBNAME); \
bfiltering = false; \
PRE_PROBEBLOCK()
+
// ==================================================================
-// Additional macro for READ_START and WRITE_START
+// macro for filesize
// ==================================================================
#define DEFINE_FILESIZE_FD(fd) _fd = (fd); _filesize = get_fd_filesize(_fd);
#define DEFINE_FILESIZE_FP(fp) _fd = checked_fileno(fp); _filesize = get_fd_filesize(_fd);
#define DEFINE_FILESIZE_0() _fd = _filesize = 0;
-#define AFTER_PACK_ORIGINAL(API_ID, RVAL, SIZE, ERRNO, FD, FILESIZE, APITYPE, INPUTFORMAT, ...) \
- POST_PACK_PROBEBLOCK_BEGIN(); \
- PREPARE_LOCAL_BUF(); \
- PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL,ERRNO, blockresult); \
- PACK_RESOURCE(SIZE, FD, APITYPE, FILESIZE, _filepath); \
- FLUSH_LOCAL_BUF(); \
- POST_PACK_PROBEBLOCK_END();
-
-#define FILE_API_START_BLOCK(API_ID, APITYPE, INPUTFORMAT, ...) \
- AFTER_PACK_ORIGINAL(API_ID, 0, 0, 0, _fd, _filesize, APITYPE, INPUTFORMAT, __VA_ARGS__)
-
-#define FILE_API_END_BLOCK(API_ID, RVAL, SIZE, APITYPE, INPUTFORMAT,...) \
- blockresult = 0; bfiltering = 1; \
- PRE_PROBEBLOCK(); \
- AFTER_PACK_ORIGINAL(API_ID,RVAL, SIZE, newerrno, _fd, _filesize, APITYPE, INPUTFORMAT, __VA_ARGS__)
-
// ==================================================================
// AFTER_ORIGINAL macro for file
// ==================================================================
POST_PACK_PROBEBLOCK_END()
+// ==================================================================
+// START_END macro for file
+// ==================================================================
+
+#define BEFORE_ORIGINAL_START_END_FD(API_ID, FUNCNAME, LIBNAME, FD, APITYPE, INPUTFORMAT, ...) \
+ DECLARE_VARIABLE_FD; \
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \
+ PRE_PROBEBLOCK_BEGIN(); \
+ _fstatret = fstat(FD, &_statbuf); \
+ DEFINE_FILESIZE_FD(fd); \
+ PREPARE_LOCAL_BUF(); \
+ PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
+ PACK_COMMON_END(0, 0, blockresult); \
+ PACK_RESOURCE(0, FD, APITYPE, _filesize, _filepath); \
+ FLUSH_LOCAL_BUF(); \
+ PRE_PROBEBLOCK_END()
+
+#define BEFORE_ORIGINAL_START_END_NOFD(API_ID, FUNCNAME, LIBNAME, APITYPE, INPUTFORMAT, ...) \
+ DECLARE_VARIABLE_FD; \
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \
+ PRE_PROBEBLOCK_BEGIN(); \
+ DEFINE_FILESIZE_0(); \
+ PREPARE_LOCAL_BUF(); \
+ PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
+ PACK_COMMON_END(0, 0, blockresult); \
+ POST_PACK_PROBEBLOCK_MIDDLE_NOFD(0, APITYPE); \
+ PRE_PROBEBLOCK_END()
+
+#define BEFORE_ORIGINAL_START_END_FILEP(API_ID, FUNCNAME, LIBNAME, FILEP, APITYPE, INPUTFORMAT, ...) \
+ DECLARE_VARIABLE_FD; \
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \
+ PRE_PROBEBLOCK_BEGIN(); \
+ GET_FD_FROM_FILEP(FILEP); \
+ if(_fd != -1) { \
+ _fstatret = fstat(_fd, &_statbuf); \
+ } \
+ PREPARE_LOCAL_BUF(); \
+ PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
+ PACK_COMMON_END(0, 0, blockresult); \
+ POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, APITYPE); \
+ PRE_PROBEBLOCK_END()
+
+#define AFTER_ORIGINAL_START_END_FD(API_ID, RVAL, SIZE, FD, APITYPE, INPUTFORMAT, ...) \
+ POST_PACK_PROBEBLOCK_BEGIN(); \
+ setProbePoint(&probeInfo); \
+ _fstatret = fstat(FD, &_statbuf); \
+ PREPARE_LOCAL_BUF(); \
+ PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
+ PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ PACK_RESOURCE(SIZE, FD, APITYPE, _filesize, _filepath); \
+ FLUSH_LOCAL_BUF(); \
+ POST_PACK_PROBEBLOCK_END()
+
+#define AFTER_ORIGINAL_START_END_NOFD(API_ID, RVAL, SIZE, APITYPE, INPUTFORMAT, ...) \
+ POST_PACK_PROBEBLOCK_BEGIN(); \
+ setProbePoint(&probeInfo); \
+ PREPARE_LOCAL_BUF(); \
+ PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
+ PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ POST_PACK_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE); \
+ POST_PACK_PROBEBLOCK_END()
+
+#define AFTER_ORIGINAL_START_END_FILEP(API_ID, RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \
+ POST_PACK_PROBEBLOCK_BEGIN(); \
+ setProbePoint(&probeInfo); \
+ GET_FD_FROM_FILEP(FILEP); \
+ if(_fd != -1) { \
+ _fstatret = fstat(_fd, &_statbuf); \
+ } \
+ PREPARE_LOCAL_BUF(); \
+ PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
+ PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, _fd, APITYPE); \
+ POST_PACK_PROBEBLOCK_END()
+
static inline ssize_t get_fd_filesize(int fd)
{
int fchown(int fd, uid_t owner, gid_t group)
{
- static int (*fchownp)(int fd, uid_t owner, gid_t group);
+ static int (*fchownp)(int fd, uid_t owner, gid_t group);
- BEFORE_ORIGINAL_FILE(fchown, LIBC);
- ret = fchownp(fd, owner, group);
- AFTER_PACK_ORIGINAL_FD(API_ID_fchown, ret, 0, fd, FD_API_PERMISSION,
- "ddd", fd, owner, group);
- return ret;
+ BEFORE_ORIGINAL_FILE(fchown, LIBC);
+ ret = fchownp(fd, owner, group);
+ AFTER_PACK_ORIGINAL_FD(API_ID_fchown, ret, 0, fd, FD_API_PERMISSION,
+ "ddd", fd, owner, group);
+ return ret;
}
static ssize_t (*preadp)(int fd, void *buf, size_t nbyte, off_t offset);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(pread, LIBC);
- DEFINE_FILESIZE_FD(fd);
- FILE_API_START_BLOCK(API_ID_pread,FD_API_READ_START,
- "dpxx", fd, buf, nbyte, offset);
+ BEFORE_ORIGINAL_START_END_FD(API_ID_pread, pread, LIBC, fd,
+ FD_API_READ_START, "dpxx", fd, buf, nbyte, offset);
+
sret = preadp(fd, buf, nbyte, offset);
- FILE_API_END_BLOCK(API_ID_pread, sret, (unsigned int)sret,
+
+ AFTER_ORIGINAL_START_END_FD(API_ID_pread, sret, (unsigned int)sret, fd,
FD_API_READ_END, "dpxx", fd, buf, nbyte, offset);
return sret;
static ssize_t (*readp)(int fildes, void *buf, size_t nbyte);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(read, LIBC);
- DEFINE_FILESIZE_FD(fd);
- FILE_API_START_BLOCK(API_ID_read, FD_API_READ_START,
- "dpx", fd, buf, nbyte);
+ BEFORE_ORIGINAL_START_END_FD(API_ID_read, read, LIBC, fd, FD_API_READ_START,
+ "dpx", fd, buf, nbyte);
sret = readp(fd, buf, nbyte);
- FILE_API_END_BLOCK(API_ID_read, sret, (unsigned int)sret,
+ AFTER_ORIGINAL_START_END_FD(API_ID_read, sret, (unsigned int)sret, fd,
FD_API_READ_END, "dpx", fd, buf, nbyte);
return sret;
static ssize_t (*pwritep)(int fd, const void *buf, size_t nbyte, off_t offset);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(pwrite, LIBC);
- DEFINE_FILESIZE_FD(fd);
- FILE_API_START_BLOCK(API_ID_pwrite, FD_API_WRITE_START,
+ BEFORE_ORIGINAL_START_END_FD(API_ID_pwrite, pwrite, LIBC, fd, FD_API_WRITE_START,
"dpxx", fd, buf, nbyte, offset);
sret = pwritep(fd, buf, nbyte, offset);
- FILE_API_END_BLOCK(API_ID_pwrite, sret, (unsigned int)sret,
- FD_API_WRITE_END, "dpxx", fd, buf, nbyte, offset);
+ DEFINE_FILESIZE_FD(fd);
+ AFTER_ORIGINAL_START_END_FD(API_ID_pwrite, sret, (unsigned int)sret, fd,
+ FD_API_WRITE_END, "dpxx", fd, buf, nbyte, offset);
return sret;
}
static ssize_t (*writep)(int fildes, const void *buf, size_t nbyte);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(write, LIBC);
- DEFINE_FILESIZE_FD(fd);
- FILE_API_START_BLOCK(API_ID_write, FD_API_WRITE_START,
- "dpx", fd, buf, nbyte);
+ BEFORE_ORIGINAL_START_END_FD(API_ID_write, write, LIBC, fd, FD_API_WRITE_START,
+ "dpx", fd, buf, nbyte);
+
sret = writep(fd, buf, nbyte);
- FILE_API_END_BLOCK(API_ID_write, sret, (unsigned int)sret,
+ DEFINE_FILESIZE_FD(fd);
+ AFTER_ORIGINAL_START_END_FD(API_ID_write, sret, (unsigned int)sret, fd,
FD_API_WRITE_END, "dpx", fd, buf, nbyte);
return sret;
static ssize_t (*readvp)(int fd, const struct iovec *iov, int iovcnt);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(readv, LIBC);
- DEFINE_FILESIZE_FD(fd);
- FILE_API_START_BLOCK(API_ID_readv, FD_API_READ_START,
+ BEFORE_ORIGINAL_START_END_FD(API_ID_readv, readv, LIBC, fd, FD_API_READ_START,
"dpd", fd, iov, iovcnt);
+
sret = readvp(fd,iov,iovcnt);
- FILE_API_END_BLOCK(API_ID_readv, sret, (unsigned int)sret,
+ AFTER_ORIGINAL_START_END_FD(API_ID_readv, sret, (unsigned int)sret, fd,
FD_API_READ_END, "dpd", fd, iov, iovcnt);
return sret;
{
static int (*vfprintfp)(FILE* stream, const char* format, va_list arg);
- BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_vfprintf, FD_API_WRITE_START,
- "ps", stream, format);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfprintf, vfprintf, LIBC, stream,
+ FD_API_WRITE_START, "ps", stream, format);
+
ret = vfprintfp(stream, format, arg);
- FILE_API_END_BLOCK(API_ID_vfprintf, ret, ret,
+
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_vfprintf, ret, ret, stream,
FD_API_WRITE_END, "ps", stream, format);
+
return ret;
}
{
static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
- BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_vfscanf, FD_API_READ_START,
- "ps", stream, format);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfscanf, vfscanf, LIBC, stream,
+ FD_API_READ_START, "ps", stream, format);
+
ret = vfscanfp(stream, format, arg);
- FILE_API_END_BLOCK(API_ID_vfscanf, ret, ret,
+
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_vfscanf, ret, ret, stream,
FD_API_READ_END, "ps", stream, format);
+
return ret;
}
{
static int (*fgetcp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(fgetc, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_fgetc, FD_API_READ_START,
- "p", stream);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgetc, fgetc, LIBC, stream,
+ FD_API_READ_START, "p", stream);
+
ret = fgetcp(stream);
- FILE_API_END_BLOCK(API_ID_fgetc, ret, (ret != EOF),
+
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fgetc, ret, (ret != EOF), stream,
FD_API_READ_END, "p", stream);
+
return ret;
}
static char* (*fgetsp)(char* str, int num, FILE* stream);
char* cret;
- BEFORE_ORIGINAL_FILE(fgets, LIBC);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgets, FD_API_READ_START,
+ fgets, LIBC, stream, "sdp", str, size, stream);
- FILE_API_START_BLOCK(API_ID_fgets, FD_API_READ_START, "sdp", str, size, stream);
-
cret = fgetsp(str, size, stream);
- FILE_API_END_BLOCK(API_ID_fgets, cret, (ret == NULL ? 0 : strlen(cret)),
- FD_API_READ_END, "sdp", str, size, stream);
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fgets, cret, (ret == NULL ? 0 : strlen(cret)),
+ stream, FD_API_READ_END, "sdp", str, size, stream);
return cret;
}
{
static int (*fputcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_FILE(fputc, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_fputc, FD_API_WRITE_START,
- "dp", character, stream);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputc, fputc, LIBC, stream,
+ FD_API_WRITE_START, "dp", character, stream);
+
ret = fputcp(character, stream);
- FILE_API_END_BLOCK(API_ID_fputc, ret, (ret != EOF),
+
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fputc, ret, (ret == EOF ? 0 : 1), stream,
FD_API_WRITE_END, "dp", character, stream);
+
return ret;
}
{
static int (*fputsp)(const char* str, FILE* stream);
- BEFORE_ORIGINAL_FILE(fputs, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_fputs, FD_API_WRITE_START,
- "sp", str, stream);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputs, fputs, LIBC, stream,
+ FD_API_WRITE_START, "sp", str, stream);
+
ret = fputsp(str, stream);
- FILE_API_END_BLOCK(API_ID_fputs, ret, ret, FD_API_WRITE_END,
- "sp", str, stream);
+
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fputs, ret, ret, stream,
+ FD_API_WRITE_END, "sp", str, stream);
+
return ret;
}
{
static int (*getcp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(getc, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_getc, FD_API_READ_START,
- "p", stream);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_getc, getc, LIBC, stream,
+ FD_API_READ_START, "p", stream);
+
ret = getcp(stream);
- FILE_API_END_BLOCK(API_ID_getc, ret, (ret != EOF),
+
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_getc, ret, (ret == EOF ? 0 : 1), stream,
FD_API_READ_END, "p", stream);
+
return ret;
}
{
static int (*putcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_FILE(putc, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_putc, FD_API_WRITE_START,
- "dp", character, stream);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, putc, LIBC, stream,
+ FD_API_WRITE_START, "dp", character, stream);
+
ret = putcp(character, stream);
- FILE_API_END_BLOCK(API_ID_putc, ret, (ret != EOF),
+
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_putc, ret, (ret == EOF ? 0 : 1), stream,
FD_API_WRITE_END, "dp", character, stream);
+
return ret;
}
{
static int (*ungetcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_FILE(ungetc, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_putc, FD_API_WRITE_START,
- "dp", character, stream);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, ungetc, LIBC, stream,
+ FD_API_WRITE_START, "dp", character, stream);
+
ret = ungetcp(character, stream);
- FILE_API_END_BLOCK(API_ID_ungetc, ret, 0,
+
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_ungetc, ret, 0, stream,
FD_API_OTHER, "dp", character, stream);
+
return ret;
}
static size_t (*freadp)(void* ptr, size_t size, size_t count, FILE* stream);
size_t tret;
- BEFORE_ORIGINAL_FILE(fread, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_fread, FD_API_READ_START,
- "pxxp", ptr, size, count, stream);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fread, fread, LIBC, stream,
+ FD_API_READ_START, "pxxp", ptr, size, count, stream);
tret = freadp(ptr, size, count, stream);
- FILE_API_END_BLOCK(API_ID_fread, tret, tret*size, FD_API_READ_END,
- "pxxp", ptr, size, count, stream);
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fread, tret, tret*size, stream,
+ FD_API_READ_END, "pxxp", ptr, size, count, stream);
return tret;
}
static size_t (*fwritep)(const void* ptr, size_t size, size_t count, FILE* stream);
size_t tret;
- BEFORE_ORIGINAL_FILE(fwrite, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_fwrite, FD_API_WRITE_START,
- "pxxp", ptr, size, count, stream);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fwrite, fwrite, LIBC, stream,
+ FD_API_WRITE_START, "pxxp", ptr, size, count, stream);
tret = fwritep(ptr, size, count, stream);
- FILE_API_END_BLOCK(API_ID_fwrite, tret, tret*size, FD_API_WRITE_END,
- "pxxp", ptr, size, count, stream);
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fwrite, tret, tret*size, stream,
+ FD_API_WRITE_END, "pxxp", ptr, size, count, stream);
return tret;
}
{
static int (*vfprintfp)(FILE* stream, const char* format, ...);
- BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_fprintf, FD_API_WRITE_START,
- "ps", stream, format);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fprintf, vfprintf, LIBC, stream,
+ FD_API_WRITE_START, "ps", stream, format);
va_list arg;
va_start(arg, format);
+
ret = vfprintfp(stream, format, arg);
- FILE_API_END_BLOCK(API_ID_fprintf, ret, ret, FD_API_WRITE_END,
- "ps", stream, format);
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fprintf, ret, ret, stream,
+ FD_API_WRITE_END, "ps", stream, format);
+
va_end(arg);
return ret;
{
static int (*vfscanfp)(FILE* stream, const char* format, ...);
- BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
- DEFINE_FILESIZE_FP(stream);
- FILE_API_START_BLOCK(API_ID_fscanf, FD_API_READ_START,
- "ps", stream, format);
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fscanf, vfscanf, LIBC, stream,
+ FD_API_READ_START, "ps", stream, format);
va_list arg;
va_start(arg, format);
+
ret = vfscanfp(stream, format, arg);
- FILE_API_END_BLOCK(API_ID_fscanf, ret, ret,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fscanf, ret, ret, stream,
FD_API_READ_END, "ps", stream, format);
+
va_end(arg);
return ret;
{
static int (*vprintfp)(const char* format, ...);
- BEFORE_ORIGINAL_FILE(vprintf, LIBC);
- DEFINE_FILESIZE_0();
- FILE_API_START_BLOCK(API_ID_printf, FD_API_WRITE_START,
- "s", format);
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_printf, vprintf, LIBC,
+ FD_API_WRITE_START, "s", format);
va_list arg;
va_start(arg, format);
ret = vprintfp(format, arg);
- FILE_API_END_BLOCK(API_ID_printf, ret, ret,
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_printf, ret, ret,
FD_API_WRITE_END, "s", format);
+
va_end(arg);
return ret;
{
static int (*vscanfp)(const char* format, ...);
- BEFORE_ORIGINAL_FILE(vscanf, LIBC);
- DEFINE_FILESIZE_0();
- FILE_API_START_BLOCK(API_ID_scanf, FD_API_READ_START,
- "s", format);
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_scanf, vscanf, LIBC,
+ FD_API_READ_START, "s", format);
va_list arg;
va_start(arg, format);
ret = vscanfp(format, arg);
- FILE_API_END_BLOCK(API_ID_scanf, ret, ret,
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_scanf, ret, ret,
FD_API_READ_END, "s", format);
+
va_end(arg);
return ret;
{
static int (*getcharp)();
- BEFORE_ORIGINAL_FILE(getchar, LIBC);
- DEFINE_FILESIZE_0();
- FILE_API_START_BLOCK(API_ID_getchar, FD_API_READ_START,
- "s", "");
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_getchar, getchar, LIBC,
+ FD_API_READ_START, "", 0);
+
ret = getcharp();
- FILE_API_END_BLOCK(API_ID_getchar, ret, (ret != EOF ),
+
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_getchar, ret, (ret == EOF ? 0 : 1),
FD_API_READ_END, "", 0);
+
return ret;
}
{
static int (*putcharp)(int c);
- BEFORE_ORIGINAL_FILE(putchar, LIBC);
- DEFINE_FILESIZE_0();
- FILE_API_START_BLOCK(API_ID_putchar, FD_API_WRITE_START,
- "d", c);
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_putchar, putchar, LIBC,
+ FD_API_WRITE_START, "d", c);
+
ret = putcharp(c);
- FILE_API_END_BLOCK(API_ID_putchar, ret, (ret != EOF),
+
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_putchar, ret, (ret == EOF ? 0 : 1),
FD_API_WRITE_END, "d", c);
+
return ret;
}
static char* (*getsp)(char* str);
char* cret;
- BEFORE_ORIGINAL_FILE(gets, LIBC);
- DEFINE_FILESIZE_0();
- FILE_API_START_BLOCK(API_ID_gets, FD_API_READ_START,
- "s", str);
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_gets, gets, LIBC,
+ FD_API_READ_START, "s", str);
cret = getsp(str);
- FILE_API_END_BLOCK(API_ID_gets, cret, strlen(cret),
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_gets, cret, strlen(cret),
FD_API_READ_END, "s", str);
return cret;
{
static int (*putsp)(const char* str);
- BEFORE_ORIGINAL_FILE(puts, LIBC);
- DEFINE_FILESIZE_0();
- FILE_API_START_BLOCK(API_ID_puts, FD_API_WRITE_START,
- "s", str);
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_puts, puts, LIBC,
+ FD_API_WRITE_START, "s", str);
+
ret = putsp(str);
- FILE_API_END_BLOCK(API_ID_puts, ret, ret,
+
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_puts, ret, ret,
FD_API_WRITE_END, "s", str);
+
return ret;
}
#endif
projects / platform / core / system / swap-probe.git / commitdiff