lorenz.stechauner/BSc-Thesis
1
0
Fork 0
Code Activity
Files
e851f5b90df68a3fc2eec8f4b8efb7e0629dcaee
BSc-Thesis/proj/intercept/src/intercept.c

2325 lines
85 KiB
C
Raw Blame History

#define _GNU_SOURCE
#include <getopt.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <time.h>
#include <stdarg.h>
#include <semaphore.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <netdb.h>
#include <arpa/inet.h>
#define BUFFER_SIZE 256
#ifdef INTERCEPT_PRELOAD
#define load(name) \
if (((__real_ ## name) = dlsym(RTLD_NEXT, #name)) == NULL) { \
fprintf(stderr, "intercept: unable to load symbol '%s': %s", #name, strerror(errno)); \
return; \
}
#define sym(name) name
#define func_def(ret, name) static ret (*__real_ ## name)
#else
#define sym(name) __wrap_ ## name
#define func_def(ret, name) extern ret __real_ ## name
#endif
func_def(void *, malloc)(size_t);
func_def(void *, calloc)(size_t, size_t);
func_def(void *, realloc)(void *, size_t);
func_def(void *, reallocarray)(void *, size_t, size_t);
func_def(void, free)(void *);
func_def(int, getopt)(int, char *const [], const char *);
func_def(void, exit)(int);
func_def(ssize_t, read)(int, void *, size_t);
func_def(ssize_t, pread)(int, void *, size_t, off_t);
func_def(ssize_t, write)(int, const void *, size_t);
func_def(ssize_t, pwrite)(int, const void *, size_t, off_t);
func_def(int, close)(int);
func_def(int, sigaction)(int, const struct sigaction *, struct sigaction *);
func_def(int, sem_init)(sem_t *, int, unsigned int);
func_def(sem_t *, sem_open)(const char *, int, ...);
func_def(int, sem_post)(sem_t *);
func_def(int, sem_wait)(sem_t *);
func_def(int, sem_trywait)(sem_t *);
func_def(int, sem_timedwait)(sem_t *restrict, const struct timespec *restrict);
func_def(int, sem_getvalue)(sem_t *restrict, int *restrict);
func_def(int, sem_close)(sem_t *);
func_def(int, sem_unlink)(const char *);
func_def(int, sem_destroy)(sem_t *);
func_def(int, shm_open)(const char *, int, mode_t);
func_def(int, shm_unlink)(const char *);
func_def(void *, mmap)(void *, size_t, int, int, int, off_t);
func_def(int, munmap)(void *, size_t);
func_def(int, ftruncate)(int, off_t);
func_def(pid_t, fork)(void);
func_def(pid_t, wait)(int *);
func_def(pid_t, waitpid)(pid_t, int *, int);
func_def(int, execl)(const char *, const char *, ...);
func_def(int, execlp)(const char *, const char *, ...);
func_def(int, execle)(const char *, const char *, ...);
func_def(int, execv)(const char *, char *const[]);
func_def(int, execvp)(const char *, char *const[]);
func_def(int, execvpe)(const char *, char *const[], char *const[]);
func_def(int, execve)(const char *, char *const[], char *const[]);
func_def(int, fexecve)(int, char *const[], char *const[]);
func_def(int, pipe)(int[2]);
func_def(int, dup)(int);
func_def(int, dup2)(int, int);
func_def(int, dup3)(int, int, int);
func_def(int, socket)(int, int, int);
func_def(int, bind)(int, const struct sockaddr *, socklen_t);
func_def(int, listen)(int, int);
func_def(int, accept)(int, struct sockaddr *, socklen_t *);
func_def(int, connect)(int, const struct sockaddr *, socklen_t);
func_def(int, getaddrinfo)(const char *, const char *, const struct addrinfo *, struct addrinfo **);
func_def(void, freeaddrinfo)(struct addrinfo *);
func_def(ssize_t, send)(int, const void *, size_t, int);
func_def(ssize_t, sendto)(int, const void *, size_t, int, const struct sockaddr *, socklen_t);
func_def(ssize_t, sendmsg)(int, const struct msghdr *, int);
func_def(ssize_t, recv)(int, void *, size_t, int);
func_def(ssize_t, recvfrom)(int, void *, size_t, int, struct sockaddr *, socklen_t *);
func_def(ssize_t, recvmsg)(int, struct msghdr *, int);
#define func_idx_malloc 0
#define func_idx_calloc 1
#define func_idx_realloc 2
#define func_idx_reallocarray 3
#define func_idx_free 4
#define func_idx_getopt 5
#define func_idx_exit 6
#define func_idx_read 7
#define func_idx_pread 8
#define func_idx_write 9
#define func_idx_pwrite 10
#define func_idx_close 11
#define func_idx_sigaction 12
#define func_idx_sem_init 13
#define func_idx_sem_open 14
#define func_idx_sem_post 15
#define func_idx_sem_wait 16
#define func_idx_sem_trywait 17
#define func_idx_sem_timedwait 18
#define func_idx_sem_getvalue 19
#define func_idx_sem_close 20
#define func_idx_sem_unlink 21
#define func_idx_sem_destroy 22
#define func_idx_shm_open 23
#define func_idx_shm_unlink 24
#define func_idx_mmap 25
#define func_idx_munmap 26
#define func_idx_ftruncate 27
#define func_idx_fork 28
#define func_idx_wait 29
#define func_idx_waitpid 30
#define func_idx_execl 31
#define func_idx_execlp 32
#define func_idx_execle 33
#define func_idx_execv 34
#define func_idx_execvp 35
#define func_idx_execvpe 36
#define func_idx_execve 37
#define func_idx_fexecve 38
#define func_idx_pipe 39
#define func_idx_dup 40
#define func_idx_dup2 41
#define func_idx_dup3 42
#define func_idx_socket 43
#define func_idx_bind 44
#define func_idx_listen 45
#define func_idx_accept 46
#define func_idx_connect 47
#define func_idx_getaddrinfo 48
#define func_idx_freeaddrinfo 49
#define func_idx_send 50
#define func_idx_sendto 51
#define func_idx_sendmsg 52
#define func_idx_recv 53
#define func_idx_recvfrom 54
#define func_idx_recvmsg 55
#define FUNCTIONS \
X(malloc) \
X(calloc) \
X(realloc) \
X(reallocarray) \
X(free) \
X(getopt) \
X(exit) \
X(read) \
X(pread) \
X(write) \
X(pwrite) \
X(close) \
X(sigaction) \
X(sem_init) \
X(sem_open) \
X(sem_post) \
X(sem_wait) \
X(sem_trywait) \
X(sem_timedwait) \
X(sem_getvalue) \
X(sem_close) \
X(sem_unlink) \
X(sem_destroy) \
X(shm_open) \
X(shm_unlink) \
X(mmap) \
X(munmap) \
X(ftruncate) \
X(fork) \
X(wait) \
X(waitpid) \
X(execl) \
X(execlp) \
X(execle) \
X(execv) \
X(execvp) \
X(execvpe) \
X(execve) \
X(fexecve) \
X(pipe) \
X(dup) \
X(dup2) \
X(dup3) \
X(socket) \
X(bind) \
X(listen) \
X(accept) \
X(connect) \
X(getaddrinfo) \
X(freeaddrinfo) \
X(send) \
X(sendto) \
X(sendmsg) \
X(recv) \
X(recvfrom) \
X(recvmsg)
#define case_const(name) case name: return #name
#define flag_str(flags, name, buf) if (flags & name) strcat(buf, #name "|")
#define ret_addr __builtin_return_address(0)
#define if_fail if (strncmp(msg_buf, "fail ", 5) == 0)
#define if_fail_int_errno(name) if_fail { set_errno(#name, msg_buf); return -1; }
#define if_fail_ptr_errno(name) if_fail { set_errno(#name, msg_buf); return NULL; }
#define if_invalid(name) if (strcmp(msg_buf, "ok") != 0) { fprintf(stderr, "intercept: %s: invalid command: '%s'\n", #name, msg_buf); }
#define if_modify_int(name, type_1, var_1) if (strncmp(msg_buf, "modify ", 7) == 0) { \
char *end_ptr = NULL; \
long val = strtol(msg_buf + 7, &end_ptr, 0); \
if (end_ptr != NULL && end_ptr[0] == 0 && end_ptr != msg_buf + 7) { \
var_1 = (type_1)val; \
} else { \
fprintf(stderr, "intercept: %s: invalid args in modify command: '%s'\n", #name, msg_buf + 7); \
} }
#define if_modify_int_int(name, type_1, var_1, type_2, var_2) if (strncmp(msg_buf, "modify ", 7) == 0) { \
char *end_ptr_1 = NULL, *end_ptr_2 = NULL; \
long val_1 = strtol(msg_buf + 7, &end_ptr_1, 0); \
long val_2 = 0; \
if (end_ptr_1 != NULL) val_2 = strtol(end_ptr_1 + 1, &end_ptr_2, 0); \
if (end_ptr_1 != NULL && end_ptr_1[0] == ',' && end_ptr_1 != msg_buf + 7 && \
end_ptr_2 != NULL && end_ptr_2[0] == 0 && end_ptr_2 != end_ptr_1 + 1) \
{ \
var_1 = (type_1)val_1; \
var_2 = (type_2)val_2; \
} else { \
fprintf(stderr, "intercept: %s: invalid args in modify command: '%s'\n", #name, msg_buf + 7); \
} }
#define if_modify_int_int_int(name, type_1, var_1, type_2, var_2, type_3, var_3) if (strncmp(msg_buf, "modify ", 7) == 0) { \
char *end_ptr_1 = NULL, *end_ptr_2 = NULL, *end_ptr_3; \
long val_1 = strtol(msg_buf + 7, &end_ptr_1, 0); \
long val_2 = 0, val_3 = 0; \
if (end_ptr_1 != NULL) val_2 = strtol(end_ptr_1 + 1, &end_ptr_2, 0); \
if (end_ptr_2 != NULL) val_3 = strtol(end_ptr_2 + 1, &end_ptr_3, 0); \
if (end_ptr_1 != NULL && end_ptr_1[0] == ',' && end_ptr_1 != msg_buf + 7 && \
end_ptr_2 != NULL && end_ptr_2[0] == ',' && end_ptr_2 != end_ptr_1 + 1 && \
end_ptr_3 != NULL && end_ptr_3[0] == 0 && end_ptr_3 != end_ptr_2 + 1) \
{ \
var_1 = (type_1)val_1; \
var_2 = (type_2)val_2; \
var_3 = (type_3)val_3; \
} else { \
fprintf(stderr, "intercept: %s: invalid args in modify command: '%s'\n", #name, msg_buf + 7); \
} }
#define if_return if (strcmp(msg_buf, "return") == 0) { msg("return"); return; }
#define if_return_int(name) if (strncmp(msg_buf, "return ", 7) == 0) { \
char *end_ptr = NULL; \
long val = strtol(msg_buf + 7, &end_ptr, 0); \
if (end_ptr != NULL && end_ptr[0] == 0 && end_ptr != msg_buf + 7) { \
msg("return %i", val); \
return val; \
} else { \
fprintf(stderr, "intercept: %s: invalid args in return command: '%s'\n", #name, msg_buf + 7); \
} }
#define if_return_int_errno(name) if (strncmp(msg_buf, "return ", 7) == 0) { \
char *end_ptr = NULL; \
long val = strtol(msg_buf + 7, &end_ptr, 0); \
if (end_ptr != NULL && end_ptr[0] == 0 && end_ptr != msg_buf + 7) { \
msg("return %i; errno %s", val, strerrorname_np(errno)); \
return val; \
} else { \
fprintf(stderr, "intercept: %s: invalid args in return command: '%s'\n", #name, msg_buf + 7); \
} }
#define if_return_int_errno_int(name, type_1, var_1, name_1) if (strncmp(msg_buf, "return ", 7) == 0) { \
char *end_ptr_1 = NULL, *end_ptr_2 = NULL; \
long val_1 = strtol(msg_buf + 7, &end_ptr_1, 0); \
long val_2 = 0; \
if (end_ptr_1 != NULL) val_2 = strtol(end_ptr_1 + 1, &end_ptr_2, 0); \
if (end_ptr_1 != NULL && end_ptr_1[0] == ',' && end_ptr_1 != msg_buf + 7 && \
end_ptr_2 != NULL && end_ptr_2[0] == 0 && end_ptr_2 != end_ptr_1 + 1) \
{ \
var_1 = (type_1)val_2; \
msg("return %i; errno %s; %s=%i", val_1, strerrorname_np(errno), name_1, var_1); \
return val_1; \
} else { \
fprintf(stderr, "intercept: %s: invalid args in return command: '%s'\n", #name, msg_buf + 7); \
} }
#define if_return_ptr_errno(name) if (strncmp(msg_buf, "return ", 7) == 0) { \
char *end_ptr = NULL; \
long val = strtol(msg_buf + 7, &end_ptr, 0); \
if (end_ptr != NULL && end_ptr[0] == 0 && end_ptr != msg_buf + 7) { \
msg("return %p; errno %s", val, strerrorname_np(errno)); \
return (void *)val; \
} else { \
fprintf(stderr, "intercept: %s: invalid args in return command: '%s'\n", #name, msg_buf + 7); \
} }
#define if_error(err) if (strcmp(msg_buf + 5, #err) == 0) { errno = err; }
static void set_errno(const char *name, const char *msg_buf) {
char *end_ptr = NULL;
long val = strtol(msg_buf + 5, &end_ptr, 0);
if (end_ptr != NULL && end_ptr[0] == 0 && end_ptr != msg_buf + 5) {
errno = (int)val;
} else if_error(EPERM)
else if_error(ENOENT)
else if_error(ESRCH)
else if_error(EINTR)
else if_error(EIO)
else if_error(ENXIO)
else if_error(E2BIG)
else if_error(ENOEXEC)
else if_error(EBADF)
else if_error(ECHILD)
else if_error(EAGAIN)
else if_error(ENOMEM)
else if_error(EACCES)
else if_error(EFAULT)
else if_error(ENOTBLK)
else if_error(EBUSY)
else if_error(EEXIST)
else if_error(EXDEV)
else if_error(ENODEV)
else if_error(ENOTDIR)
else if_error(EISDIR)
else if_error(EINVAL)
else if_error(ENFILE)
else if_error(EMFILE)
else if_error(ENOTTY)
else if_error(ETXTBSY)
else if_error(EFBIG)
else if_error(ENOSPC)
else if_error(ESPIPE)
else if_error(EROFS)
else if_error(EMLINK)
else if_error(EPIPE)
else if_error(EDOM)
else if_error(ERANGE)
else if_error(EDEADLK)
else if_error(ENAMETOOLONG)
else if_error(ENOLCK)
else if_error(ENOSYS)
else if_error(ENOTEMPTY)
else if_error(ELOOP)
else if_error(EWOULDBLOCK)
else if_error(ENOMSG)
else if_error(EIDRM)
else if_error(ECHRNG)
else if_error(EL2NSYNC)
else if_error(EL3HLT)
else if_error(EL3RST)
else if_error(ELNRNG)
else if_error(EUNATCH)
else if_error(ENOCSI)
else if_error(EL2HLT)
else if_error(EBADE)
else if_error(EBADR)
else if_error(EXFULL)
else if_error(ENOANO)
else if_error(EBADRQC)
else if_error(EBADSLT)
else if_error(EDEADLOCK)
else if_error(EBFONT)
else if_error(ENOSTR)
else if_error(ENODATA)
else if_error(ETIME)
else if_error(ENOSR)
else if_error(ENONET)
else if_error(ENOPKG)
else if_error(EREMOTE)
else if_error(ENOLINK)
else if_error(EADV)
else if_error(ESRMNT)
else if_error(ECOMM)
else if_error(EPROTO)
else if_error(EMULTIHOP)
else if_error(EDOTDOT)
else if_error(EBADMSG)
else if_error(EOVERFLOW)
else if_error(ENOTUNIQ)
else if_error(EBADFD)
else if_error(EREMCHG)
else if_error(ELIBACC)
else if_error(ELIBBAD)
else if_error(ELIBSCN)
else if_error(ELIBMAX)
else if_error(ELIBEXEC)
else if_error(EILSEQ)
else if_error(ERESTART)
else if_error(ESTRPIPE)
else if_error(EUSERS)
else if_error(ENOTSOCK)
else if_error(EDESTADDRREQ)
else if_error(EMSGSIZE)
else if_error(EPROTOTYPE)
else if_error(ENOPROTOOPT)
else if_error(EPROTONOSUPPORT)
else if_error(ESOCKTNOSUPPORT)
else if_error(EOPNOTSUPP)
else if_error(EPFNOSUPPORT)
else if_error(EAFNOSUPPORT)
else if_error(EADDRINUSE)
else if_error(EADDRNOTAVAIL)
else if_error(ENETDOWN)
else if_error(ENETRESET)
else if_error(ECONNABORTED)
else if_error(ECONNRESET)
else if_error(ENOBUFS)
else if_error(EISCONN)
else if_error(ENOTCONN)
else if_error(ESHUTDOWN)
else if_error(ETOOMANYREFS)
else if_error(ETIMEDOUT)
else if_error(ECONNREFUSED)
else if_error(EHOSTDOWN)
else if_error(EHOSTUNREACH)
else if_error(EALREADY)
else if_error(EINPROGRESS)
else if_error(ESTALE)
else if_error(EUCLEAN)
else if_error(ENOTNAM)
else if_error(ENAVAIL)
else if_error(EISNAM)
else if_error(EREMOTEIO)
else if_error(EDQUOT)
else if_error(ENOMEDIUM)
else if_error(EMEDIUMTYPE)
else if_error(ECANCELED)
else if_error(ENOKEY)
else if_error(EKEYEXPIRED)
else if_error(EKEYREVOKED)
else if_error(EKEYREJECTED)
else if_error(EOWNERDEAD)
else if_error(ENOTRECOVERABLE)
else if_error(ERFKILL)
else if_error(EHWPOISON)
else {
errno = 0;
fprintf(stderr, "intercept: %s: invalid error code in fail command: '%s'\n", name, msg_buf + 5);
}
}
static const char *getdomainstr(int domain) {
switch (domain) {
case_const(AF_UNSPEC);
case_const(AF_UNIX);
case_const(AF_INET);
case_const(AF_INET6);
default: return "?";
}
}
static const char *getsocktype(int type) {
switch (type) {
case_const(SOCK_STREAM);
case_const(SOCK_DGRAM);
case_const(SOCK_RAW);
case_const(SOCK_RDM);
case_const(SOCK_SEQPACKET);
case_const(SOCK_DCCP);
case_const(SOCK_PACKET);
default: return "?";
}
}
static char *strtostr(char *ptr, char **end_ptr, char *buf) {
if (ptr[0] != '"') return NULL;
int i = 0, esc = 0, hex = 0;
for (*end_ptr = ptr + 1; *end_ptr[0] != 0; (*end_ptr)++) {
char ch = *end_ptr[0];
if (esc) {
if (esc == 2) {
if (ch >= '0' && ch <= '9') {
hex = (ch - '0') << 4;
} else if (ch >= 'A' && ch <= 'F') {
hex = (ch - 'A' + 10) << 4;
} else if (ch >= 'a' && ch <= 'f') {
hex = (ch - 'a' + 10) << 4;
} else {
return NULL;
}
esc = 3;
continue;
} else if (esc == 3) {
if (ch >= '0' && ch <= '9') {
hex |= (ch - '0');
} else if (ch >= 'A' && ch <= 'F') {
hex |= (ch - 'A' + 10);
} else if (ch >= 'a' && ch <= 'f') {
hex |= (ch - 'a' + 10);
} else {
return NULL;
}
buf[i++] = (char)hex;
esc = 0;
continue;
}
switch (ch) {
case 'a': ch = '\a'; break;
case 'b': ch = '\b'; break;
case 't': ch = '\t'; break;
case 'n': ch = '\n'; break;
case 'v': ch = '\v'; break;
case 'f': ch = '\f'; break;
case 'r': ch = '\r'; break;
case '0': ch = 0; break;
case 'x': esc = 2; continue;
case '"':
case '\\':
break;
default: return NULL;
}
buf[i++] = ch;
esc = 0;
} else if (ch == '\\') {
esc = 1;
} else if (ch == '"') {
(*end_ptr)++;
return buf;
} else {
buf[i++] = ch;
}
}
return NULL;
}
static int mode = 0;
static int intercept = 0;
static uint8_t func_flags[256];
static size_t msg_bytes(char *buf, size_t maxlen, size_t len, const char *str, int flags) {
size_t offset = flags & 1 ? snprintf(buf, maxlen, "\"") : snprintf(buf, maxlen, "%p:\"", str);
for (int i = 0; i < len && offset <= maxlen - 2; i++) {
char ch = str[i];
if (ch == '\\' || ch == '"') {
buf[offset++] = '\\';
buf[offset++] = ch;
} else if (ch == '\t') {
buf[offset++] = '\\';
buf[offset++] = 't';
} else if (ch == '\n') {
buf[offset++] = '\\';
buf[offset++] = 'n';
} else if (ch == '\r') {
buf[offset++] = '\\';
buf[offset++] = 'r';
} else if ((ch >= 0 && ch < 0x20) || ch == 0x7F) {
offset += snprintf(buf + offset, maxlen - offset, "\\x%02x", ch);
} else {
buf[offset++] = ch;
}
}
if (offset <= maxlen - 2) {
buf[offset++] = '"';
buf[offset] = 0;
}
return offset;
}
static size_t msg_str(char *buf, size_t maxlen, const char *str, int flags) {
return msg_bytes(buf, maxlen, strlen(str), str, flags);
}
static size_t msg_array_str(char *buf, size_t maxlen, char *const array[], int n) {
size_t offset = snprintf(buf, maxlen, "%p:[", (void *)array);
for (int i = 0; i < n && offset <= maxlen - 2; i++) {
if (i > 0) {
buf[offset++] = ',';
buf[offset++] = ' ';
}
offset += msg_str(buf + offset, maxlen - offset, array[i], 0);
}
if (offset <= maxlen - 2) {
buf[offset++] = ']';
buf[offset] = 0;
}
return offset;
}
static void msg(const char *fmt, ...) {
if (!intercept || mode == -1) return;
char buf[8192], sub_fmt[16];
int sub_fmt_p = 0;
va_list args;
va_start(args, fmt);
struct timespec spec;
clock_gettime(CLOCK_REALTIME, &spec);
size_t offset = snprintf(buf, sizeof(buf), "%li.%09li %i ", spec.tv_sec, spec.tv_nsec, getpid());
for (char ch, state = 0; (ch = *fmt) != 0 && offset < sizeof(buf); fmt++) {
if (state == '%') {
if (ch == '%') {
buf[offset++] = ch;
state = 0;
continue;
} else if (ch == 'e') {
state = 'e';
continue;
} else if (ch == 'q') {
state = 'q';
continue;
} else if (ch == 'a') {
state = 'a';
continue;
} else {
sub_fmt_p = 0;
state = '_';
sub_fmt[sub_fmt_p++] = '%';
sub_fmt[sub_fmt_p] = 0;
}
}
if (state == '_') {
sub_fmt[sub_fmt_p++] = ch;
sub_fmt[sub_fmt_p] = 0;
if (ch == 's' || ch == 'i' || ch == 'd' || ch == 'o' || ch == 'u' || ch == 'x' || ch == 'X' || ch == 'f' || ch == 'p') {
state = 0;
offset += snprintf(buf + offset, sizeof(buf) - offset, sub_fmt, va_arg(args, long int));
}
} else if (state == 'e') {
if (ch == 's') {
// escaped string
offset += msg_str(buf + offset, sizeof(buf) - offset, va_arg(args, const char *), 0);
} else if (ch == 'b') {
// escaped byte sequence
const int len = va_arg(args, int);
offset += msg_bytes(buf + offset, sizeof(buf) - offset, len, va_arg(args, const char *), 0);
}
state = 0;
} else if (state == 'q') {
if (ch == 'a') {
// address, struct sockaddr
const int len = va_arg(args, int);
const struct sockaddr *addr = va_arg(args, struct sockaddr *);
if (addr->sa_family == AF_UNIX) {
// 0x0:{sa_family: 1:AF_UNIX, sun_path: "/path/"}
const struct sockaddr_un *un = (const struct sockaddr_un *)addr;
offset += snprintf(buf + offset, sizeof(buf) - offset, "%p:{sa_family: %i:AF_UNIX, sun_Path: ", (void *)un, AF_UNIX);
offset += msg_str(buf + offset, sizeof(buf) - offset, un->sun_path, 1);
offset += snprintf(buf + offset, sizeof(buf) - offset, "}");
} else if (addr->sa_family == AF_INET && len == sizeof(struct sockaddr_in)) {
// 0x0:{sa_family: 2:AF_INET, sin_addr: "192.168.0.1", sin_port: 80}
const struct sockaddr_in *in = (const struct sockaddr_in *)addr;
char addr_buf[INET_ADDRSTRLEN];
offset += snprintf(buf + offset, sizeof(buf) - offset, "%p:{sa_family: %i:AF_INET, sin_addr: \"%s\", sin_port: %i}", (void *)in, AF_INET, inet_ntop(AF_INET, &in->sin_addr, addr_buf, sizeof(addr_buf)), ntohs(in->sin_port));
} else if (addr->sa_family == AF_INET6 && len == sizeof(struct sockaddr_in6)) {
// 0x0:{sa_family: 10:AF_INET6, sin6_addr: "::1", sin6_port: 80, sin6_scope_id: 0}
const struct sockaddr_in6 *in6 = (const struct sockaddr_in6 *)addr;
char addr_buf[INET6_ADDRSTRLEN];
offset += snprintf(buf + offset, sizeof(buf) - offset, "%p:{sa_family: %i:AF_INET6, sin6_addr: \"%s\", sin6_port: %i, sin6_scope_id: %i}", (void *)in6, AF_INET6, inet_ntop(AF_INET6, &in6->sin6_addr, addr_buf, sizeof(addr_buf)), ntohs(in6->sin6_port), in6->sin6_scope_id);
} else {
// 0x0:{sa_family: 7:?, sa_data: "\x01\x02\x03\x04"}
offset += snprintf(buf + offset, sizeof(buf) - offset, "%p:{sa_family: %i:%s, sa_data: ", (void *)addr, addr->sa_family, getdomainstr(addr->sa_family));
offset += msg_bytes(buf + offset, sizeof(buf) - offset, len - sizeof(addr->sa_family), addr->sa_data, 1);
offset += snprintf(buf + offset, sizeof(buf) - offset, "}");
}
} else if (ch == 'm') {
// struct msghdr
// TODO format struct msghdr
const struct msghdr *msg = va_arg(args, struct msghdr *);
offset += snprintf(buf + offset, sizeof(buf) - offset, "%p:{}", (void *)msg);
} else if (ch == 't') {
// struct timespec
const struct timespec *tv = va_arg(args, struct timespec *);
offset += snprintf(buf + offset, sizeof(buf) - offset, "%p:{tv_sec: %li, tv_nsec: %li}", (void *)tv, tv->tv_sec, tv->tv_nsec);
} else if (ch == 'i') {
// struct addrinfo
// TODO format struct addrinfo
const struct addrinfo *ai = va_arg(args, struct addrinfo *);
offset += snprintf(buf + offset, sizeof(buf) - offset, "%p:{}", (void *)ai);
} else {
// error
va_end(args);
return;
}
state = 0;
} else if (state == 'a') {
if (ch == 's') {
// string array
const int len = va_arg(args, int);
char *const *array = va_arg(args, char *const *);
offset += msg_array_str(buf + offset, sizeof(buf) - offset, array, len);
} else {
// error
va_end(args);
return;
}
state = 0;
} else if (ch == '%') {
state = '%';
} else {
buf[offset++] = ch;
}
}
if (offset <= sizeof(buf) - 2) {
buf[offset++] = '\n';
buf[offset] = 0;
}
const size_t size = offset >= sizeof(buf) ? sizeof(buf) - 1 : offset;
ssize_t ret;
for (size_t written = 0; written < size; written += ret) {
if ((ret = __real_write(intercept, buf, size)) == -1) {
if (errno == EINTR) {
ret = 0;
continue;
}
va_end(args);
return;
}
}
va_end(args);
}
static void rcv(char *buf, const int size) {
if (!intercept) return;
size_t num = 0;
for (ssize_t ret; num == 0 || buf[num - 1] != '\n'; num += ret) {
if ((ret = __real_read(intercept, buf, size)) == -1) {
if (errno == EINTR) {
ret = 0;
continue;
}
buf[0] = 0;
return;
}
}
buf[num - 1] = 0;
}
static void fin(void) {
if (intercept && mode > 2)
__real_close(intercept);
if (mode > 0)
fprintf(stderr, "intercept: stopped\n");
mode = 0, intercept = 0;
}
static void init(void) {
if (mode) return;
mode = -1;
#ifdef INTERCEPT_PRELOAD
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#define X(name) load(name);
FUNCTIONS
#undef X
#pragma GCC diagnostic pop
#endif
atexit(fin);
const char *val = getenv("INTERCEPT");
if (val && strcmp(val, "stdout") == 0) {
fprintf(stderr, "intercept: intercepting function/system calls and logging to stdout\n");
intercept = STDOUT_FILENO;
mode = 1;
} else if (val && strcmp(val, "stderr") == 0) {
fprintf(stderr, "intercept: intercepting function/system calls and logging to stderr\n");
intercept = STDERR_FILENO;
mode = 2;
} else if (val && strncmp(val, "file:", 5) == 0) {
if ((intercept = open(val + 5, O_CREAT | O_TRUNC | O_WRONLY, 0644)) == -1) {
fprintf(stderr, "intercept: unable to open log file '%s': %s\n" "intercept: not logging or manipulating function/system calls\n", val + 5, strerror(errno));
errno = 0;
mode = -1;
return;
}
fprintf(stderr, "intercept: intercepting function/system calls and logging to file\n");
mode = 3;
} else if (val && strncmp(val, "unix:", 5) == 0) {
if ((intercept = __real_socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
fprintf(stderr, "intercept: unable to open unix socket '%s': %s\n" "intercept: not logging or manipulating function/system calls\n", val + 5, strerror(errno));
errno = 0;
mode = -1;
return;
}
struct sockaddr_un addr = {.sun_family = AF_UNIX};
strncpy(addr.sun_path, val + 5, sizeof(addr.sun_path));
if (__real_connect(intercept, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
fprintf(stderr, "intercept: unable to connect to unix socket '%s': %s\n" "intercept: not logging or manipulating function/system calls\n", val + 5, strerror(errno));
__real_close(intercept);
errno = 0;
mode = -1;
return;
}
fprintf(stderr, "intercept: intercepting function/system calls and logging to unix socket\n");
char buf[256] = "";
const ssize_t ret = readlink("/proc/self/exe", buf, sizeof(buf));
mode = 4;
msg("PID:%li%s%s", getpid(), ret != -1 ? ";PATH:" : "", buf);
} else if (val && strncmp(val, "tcp://", 6) == 0) {
// TODO socket/tcp mode
mode = 5;
} else {
fprintf(stderr, "intercept: not logging or manipulating function/system calls\n");
}
char *fncts = getenv("INTERCEPT_FUNCTIONS");
if (fncts) {
memset(func_flags, 0, sizeof(func_flags));
const char *func_names_ordered[] = {
#define X(name) #name,
FUNCTIONS
#undef X
};
char *func_names[256] = {fncts, NULL};
const size_t len = strlen(fncts);
for (int i = 0, p = 0; i < len; i++) {
const char ch = fncts[i];
if (ch == ',' || ch == ';' || ch == ':' || ch == 0) {
fncts[i] = 0;
func_names[++p] = fncts + i + 1;
}
}
for (int i = 0; func_names[i] != NULL; i++) {
const char *name1 = func_names[i];
const int wildcard = name1[strlen(name1) - 1] == '*';
for (int j = 0; j < sizeof(func_names_ordered) / sizeof(char *); j++) {
const char *name2 = func_names_ordered[j];
if (strcmp(name1, name2) == 0 || (wildcard && strncmp(name1, name2, strlen(name1) - 1) == 0))
func_flags[j] |= 1;
}
}
} else {
memset(func_flags, 1, sizeof(func_flags));
}
}
void *sym(malloc)(size_t size) {
init();
if (!func_flags[func_idx_malloc]) return __real_malloc(size);
msg("malloc(%li): %p", size, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(malloc, size_t, size)
else if_return_ptr_errno(malloc)
else if_fail_ptr_errno(malloc)
else if_invalid(malloc)
}
void *ret = __real_malloc(size);
msg("return %p; errno %s", ret, strerrorname_np(errno));
return ret;
}
void *sym(calloc)(size_t nmemb, size_t size) {
init();
if (!func_flags[func_idx_calloc]) return __real_calloc(nmemb, size);
msg("calloc(%li, %li): %p", nmemb, size, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int(calloc, size_t, nmemb, size_t, size)
else if_return_ptr_errno(calloc)
else if_fail_ptr_errno(calloc)
else if_invalid(calloc)
}
void *ret = __real_calloc(nmemb, size);
msg("return %p; errno %s", ret, strerrorname_np(errno));
return ret;
}
void *sym(realloc)(void *ptr, size_t size) {
init();
if (!func_flags[func_idx_realloc]) return __real_realloc(ptr, size);
msg("realloc(%p, %li): %p", ptr, size, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int(realloc, void *, ptr, size_t, size)
else if_return_ptr_errno(realloc)
else if_fail_ptr_errno(realloc)
else if_invalid(realloc)
}
void *ret = __real_realloc(ptr, size);
msg("return %p; errno %s", ret, strerrorname_np(errno));
return ret;
}
void *sym(reallocarray)(void *ptr, size_t nmemb, size_t size) {
init();
if (!func_flags[func_idx_reallocarray]) return __real_reallocarray(ptr, nmemb, size);
msg("reallocarray(%p, %li): %p", ptr, size, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int_int(reallocarray, void *, ptr, size_t, nmemb, size_t, size)
else if_return_ptr_errno(reallocarray)
else if_fail_ptr_errno(reallocarray)
else if_invalid(reallocarray)
}
void *ret = __real_reallocarray(ptr, nmemb, size);
msg("return %p; errno %s", ret, strerrorname_np(errno));
return ret;
}
void sym(free)(void *ptr) {
init();
if (!func_flags[func_idx_free]) { __real_free(ptr); return; }
msg("free(%p): %p", ptr, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(free, void *, ptr)
else if_return
else if_invalid(free)
}
__real_free(ptr);
msg("return");
}
int sym(getopt)(const int argc, char *const argv[], const char *shortopts) {
init();
if (!func_flags[func_idx_getopt]) return __real_getopt(argc, argv, shortopts);
msg("getopt(%i, %as, %es): %p", argc, argc, argv, shortopts, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// modify <argc>,<argv>,<shortopts>
// TODO getopt modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "getopt");
} else if_return_int(getopt)
else if_invalid(getopt)
}
const int ret = __real_getopt(argc, argv, shortopts);
msg("return %i", ret);
return ret;
}
void sym(exit)(int status) {
init();
if (!func_flags[func_idx_exit]) __real_exit(status);
msg("exit(%i): %p", status, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int("exit", int, status)
else if_invalid(getopt)
}
__real_exit(status);
}
ssize_t sym(read)(int fildes, void *buf, size_t nbyte) {
init();
if (!func_flags[func_idx_read]) return __real_read(fildes, buf, nbyte);
msg("read(%i, %p, %i): %p", fildes, buf, nbyte, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO read modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "read");
} else if_return_int_errno(read)
else if_fail_int_errno(read)
else if_invalid(read)
}
const ssize_t ret = __real_read(fildes, buf, nbyte);
if (ret >= 0) {
msg("return %i; errno %s; buf=%eb", ret, strerrorname_np(errno), ret, buf);
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
ssize_t sym(pread)(int fildes, void *buf, size_t nbyte, off_t offset) {
init();
if (!func_flags[func_idx_pread]) return __real_pread(fildes, buf, nbyte, offset);
msg("pread(%i, %p, %i, %i): %p", fildes, buf, nbyte, offset, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO pread modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "pread");
} else if_return_int_errno(pread)
else if_fail_int_errno(pread)
else if_invalid(pread)
}
const ssize_t ret = __real_pread(fildes, buf, nbyte, offset);
if (ret >= 0) {
msg("return %i; errno %s; buf=%eb", ret, strerrorname_np(errno), ret, buf);
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
ssize_t sym(write)(int fildes, const void *buf, size_t nbyte) {
init();
if (!func_flags[func_idx_write]) return __real_write(fildes, buf, nbyte);
msg("write(%i, %eb, %i): %p", fildes, nbyte, buf, nbyte, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO write modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "write");
} else if_return_int_errno(write)
else if_fail_int_errno(write)
else if_invalid(write)
}
const ssize_t ret = __real_write(fildes, buf, nbyte);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
ssize_t sym(pwrite)(int fildes, const void *buf, size_t nbyte, off_t offset) {
init();
if (!func_flags[func_idx_pwrite]) return __real_pwrite(fildes, buf, nbyte, offset);
msg("pwrite(%i, %eb, %i, %i): %p", fildes, nbyte, buf, nbyte, offset, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO pwrite modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "pwrite");
} else if_return_int_errno(pwrite)
else if_fail_int_errno(pwrite)
else if_invalid(pwrite)
}
const ssize_t ret = __real_pwrite(fildes, buf, nbyte, offset);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(close)(int fildes) {
init();
if (!func_flags[func_idx_close]) return __real_close(fildes);
msg("close(%i): %p", fildes, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(close, int, fildes)
else if_return_int_errno(close)
else if_fail_int_errno(close)
else if_invalid(close)
}
const int ret = __real_close(fildes);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
static const char *getsigstr(int sig) {
switch (sig) {
case_const(SIGINT);
case_const(SIGILL);
case_const(SIGABRT);
case_const(SIGFPE);
case_const(SIGSEGV);
case_const(SIGTERM);
case_const(SIGHUP);
case_const(SIGQUIT);
case_const(SIGTRAP);
case_const(SIGKILL);
case_const(SIGPIPE);
case_const(SIGALRM);
case_const(SIGSTKFLT);
case_const(SIGPWR);
case_const(SIGBUS);
case_const(SIGSYS);
case_const(SIGURG);
case_const(SIGSTOP);
case_const(SIGTSTP);
case_const(SIGCONT);
case_const(SIGCHLD);
case_const(SIGTTIN);
case_const(SIGTTOU);
case_const(SIGPOLL);
case_const(SIGXFSZ);
case_const(SIGXCPU);
case_const(SIGVTALRM);
case_const(SIGPROF);
case_const(SIGUSR1);
case_const(SIGUSR2);
case_const(SIGWINCH);
default: return "?";
}
}
int sym(sigaction)(int sig, const struct sigaction *restrict act, struct sigaction *restrict oact) {
init();
if (!func_flags[func_idx_sigaction]) return __real_sigaction(sig, act, oact);
const char *sigstr = getsigstr(sig);
if (act != NULL) {
char *name = "sa_handler";
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
void *ptr = (void *)act->sa_handler;
if (act->sa_flags & SA_SIGINFO) {
name = "sa_sigaction";
ptr = (void *)act->sa_sigaction;
}
#pragma GCC diagnostic pop
char flgstr[64] = "|";
flag_str(act->sa_flags, SA_NOCLDSTOP, flgstr);
flag_str(act->sa_flags, SA_NOCLDWAIT, flgstr);
flag_str(act->sa_flags, SA_SIGINFO, flgstr);
if (act->sa_flags & ~(SA_NOCLDSTOP | SA_NOCLDWAIT | SA_SIGINFO)) strcat(flgstr, "?|");
char maskstr[512] = "";
for (int i = 0; i < 64; i++) {
if (sigismember(&act->sa_mask, i) != 1)
continue;
if (maskstr[0] != 0) strcat(maskstr, ",");
strcat(maskstr, getsigstr(i));
}
msg("sigaction(%i:%s, %p:{sa_flags: 0x%x:%s, %s: %p, sa_mask: [%s]}, %p): %p", sig, sigstr, act, act->sa_flags, flgstr, name, ptr, maskstr, oact, ret_addr);
} else {
msg("sigaction(%i:%s, %p:{}, %p): %p", sig, sigstr, act, oact, ret_addr);
}
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO sigaction modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "sigaction");
} else if (strncmp(msg_buf, "return ", 7) == 0) {
// TODO sigaction return
fprintf(stderr, "intercept: %s: return command not implemented\n", "sigaction");
} else if_fail_int_errno(sigaction)
else if_invalid(sigaction)
}
const int ret = __real_sigaction(sig, act, oact);
if (oact != NULL) {
char *name = "sa_handler";
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
void *ptr = (void *)oact->sa_handler;
if (oact->sa_flags & SA_SIGINFO) {
name = "sa_sigaction";
ptr = (void *)oact->sa_sigaction;
}
#pragma GCC diagnostic pop
char flgstr[64] = "|";
flag_str(oact->sa_flags, SA_NOCLDSTOP, flgstr);
flag_str(oact->sa_flags, SA_NOCLDWAIT, flgstr);
flag_str(oact->sa_flags, SA_SIGINFO, flgstr);
if (oact->sa_flags & ~(SA_NOCLDSTOP | SA_NOCLDWAIT | SA_SIGINFO)) strcat(flgstr, "?|");
char maskstr[512] = "";
for (int i = 0; i < 64; i++) {
if (sigismember(&oact->sa_mask, i) != 1)
continue;
if (maskstr[0] != 0) strcat(maskstr, ",");
strcat(maskstr, getsigstr(i));
}
msg("return %i; errno %s; oact={sa_flags: 0x%x:%s, %s: %p, sa-mask: [%s]}", ret, strerrorname_np(errno), oact->sa_flags, flgstr, name, ptr, maskstr);
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
int sym(sem_init)(sem_t *sem, int pshared, unsigned int value) {
init();
if (!func_flags[func_idx_sem_init]) return __real_sem_init(sem, pshared, value);
msg("sem_init(%p, %i, %u): %p", sem, pshared, value, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int_int(sem_init, sem_t *, sem, int, pshared, unsigned int, value)
else if_return_int_errno(sem_init)
else if_fail_int_errno(sem_init)
else if_invalid(sem_init)
}
const int ret = __real_sem_init(sem, pshared, value);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
sem_t *sym(sem_open)(const char *name, int oflag, ...) {
init();
char ostr[32] = "|";
flag_str(oflag, O_CREAT, ostr);
flag_str(oflag, O_EXCL, ostr);
if (oflag & ~(O_CREAT | O_EXCL)) strcat(ostr, "?|");
mode_t mode_arg = 0;
unsigned int value = 0;
if (oflag & O_CREAT) {
va_list args;
va_start(args, oflag);
mode_arg = va_arg(args, mode_t);
value = va_arg(args, unsigned int);
va_end(args);
if (!func_flags[func_idx_sem_open]) return __real_sem_open(name, oflag, mode_arg, value);
msg("sem_open(%es, 0%o:%s, 0%03o, %u): %p", name, oflag, ostr, mode_arg, value, ret_addr);
} else {
if (!func_flags[func_idx_sem_open]) return __real_sem_open(name, oflag);
msg("sem_open(%es, 0%o:|%s): %p", name, oflag, ostr, ret_addr);
}
char overwrite[BUFFER_SIZE];
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// modify <name>,<oflag>
// modify <name>,<oflag>,<mode>,<value>
char *val_1 = NULL, *end_ptr_1 = NULL, *end_ptr_2 = NULL, *end_ptr_3 = NULL, *end_ptr_4 = NULL;
long val_2 = 0, val_3 = 0, val_4 = 0;
if (msg_buf[7] == '"') {
// modify "<name>",...
val_1 = strtostr(msg_buf + 7, &end_ptr_1, overwrite);
if (val_1 == NULL) end_ptr_1 = NULL;
} else {
// modify <name_ptr>,...
val_1 = (char *)strtol(msg_buf + 7, &end_ptr_1, 0);
}
if (end_ptr_1 != NULL && end_ptr_1[0] != 0) {
if (end_ptr_1[1] == '|') {
val_2 = 0;
end_ptr_2 = end_ptr_1 + 1;
if (strncmp(end_ptr_2, "O_CREAT|", 8) == 0) {
val_2 |= O_CREAT;
end_ptr_2 += 8;
}
if (strncmp(end_ptr_2, "O_EXCL|", 7) == 0) {
val_2 |= O_EXCL;
end_ptr_2 += 7;
}
} else {
val_2 = strtol(end_ptr_1 + 1, &end_ptr_2, 0);
}
}
if (end_ptr_2 != NULL && end_ptr_2[0] != 0) val_3 = strtol(end_ptr_2 + 1, &end_ptr_3, 0);
if (end_ptr_3 != NULL && end_ptr_3[0] != 0) val_4 = strtol(end_ptr_3 + 1, &end_ptr_4, 0);
if (end_ptr_1 != NULL && end_ptr_1[0] == ',' && end_ptr_1 != msg_buf + 7 &&
end_ptr_2 != NULL && (end_ptr_2[0] == 0 || end_ptr_2[0] == ',') && end_ptr_2 != end_ptr_1 + 1 &&
(end_ptr_2[0] == 0 || (end_ptr_3 != NULL && end_ptr_3[0] == ',' && end_ptr_3 != end_ptr_2 + 1 &&
end_ptr_4 != NULL && end_ptr_4[0] == 0 && end_ptr_4 != end_ptr_3 + 1)))
{
name = val_1;
oflag = (int)val_2;
if (end_ptr_2[0] != 0) {
mode_arg = val_3;
value = val_4;
}
} else {
fprintf(stderr, "intercept: %s: invalid args in modify command: '%s'\n", "sem_open", msg_buf + 7);
}
} else if_return_ptr_errno(sem_open)
else if_fail_ptr_errno(sem_open)
else if_invalid(sem_open)
}
sem_t *ret;
if (oflag & O_CREAT) {
ret = __real_sem_open(name, oflag, mode_arg, value);
} else {
ret = __real_sem_open(name, oflag);
}
msg("return %p; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(sem_post)(sem_t *sem) {
init();
if (!func_flags[func_idx_sem_post]) return __real_sem_post(sem);
msg("sem_post(%p): %p", sem, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(sem_post, sem_t *, sem)
else if_return_int_errno(sem_post)
else if_fail_int_errno(sem_post)
else if_invalid(sem_post)
}
const int ret = __real_sem_post(sem);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(sem_wait)(sem_t *sem) {
init();
if (!func_flags[func_idx_sem_wait]) return __real_sem_wait(sem);
msg("sem_wait(%p): %p", sem, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(sem_wait, sem_t *, sem)
else if_return_int_errno(sem_wait)
else if_fail_int_errno(sem_wait)
else if_invalid(sem_wait)
}
const int ret = __real_sem_wait(sem);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(sem_trywait)(sem_t *sem) {
init();
if (!func_flags[func_idx_sem_trywait]) return __real_sem_trywait(sem);
msg("sem_trywait(%p): %p", sem, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(sem_trywait, sem_t *, sem)
else if_return_int_errno(sem_trywait)
else if_fail_int_errno(sem_trywait)
else if_invalid(sem_trywait)
}
const int ret = __real_sem_trywait(sem);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(sem_timedwait)(sem_t *restrict sem, const struct timespec *restrict abs_timeout) {
init();
if (!func_flags[func_idx_sem_timedwait]) return __real_sem_timedwait(sem, abs_timeout);
msg("sem_timedwait(%p, %qt): %p", sem, abs_timeout, ret_addr);
struct timespec overwrite;
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// modfiy <sem>,<abs_timeout_ptr>
// modify <sem>,{<tv_sec>,<tv_nsec>}
char *end_ptr_1 = NULL, *end_ptr_2 = NULL, *end_ptr_3 = NULL;
long val_1 = strtol(msg_buf + 7, &end_ptr_1, 0);
struct timespec *val_2 = 0;
if (end_ptr_1 != NULL && end_ptr_1[0] != 0) {
if (end_ptr_1[1] == '{') {
long sec = 0, nsec = 0;
sec = strtol(end_ptr_1 + 2, &end_ptr_2, 0);
if (end_ptr_2 != NULL && end_ptr_2[0] == ',') nsec = strtol(end_ptr_2 + 1, &end_ptr_3, 0);
overwrite.tv_sec = sec;
overwrite.tv_nsec = nsec;
if (end_ptr_3 != NULL && end_ptr_3[0] == '}' && end_ptr_3[1] == 0) {
val_2 = &overwrite;
end_ptr_2 = end_ptr_3 + 1;
}
} else {
val_2 = (void *)strtol(end_ptr_1 + 1, &end_ptr_2, 0);
}
}
if (end_ptr_1 != NULL && end_ptr_1[0] == ',' && end_ptr_1 != msg_buf + 7 &&
end_ptr_2 != NULL && end_ptr_2[0] == 0 && end_ptr_2 != end_ptr_1 + 1)
{
sem = (sem_t *)val_1;
abs_timeout = val_2;
} else {
fprintf(stderr, "intercept: %s: invalid args in modify command: '%s'\n", "sem_timedwait", msg_buf + 7);
}
} else if_return_int_errno(sem_timedwait)
else if_fail_int_errno(sem_timedwait)
else if_invalid(sem_timedwait)
}
const int ret = __real_sem_timedwait(sem, abs_timeout);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(sem_getvalue)(sem_t *restrict sem, int *restrict value) {
init();
if (!func_flags[func_idx_sem_getvalue]) return __real_sem_getvalue(sem, value);
msg("sem_getvalue(%p, %p): %p", sem, value, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int(sem_getvalue, sem_t *, sem, int *, value)
else if_return_int_errno_int(sem_getvalue, int, *value, "value")
else if_fail_int_errno(sem_getvalue)
else if_invalid(sem_getvalue)
}
const int ret = __real_sem_getvalue(sem, value);
if (value != NULL) {
msg("return %i; errno %s; value=%i", ret, strerrorname_np(errno), *value);
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
int sym(sem_close)(sem_t *sem) {
init();
if (!func_flags[func_idx_sem_close]) return __real_sem_close(sem);
msg("sem_close(%p): %p", sem, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(sem_close, sem_t *, sem)
else if_return_int_errno(sem_close)
else if_fail_int_errno(sem_close)
else if_invalid(sem_close)
}
const int ret = __real_sem_close(sem);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(sem_unlink)(const char *name) {
init();
if (!func_flags[func_idx_sem_unlink]) return __real_sem_unlink(name);
msg("sem_unlink(%es): %p", name, ret_addr);
char overwrite[BUFFER_SIZE];
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
char *end_ptr = NULL, *val = NULL;
if (msg_buf[7] == '"') {
// modify "<name>"
val = strtostr(msg_buf + 7, &end_ptr, overwrite);
if (val == NULL) end_ptr = NULL;
} else {
// modify <name_ptr>
val = (char *)strtol(msg_buf + 7, &end_ptr, 0);
}
if (end_ptr != NULL && end_ptr[0] == 0 && end_ptr != msg_buf + 7) {
name = val;
} else {
fprintf(stderr, "intercept: %s: invalid args in modify command: '%s'\n", "sem_unlink", msg_buf + 7);
}
} else if_return_int_errno(sem_unlink)
else if_fail_int_errno(sem_unlink)
else if_invalid(sem_unlink)
}
const int ret = __real_sem_unlink(name);
msg("return %p; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(sem_destroy)(sem_t *sem) {
init();
if (!func_flags[func_idx_sem_destroy]) return __real_sem_destroy(sem);
msg("sem_destroy(%p): %p", sem, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(sem_destroy, sem_t *, sem)
else if_return_int_errno(sem_destroy)
else if_fail_int_errno(sem_destroy)
else if_invalid(sem_destroy)
}
const int ret = __real_sem_destroy(sem);
msg("return %p; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(shm_open)(const char *name, int oflag, mode_t mode_arg) {
init();
if (!func_flags[func_idx_shm_open]) return __real_shm_open(name, oflag, mode);
char ostr[64] = "|";
flag_str(oflag, O_RDONLY, ostr);
flag_str(oflag, O_RDWR, ostr);
flag_str(oflag, O_CREAT, ostr);
flag_str(oflag, O_EXCL, ostr);
flag_str(oflag, O_TRUNC, ostr);
if (oflag & ~(O_RDONLY | O_RDWR | O_CREAT | O_EXCL | O_TRUNC)) strcat(ostr, "?|");
msg("shm_open(%es, 0%o:%s, 0%03o): %p", name, oflag, ostr, mode_arg, ret_addr);
char overwrite[BUFFER_SIZE];
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// modify <name>,<oflag>,<mode>
char *val_1 = NULL, *end_ptr_1 = NULL, *end_ptr_2 = NULL, *end_ptr_3 = NULL;
long val_2 = 0, val_3 = 0;
if (msg_buf[7] == '"') {
// modify "<name>",...
val_1 = strtostr(msg_buf + 7, &end_ptr_1, overwrite);
if (val_1 == NULL) end_ptr_1 = NULL;
} else {
// modify <name_ptr>,...
val_1 = (char *)strtol(msg_buf + 7, &end_ptr_1, 0);
}
if (end_ptr_1 != NULL && end_ptr_1[0] != 0) {
if (end_ptr_1[1] == '|') {
val_2 = 0;
end_ptr_2 = end_ptr_1 + 1;
if (strncmp(end_ptr_2, "O_RDONLY|", 8) == 0) {
val_2 |= O_RDONLY;
end_ptr_2 += 9;
}
if (strncmp(end_ptr_2, "O_RDWR|", 8) == 0) {
val_2 |= O_RDWR;
end_ptr_2 += 7;
}
if (strncmp(end_ptr_2, "O_CREAT|", 8) == 0) {
val_2 |= O_CREAT;
end_ptr_2 += 8;
}
if (strncmp(end_ptr_2, "O_EXCL|", 7) == 0) {
val_2 |= O_EXCL;
end_ptr_2 += 7;
}
if (strncmp(end_ptr_2, "O_TRUNC|", 7) == 0) {
val_2 |= O_TRUNC;
end_ptr_2 += 8;
}
} else {
val_2 = strtol(end_ptr_1 + 1, &end_ptr_2, 0);
}
}
if (end_ptr_2 != NULL && end_ptr_2[0] != 0) val_3 = strtol(end_ptr_2 + 1, &end_ptr_3, 0);
if (end_ptr_1 != NULL && end_ptr_1[0] == ',' && end_ptr_1 != msg_buf + 7 &&
end_ptr_2 != NULL && end_ptr_2[0] == ',' && end_ptr_2 != end_ptr_1 + 1 &&
end_ptr_3 != NULL && end_ptr_3[0] == 0 && end_ptr_3 != end_ptr_2 + 1)
{
name = val_1;
oflag = (int)val_2;
mode_arg = val_3;
} else {
fprintf(stderr, "intercept: %s: invalid args in modify command: '%s'\n", "shm_open", msg_buf + 7);
}
} else if_return_int_errno(shm_open)
else if_fail_int_errno(shm_open)
else if_invalid(shm_open)
}
const int ret = __real_shm_open(name, oflag, mode);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(shm_unlink)(const char *name) {
init();
if (!func_flags[func_idx_shm_unlink]) return __real_shm_unlink(name);
msg("shm_unlink(%es): %p", name, ret_addr);
char overwrite[BUFFER_SIZE];
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
char *end_ptr = NULL, *val = NULL;
if (msg_buf[7] == '"') {
// modify "<name>"
val = strtostr(msg_buf + 7, &end_ptr, overwrite);
if (val == NULL) end_ptr = NULL;
} else {
// modify <name_ptr>
val = (char *)strtol(msg_buf + 7, &end_ptr, 0);
}
if (end_ptr != NULL && end_ptr[0] == 0 && end_ptr != msg_buf + 7) {
name = val;
} else {
fprintf(stderr, "intercept: %s: invalid args in modify command: '%s'\n", "shm_unlink", msg_buf + 7);
}
} else if_return_int_errno(shm_unlink)
else if_fail_int_errno(shm_unlink)
else if_invalid(shm_unlink)
}
const int ret = __real_shm_unlink(name);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
void *sym(mmap)(void *addr, size_t len, int prot, int flags, int fildes, off_t off) {
init();
if (!func_flags[func_idx_mmap]) return __real_mmap(addr, len, prot, flags, fildes, off);
char pstr[64] = "|";
if (prot == PROT_NONE) strcat(pstr, "PROT_NONE|");
flag_str(prot, PROT_READ, pstr);
flag_str(prot, PROT_WRITE, pstr);
flag_str(prot, PROT_EXEC, pstr);
if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC)) strcat(pstr, "?|");
char fstr[64] = "|";
flag_str(prot, MAP_SHARED, fstr);
flag_str(prot, MAP_PRIVATE, fstr);
flag_str(prot, MAP_FIXED, fstr);
flag_str(prot, MAP_ANONYMOUS, fstr);
if (prot & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS)) strcat(fstr, "?|");
msg("mmap(%p, %i, 0x%x:%s, %0x%x:%s, %i, %i): %p", addr, len, prot, pstr, flags, fstr, fildes, off, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO mmap modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "mmap");
} else if_return_ptr_errno(mmap)
else if_fail {
set_errno("mmap", msg_buf);
return MAP_FAILED;
} else if_invalid(mmap)
}
void *ret = __real_mmap(addr, len, prot, flags, fildes, off);
msg("return %p; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(munmap)(void *addr, size_t len) {
init();
if (!func_flags[func_idx_munmap]) return __real_munmap(addr, len);
msg("munmap(%p, %i): %p", addr, len, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int(munmap, void *, addr, size_t, len)
else if_return_int_errno(munmap)
else if_fail_int_errno(munmap)
else if_invalid(munmap)
}
const int ret = __real_munmap(addr, len);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(ftruncate)(int fildes, off_t length) {
init();
if (!func_flags[func_idx_ftruncate]) return __real_ftruncate(fildes, length);
msg("ftruncate(%i, %i): %p", fildes, length, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int(ftruncate, int, fildes, off_t, length)
else if_return_int_errno(ftruncate)
else if_fail_int_errno(ftruncate)
else if_invalid(ftruncate)
}
const int ret = __real_ftruncate(fildes, length);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
pid_t sym(fork)(void) {
init();
if (!func_flags[func_idx_fork]) return __real_fork();
msg("fork(): %p", ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_return_int_errno(fork)
else if_fail_int_errno(fork)
else if_invalid(fork)
}
const pid_t ret = __real_fork();
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
pid_t sym(wait)(int *stat_loc) {
init();
if (!func_flags[func_idx_wait]) return __real_wait(stat_loc);
msg("wait(%p): %p", stat_loc, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(wait, int *, stat_loc)
else if_return_int_errno_int(wait, int, *stat_loc, "stat_loc")
else if_fail_int_errno(wait)
else if_invalid(wait)
}
const pid_t ret = __real_wait(stat_loc);
if (stat_loc != NULL) {
msg("return %i; errno %s; stat=%i", ret, *stat_loc, strerrorname_np(errno));
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
pid_t sym(waitpid)(pid_t pid, int *stat_loc, int options) {
init();
if (!func_flags[func_idx_waitpid]) return __real_waitpid(pid, stat_loc, options);
char ostr[64] = "|";
flag_str(options, WCONTINUED, ostr);
flag_str(options, WNOHANG, ostr);
flag_str(options, WUNTRACED, ostr);
if (options & ~(WCONTINUED | WNOHANG | WUNTRACED)) strcat(ostr, "?|");
msg("waitpid(%i, %p, 0x%x:%s): %p", pid, stat_loc, options, ostr, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
// TODO waitpid modify options
if_modify_int_int_int(waitpid, pid_t, pid, int *, stat_loc, int, options)
else if_return_int_errno_int(waitpid, int, *stat_loc, "stat_loc")
else if_fail_int_errno(waitpid)
else if_invalid(waitpid)
}
const pid_t ret = __real_waitpid(pid, stat_loc, options);
if (stat_loc != NULL) {
msg("return %i; errno %s; stat=%i", ret, *stat_loc, strerrorname_np(errno));
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
int sym(execl)(const char *pathname, const char *arg, ...) {
init();
va_list args;
va_start(args, arg);
const char *arg_vec[64];
arg_vec[0] = arg;
for (int i = 1; i < 64 && arg_vec[i - 1] != NULL; i++) {
arg_vec[i] = va_arg(args, const char *);
}
va_end(args);
if (!func_flags[func_idx_execl]) return __real_execv(pathname, (char *const *)arg_vec);
char arg_buf[4096] = "", *arg_buf_ptr = arg_buf;
for (int i = 1; i < 64; i++) {
arg_buf_ptr[0] = ',';
arg_buf_ptr[1] = ' ';
arg_buf_ptr[2] = 0;
arg_buf_ptr += 2;
if (arg_vec[i] == NULL) {
strcat(arg_buf_ptr, "NULL");
break;
}
arg_buf_ptr += msg_str(arg_buf, sizeof(arg_buf) - (arg_buf_ptr - arg_buf), arg_vec[i], 0);
}
msg("execl(%es, %es%s): %p", pathname, arg, arg_buf, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO execl modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "execl");
} else if_return_int_errno(execl)
else if_fail_int_errno(execl)
else if_invalid(execl)
}
const int ret = __real_execv(pathname, (char *const *)arg_vec);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(execlp)(const char *file, const char *arg, ...) {
init();
va_list args;
va_start(args, arg);
const char *arg_vec[64];
arg_vec[0] = arg;
for (int i = 1; i < 64 && arg_vec[i - 1] != NULL; i++) {
arg_vec[i] = va_arg(args, const char *);
}
va_end(args);
if (!func_flags[func_idx_execlp]) return __real_execvp(file, (char *const *)arg_vec);
char arg_buf[4096] = "", *arg_buf_ptr = arg_buf;
for (int i = 1; i < 64; i++) {
arg_buf_ptr[0] = ',';
arg_buf_ptr[1] = ' ';
arg_buf_ptr[2] = 0;
arg_buf_ptr += 2;
if (arg_vec[i] == NULL) {
strcat(arg_buf_ptr, "NULL");
break;
}
arg_buf_ptr += msg_str(arg_buf, sizeof(arg_buf) - (arg_buf_ptr - arg_buf), arg_vec[i], 0);
}
msg("execlp(%es, %es%s): %p", file, arg, arg_buf, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO execlp modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "execlp");
} else if_return_int_errno(execlp)
else if_fail_int_errno(execlp)
else if_invalid(execlp)
}
const int ret = __real_execvp(file, (char *const *)arg_vec);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(execle)(const char *pathname, const char *arg, ...) {
init();
va_list args;
va_start(args, arg);
const char *arg_vec[64];
char *const *envp = NULL;
arg_vec[0] = arg;
for (int i = 1; i < 64; i++) {
arg_vec[i] = va_arg(args, const char *);
if (arg_vec[i] == NULL) {
envp = va_arg(args, char *const *);
break;
}
}
va_end(args);
if (!func_flags[func_idx_execle]) return __real_execvpe(pathname, (char *const *)arg_vec, envp);
char arg_buf[4096] = "", *arg_buf_ptr = arg_buf;
for (int i = 1; i < 64; i++) {
arg_buf_ptr[0] = ',';
arg_buf_ptr[1] = ' ';
arg_buf_ptr[2] = 0;
arg_buf_ptr += 2;
if (arg_vec[i] == NULL) {
strcat(arg_buf_ptr, "NULL");
break;
}
arg_buf_ptr += msg_str(arg_buf, sizeof(arg_buf) - (arg_buf_ptr - arg_buf), arg_vec[i], 0);
}
int len = 0; for (len = 0; envp[len] != NULL; len++) {}
msg("execle(%es, %es%s, %as): %p", pathname, arg, arg_buf, len, envp, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO execle modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "execle");
} else if_return_int_errno(execle)
else if_fail_int_errno(execle)
else if_invalid(execle)
}
const int ret = __real_execvpe(pathname, (char *const *)arg_vec, envp);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(execv)(const char *pathname, char *const argv[]) {
init();
if (!func_flags[func_idx_execv]) return __real_execv(pathname, argv);
int len = 0; for (len = 0; argv[len] != NULL; len++) {}
msg("execv(%es, %as): %p", pathname, len, argv, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO execv modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "execv");
} else if_return_int_errno(execv)
else if_fail_int_errno(execv)
else if_invalid(execv)
}
const int ret = __real_execv(pathname, argv);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(execvp)(const char *file, char *const argv[]) {
init();
if (!func_flags[func_idx_execvp]) return __real_execvp(file, argv);
int len = 0; for (len = 0; argv[len] != NULL; len++) {}
msg("execvp(%es, %as): %p", file, len, argv, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO execvp modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "execvp");
} else if_return_int_errno(execvp)
else if_fail_int_errno(execvp)
else if_invalid(execvp)
}
const int ret = __real_execvp(file, argv);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(execvpe)(const char *file, char *const argv[], char *const envp[]) {
init();
if (!func_flags[func_idx_execvpe]) return __real_execvpe(file, argv, envp);
int len1 = 0; for (len1 = 0; argv[len1] != NULL; len1++) {}
int len2 = 0; for (len2 = 0; envp[len2] != NULL; len2++) {}
msg("execvpe(%es, %as, %as): %p", file, len1, argv, len2, envp, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO execvpe modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "execvpe");
} else if_return_int_errno(execvpe)
else if_fail_int_errno(execvpe)
else if_invalid(execvpe)
}
const int ret = __real_execvpe(file, argv, envp);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(execve)(const char *pathname, char *const argv[], char *const envp[]) {
init();
if (!func_flags[func_idx_execve]) return __real_execve(pathname, argv, envp);
int len1 = 0; for (len1 = 0; argv[len1] != NULL; len1++) {}
int len2 = 0; for (len2 = 0; envp[len2] != NULL; len2++) {}
msg("execve(%es, %as, %as): %p", pathname, len1, argv, len2, envp, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO execve modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "execve");
} else if_return_int_errno(execve)
else if_fail_int_errno(execve)
else if_invalid(execve)
}
const int ret = __real_execve(pathname, argv, envp);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(fexecve)(int fd, char *const argv[], char *const envp[]) {
init();
if (!func_flags[func_idx_fexecve]) return __real_fexecve(fd, argv, envp);
int len1 = 0; for (len1 = 0; argv[len1] != NULL; len1++) {}
int len2 = 0; for (len2 = 0; envp[len2] != NULL; len2++) {}
msg("fexecve(%i, %as, %as): %p", fd, len1, argv, len2, envp, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO fexecve modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "fexecve");
} else if_return_int_errno(fexecve)
else if_fail_int_errno(fexecve)
else if_invalid(fexecve)
}
const int ret = __real_fexecve(fd, argv, envp);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(pipe)(int fildes[2]) {
init();
if (!func_flags[func_idx_pipe]) return __real_pipe(fildes);
msg("pipe(%p): %p", fildes, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO pipe modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "pipe");
} else if_return_int_errno(pipe)
else if_fail_int_errno(pipe)
else if_invalid(pipe)
}
const int ret = __real_pipe(fildes);
msg("return %i; errno %s; fildes=[%i,%i]", ret, strerrorname_np(errno), fildes[0], fildes[1]);
return ret;
}
int sym(dup)(int oldfd) {
init();
if (!func_flags[func_idx_dup]) return __real_dup(oldfd);
msg("dup(%i): %p", oldfd, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(dup, int, oldfd)
else if_return_int_errno(dup)
else if_fail_int_errno(dup)
else if_invalid(dup)
}
const int ret = __real_dup(oldfd);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(dup2)(int oldfd, int newfd) {
init();
if (!func_flags[func_idx_dup2]) return __real_dup2(oldfd, newfd);
msg("dup2(%i, %i): %p", oldfd, newfd, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int(dup2, int, oldfd, int, newfd)
else if_return_int_errno(dup2)
else if_fail_int_errno(dup2)
else if_invalid(dup2)
}
const int ret = __real_dup2(oldfd, newfd);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(dup3)(int oldfd, int newfd, int flags) {
init();
if (!func_flags[func_idx_dup3]) return __real_dup3(oldfd, newfd, flags);
char fstr[16] = "|";
flag_str(flags, O_CLOEXEC, fstr);
if (flags & ~(O_CLOEXEC)) strcat(fstr, "?|");
msg("dup3(%i, %i, 0%o:%s): %p", oldfd, newfd, flags, fstr, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int_int(dup3, int, oldfd, int, newfd, int, flags)
else if_return_int_errno(dup3)
else if_fail_int_errno(dup3)
else if_invalid(dup3)
}
const int ret = __real_dup3(oldfd, newfd, flags);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(socket)(int domain, int type, int protocol) {
init();
if (!func_flags[func_idx_socket]) return __real_socket(domain, type, protocol);
msg("socket(%i:%s, %i:%s, %i): %p", domain, getdomainstr(domain), type, getsocktype(type), protocol, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO socket modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "socket");
} else if_return_int_errno(socket)
else if_fail_int_errno(socket)
else if_invalid(socket)
}
const int ret = __real_socket(domain, type, protocol);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(bind)(int sockfd, const struct sockaddr *address, socklen_t address_len) {
init();
if (!func_flags[func_idx_bind]) return __real_bind(sockfd, address, address_len);
msg("socket(%i, %qa, %i): %p", sockfd, address_len, address, address_len, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO bind modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "bind");
} else if_return_int_errno(bind)
else if_fail_int_errno(bind)
else if_invalid(bind)
}
const int ret = __real_bind(sockfd, address, address_len);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(listen)(int sockfd, int backlog) {
init();
if (!func_flags[func_idx_listen]) return __real_listen(sockfd, backlog);
msg("listen(%i, %i): %p", sockfd, backlog, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int_int(listen, int, sockfd, int, backlog)
else if_return_int_errno(listen)
else if_fail_int_errno(listen)
else if_invalid(listen)
}
const int ret = __real_listen(sockfd, backlog);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(accept)(int sockfd, struct sockaddr *restrict address, socklen_t *restrict address_len) {
init();
if (!func_flags[func_idx_accept]) return __real_accept(sockfd, address, address_len);
msg("accept(%i, %p, %p): %p", sockfd, address, address_len, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO accept modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "accept");
} else if_return_int_errno(accept)
else if_fail_int_errno(accept)
else if_invalid(accept)
}
const int ret = __real_accept(sockfd, address, address_len);
if (ret >= 0) {
if (address != NULL && address_len != NULL) {
msg("return %i; errno %s; address=%qa; address_len=%i", ret, strerrorname_np(errno), *address_len, address, *address_len);
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
int sym(connect)(int sockfd, const struct sockaddr *address, socklen_t address_len) {
init();
if (!func_flags[func_idx_connect]) return __real_connect(sockfd, address, address_len);
msg("connect(%i, %qa, %i): %p", sockfd, address_len, address, address_len, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO connect modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "connect");
} else if_return_int_errno(connect)
else if_fail_int_errno(connect)
else if_invalid(connect)
}
const int ret = __real_connect(sockfd, address, address_len);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
int sym(getaddrinfo)(const char *restrict node, const char *restrict service, const struct addrinfo *restrict hints, struct addrinfo **restrict res) {
init();
if (!func_flags[func_idx_getaddrinfo]) return __real_getaddrinfo(node, service, hints, res);
msg("getaddrinfo(%es, %es, %qi, %p): %p", node, service, hints, res, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO getaddrinfo modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "getaddrinfo");
} else if_return_int_errno(getaddrinfo)
else if_fail_int_errno(getaddrinfo)
else if_invalid(getaddrinfo)
}
const int ret = __real_getaddrinfo(node, service, hints, res);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
void sym(freeaddrinfo)(struct addrinfo *res) {
init();
if (!func_flags[func_idx_freeaddrinfo]) { __real_freeaddrinfo(res); return; }
msg("freeaddrinfo(%p): %p", res, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if_modify_int(freeaddrinfo, struct addrinfo *, res)
else if_return
else if_invalid(freeaddrinfo)
}
__real_freeaddrinfo(res);
msg("return");
}
ssize_t sym(send)(int sockfd, const void *buf, size_t length, int flags) {
init();
if (!func_flags[func_idx_send]) return __real_send(sockfd, buf, length, flags);
char fstr[256] = "|";
flag_str(flags, MSG_CONFIRM, fstr);
flag_str(flags, MSG_DONTROUTE, fstr);
flag_str(flags, MSG_DONTWAIT, fstr);
flag_str(flags, MSG_EOR, fstr);
flag_str(flags, MSG_MORE, fstr);
flag_str(flags, MSG_NOSIGNAL, fstr);
flag_str(flags, MSG_OOB, fstr);
flag_str(flags, MSG_FASTOPEN, fstr);
if (flags & ~(MSG_CONFIRM | MSG_DONTROUTE | MSG_EOR | MSG_MORE | MSG_NOSIGNAL | MSG_OOB | MSG_FASTOPEN)) strcat(fstr, "?|");
msg("send(%i, %eb, %i, 0x%x:%s): %p", sockfd, length, buf, length, flags, fstr, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO send modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "send");
} else if_return_int_errno(send)
else if_fail_int_errno(send)
else if_invalid(send)
}
const ssize_t ret = __real_send(sockfd, buf, length, flags);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
ssize_t sym(sendto)(int sockfd, const void *buf, size_t size, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) {
init();
if (!func_flags[func_idx_sendto]) return __real_sendto(sockfd, buf, size, flags, dest_addr, addrlen);
char fstr[256] = "|";
flag_str(flags, MSG_CONFIRM, fstr);
flag_str(flags, MSG_DONTROUTE, fstr);
flag_str(flags, MSG_DONTWAIT, fstr);
flag_str(flags, MSG_EOR, fstr);
flag_str(flags, MSG_MORE, fstr);
flag_str(flags, MSG_NOSIGNAL, fstr);
flag_str(flags, MSG_OOB, fstr);
flag_str(flags, MSG_FASTOPEN, fstr);
if (flags & ~(MSG_CONFIRM | MSG_DONTROUTE | MSG_EOR | MSG_MORE | MSG_NOSIGNAL | MSG_OOB | MSG_FASTOPEN)) strcat(fstr, "?|");
msg("sendto(%i, %eb, %i, 0x%x:%s, %qa, %i): %p", sockfd, size, buf, size, flags, fstr, addrlen, dest_addr, addrlen, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO sendto modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "sendto");
} else if_return_int_errno(sendto)
else if_fail_int_errno(sendto)
else if_invalid(sendto)
}
const ssize_t ret = __real_sendto(sockfd, buf, size, flags, dest_addr, addrlen);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
ssize_t sym(sendmsg)(int sockfd, const struct msghdr *message, int flags) {
init();
if (!func_flags[func_idx_sendmsg]) return __real_sendmsg(sockfd, message, flags);
char fstr[256] = "|";
flag_str(flags, MSG_CONFIRM, fstr);
flag_str(flags, MSG_DONTROUTE, fstr);
flag_str(flags, MSG_DONTWAIT, fstr);
flag_str(flags, MSG_EOR, fstr);
flag_str(flags, MSG_MORE, fstr);
flag_str(flags, MSG_NOSIGNAL, fstr);
flag_str(flags, MSG_OOB, fstr);
flag_str(flags, MSG_FASTOPEN, fstr);
if (flags & ~(MSG_CONFIRM | MSG_DONTROUTE | MSG_EOR | MSG_MORE | MSG_NOSIGNAL | MSG_OOB | MSG_FASTOPEN)) strcat(fstr, "?|");
msg("sendmsg(%i, %qm, 0x%x:%s): %p", sockfd, message, flags, fstr, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO sendmsg modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "sendmsg");
} else if_return_int_errno(sendmsg)
else if_fail_int_errno(sendmsg)
else if_invalid(sendmsg)
}
const ssize_t ret = __real_sendmsg(sockfd, message, flags);
msg("return %i; errno %s", ret, strerrorname_np(errno));
return ret;
}
ssize_t sym(recv)(int sockfd, void *buf, size_t size, int flags) {
init();
if (!func_flags[func_idx_recv]) return __real_recv(sockfd, buf, size, flags);
char fstr[256] = "|";
flag_str(flags, MSG_DONTWAIT, fstr);
flag_str(flags, MSG_ERRQUEUE, fstr);
flag_str(flags, MSG_OOB, fstr);
flag_str(flags, MSG_PEEK, fstr);
flag_str(flags, MSG_TRUNC, fstr);
flag_str(flags, MSG_WAITALL, fstr);
if (flags & ~(MSG_DONTWAIT | MSG_ERRQUEUE | MSG_OOB | MSG_PEEK | MSG_TRUNC | MSG_WAITALL)) strcat(fstr, "?|");
msg("recv(%i, %p, %i, 0x%x:%s): %p", sockfd, buf, size, flags, fstr, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO recv modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "recv");
} else if_return_int_errno(recv)
else if_fail_int_errno(recv)
else if_invalid(recv)
}
const ssize_t ret = __real_recv(sockfd, buf, size, flags);
if (ret >= 0) {
msg("return %i; errno %s; buf=%eb", ret, strerrorname_np(errno), ret, buf);
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
ssize_t sym(recvfrom)(int sockfd, void *restrict buf, size_t size, int flags, struct sockaddr *restrict src_addr, socklen_t *restrict addrlen) {
init();
if (!func_flags[func_idx_recvfrom]) return __real_recvfrom(sockfd, buf, size, flags, src_addr, addrlen);
char fstr[256] = "|";
flag_str(flags, MSG_DONTWAIT, fstr);
flag_str(flags, MSG_ERRQUEUE, fstr);
flag_str(flags, MSG_OOB, fstr);
flag_str(flags, MSG_PEEK, fstr);
flag_str(flags, MSG_TRUNC, fstr);
flag_str(flags, MSG_WAITALL, fstr);
if (flags & ~(MSG_DONTWAIT | MSG_ERRQUEUE | MSG_OOB | MSG_PEEK | MSG_TRUNC | MSG_WAITALL)) strcat(fstr, "?|");
msg("recvfrom(%i, %p, %i, 0x%x:%s, %p, %p): %p", sockfd, buf, size, flags, fstr, addrlen, src_addr, addrlen, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO recvfrom modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "recvfrom");
} else if_return_int_errno(recvfrom)
else if_fail_int_errno(recvfrom)
else if_invalid(recvfrom)
}
const ssize_t ret = __real_recvfrom(sockfd, buf, size, flags, src_addr, addrlen);
if (ret >= 0) {
if (src_addr != NULL && addrlen != NULL) {
msg("return %i; errno %s; buf=%eb; src_addr=%qa; addrlen=%i", ret, strerrorname_np(errno), ret, buf, *addrlen, src_addr, *addrlen);
} else {
msg("return %i; errno %s; buf=%eb", ret, strerrorname_np(errno), ret, buf);
}
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
ssize_t sym(recvmsg)(int sockfd, struct msghdr *message, int flags) {
init();
if (!func_flags[func_idx_recvmsg]) return __real_recvmsg(sockfd, message, flags);
char fstr[256] = "|";
flag_str(flags, MSG_CMSG_CLOEXEC, fstr);
flag_str(flags, MSG_DONTWAIT, fstr);
flag_str(flags, MSG_ERRQUEUE, fstr);
flag_str(flags, MSG_OOB, fstr);
flag_str(flags, MSG_PEEK, fstr);
flag_str(flags, MSG_TRUNC, fstr);
flag_str(flags, MSG_WAITALL, fstr);
if (flags & ~(MSG_CMSG_CLOEXEC | MSG_DONTWAIT | MSG_ERRQUEUE | MSG_OOB | MSG_PEEK | MSG_TRUNC | MSG_WAITALL)) strcat(fstr, "?|");
msg("recvmsg(%i, %qm, 0x%x:%s): %p", sockfd, msg, flags, fstr, ret_addr);
if (mode >= 4) {
char msg_buf[BUFFER_SIZE];
rcv(msg_buf, sizeof(msg_buf));
if (strncmp(msg_buf, "modify ", 7) == 0) {
// TODO recvmsg modify
fprintf(stderr, "intercept: %s: modify command not implemented\n", "recvmsg");
} else if_return_int_errno(recvmsg)
else if_fail_int_errno(recvmsg)
else if_invalid(recvmsg)
}
const ssize_t ret = __real_recvmsg(sockfd, message, flags);
if (ret >= 0) {
msg("return %i; errno %s; message=%eb", ret, strerrorname_np(errno), sizeof(*message), message);
} else {
msg("return %i; errno %s", ret, strerrorname_np(errno));
}
return ret;
}
View Git Blame Copy Permalink