From 7a4ad7162aef8f626a7ff074a4c92e6419a00eb5 Mon Sep 17 00:00:00 2001 From: Randy Jordan Date: Fri, 26 Jun 2026 16:30:34 -0500 Subject: [PATCH] try implementation progress --- src/ci2_try.c | 366 ++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 328 insertions(+), 38 deletions(-) diff --git a/src/ci2_try.c b/src/ci2_try.c index 176373f..1107f25 100644 --- a/src/ci2_try.c +++ b/src/ci2_try.c @@ -29,78 +29,246 @@ a robust way to handle errors. #include "../include/platform/error/ci2_exception.h" // Exceptions #include "../include/platform/try/ci2_try.h" +#include +#include /* fcntl.h */ int -ci2_try_creat(const char* path, mode_t mode); +ci2_try_creat(const char* path, mode_t mode) +{ + int res = creat(path, mode); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_fcntl(int fd, int cmd, long args); int -ci2_try_open(const char* pathname, int flags, mode_t mode); +ci2_try_open(const char* path, int flags, mode_t mode) +{ + int res = open(path, flags, mode); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} /* socket.h */ int -ci2_try_accept(int, struct sockaddr* restrict, socklen_t* restrict); +ci2_try_accept(int sockfd, + struct sockaddr* restrict addr, + socklen_t* restrict addrlen) +{ + int res = accept(sockfd, addr, addrlen); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int -ci2_try_bind(int, const struct sockaddr*, socklen_t); +ci2_try_bind(int sockfd, const struct sockaddr* addr, socklen_t addrlen) +{ + int res = bind(sockfd, addr, addrlen); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int -ci2_try_connect(int, const struct sockaddr*, socklen_t); +ci2_try_connect(int sockfd, const struct sockaddr* addr, socklen_t addrlen) +{ + int res = connect(sockfd, addr, addrlen); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int -ci2_try_getpeername(int, struct sockaddr* restrict, socklen_t* restrict); +ci2_try_getpeername(int sockfd, + struct sockaddr* restrict addr, + socklen_t* restrict addrlen) +{ + int res = getpeername(sockfd, addr, addrlen); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int -ci2_try_getsockname(int, struct sockaddr* restrict, socklen_t* restrict); +ci2_try_getsockname(int sockfd, + struct sockaddr* restrict addr, + socklen_t* restrict addrlen) +{ + int res = getsockname(sockfd, addr, addrlen); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_getsockopt(int, int, int, void* restrict, socklen_t* restrict); int -ci2_try_listen(int, int); +ci2_try_listen(int sockfd, int backlog) +{ + int res = listen(sockfd, backlog); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} ssize_t -ci2_try_recv(int, void*, size_t, int); +ci2_try_recv(int sockfd, void* buf, size_t len, int flags) +{ + ssize_t res = recv(sockfd, buf, len, flags); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} ssize_t -ci2_try_recvfrom(int, - void* restrict, - size_t, - int, - struct sockaddr* restrict, - socklen_t* restrict); +ci2_try_recvfrom(int sockfd, + void* restrict buf, + size_t len, + int flags, + struct sockaddr* restrict addr, + socklen_t* restrict addrlen) +{ + ssize_t res = recvfrom(sockfd, buf, len, flags, addr, addrlen); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} ssize_t -ci2_try_recvmsg(int, struct msghdr*, int); +ci2_try_recvmsg(int sockfd, struct msghdr* msg, int flags) +{ + ssize_t res = recvmsg(sockfd, msg, flags); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} ssize_t -ci2_try_send(int, const void*, size_t, int); +ci2_try_send(int sockfd, const void* buf, size_t len, int flags) +{ + ssize_t res = send(sockfd, buf, len, flags); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} ssize_t -ci2_try_sendmsg(int, const struct msghdr*, int); +ci2_try_sendmsg(int sockfd, const struct msghdr* msg, int flags) +{ + ssize_t res = sendmsg(sockfd, msg, flags); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} ssize_t -ci2_try_sendto(int, - const void*, - size_t, - int, - const struct sockaddr*, - socklen_t); +ci2_try_sendto(int sockfd, + const void* buf, + size_t len, + int flags, + const struct sockaddr* addr, + socklen_t addrlen) +{ + ssize_t res = sendto(sockfd, buf, len, flags, addr, addrlen); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_setsockopt(int, int, int, const void*, socklen_t); int -ci2_try_shutdown(int, int); +ci2_try_shutdown(int fd, int how) +{ + int res = shutdown(fd, how); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_sockatmark(int); int -ci2_try_socket(int, int, int); +ci2_try_socket(int domain, int type, int protocol) +{ + int res = socket(domain, type, protocol); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_socketpair(int, int, int, int[2]); @@ -168,7 +336,17 @@ int ci2_try_chown(const char*, uid_t, gid_t); int -ci2_try_close(int); +ci2_try_close(int fd) +{ + int res = close(fd); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} size_t ci2_try_confstr(int, char*, size_t); @@ -177,10 +355,30 @@ char* ci2_try_crypt(const char*, const char*); int -ci2_try_dup(int); +ci2_try_dup(int oldfd) +{ + int res = dup(oldfd); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int -ci2_try_dup2(int, int); +ci2_try_dup2(int oldfd, int newfd) +{ + int res = dup2(oldfd, newfd); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} void ci2_try_exit(int); @@ -198,13 +396,43 @@ int ci2_try_execlp(const char*, const char*, ...); int -ci2_try_execv(const char*, char* const[]); +ci2_try_execv(const char* path, char* const argv[]) +{ + int res = execv(path, argv); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int -ci2_try_execve(const char*, char* const[], char* const[]); +ci2_try_execve(const char* path, char* const argv[], char* const envp[]) +{ + int res = execve(path, argv, envp); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int -ci2_try_execvp(const char*, char* const[]); +ci2_try_execvp(const char* file, char* const argv[]) +{ + int res = execvp(file, argv); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_faccessat(int, const char*, int, int); @@ -225,7 +453,17 @@ int ci2_try_fexecve(int, char* const[], char* const[]); pid_t -ci2_try_fork(void); +ci2_try_fork(void) +{ + pid_t res = fork(); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} long ci2_try_fpathconf(int, int); @@ -310,7 +548,17 @@ int ci2_try_pause(void); int -ci2_try_pipe(int[2]); +ci2_try_pipe(int fds[2]) +{ + int res = pipe(fds); + if (res < 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} ssize_t ci2_try_pread(int, void*, size_t, off_t); @@ -403,10 +651,30 @@ int ci2_try_dprintf(int, const char* restrict, ...); int -ci2_try_fclose(FILE*); +ci2_try_fclose(FILE* fp) +{ + int res = fclose(fp); + if (res != 0) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} FILE* -ci2_try_fdopen(int, const char*); +ci2_try_fdopen(int fd, const char* mode) +{ + FILE* res = fdopen(fd, mode); + if (res == NULL) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_feof(FILE*); @@ -436,7 +704,17 @@ FILE* ci2_try_fmemopen(void* restrict, size_t, const char* restrict); FILE* -ci2_try_fopen(const char* restrict, const char* restrict); +ci2_try_fopen(const char* restrict path, const char* restrict mode) +{ + FILE* res = fopen(path, mode); + if (res == NULL) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_fprintf(FILE* restrict, const char* restrict, ...); @@ -451,7 +729,19 @@ size_t ci2_try_fread(void* restrict, size_t, size_t, FILE* restrict); FILE* -ci2_try_freopen(const char* restrict, const char* restrict, FILE* restrict); +ci2_try_freopen(const char* restrict path, + const char* restrict mode, + FILE* restrict stream) +{ + FILE* res = freopen(path, mode, stream); + if (res == NULL) { + int err = errno; + char* err_str = strerror(err); + struct Exception e = { err_str }; + CI2_RAISE(e); + } + return res; +} int ci2_try_fscanf(FILE* restrict, const char* restrict, ...);