diff --git a/src/sys/syscalls/accept.c b/src/sys/syscalls/accept.c index 010694b3..76a19cd2 100644 --- a/src/sys/syscalls/accept.c +++ b/src/sys/syscalls/accept.c @@ -3,6 +3,7 @@ #include #include #include +#include extern fs_t kerneltmpfs; @@ -70,6 +71,17 @@ syscallret syscall_accept(int sockfd, void* addr, socklen_t* addrlen){ if(retv.errno) goto _fail; + + retv.errno = u_memcpy(addr, &peer->addr_un, peer->addrlen); + + if(retv.errno) + goto _fail; + + retv.errno = u_memcpy(addrlen, &peer->addrlen, sizeof(socklen_t)); + + if(retv.errno) + goto _fail; + connsock->peer = peer; connsock->state = SOCKET_STATE_CONNECTED; @@ -87,11 +99,8 @@ syscallret syscall_accept(int sockfd, void* addr, socklen_t* addrlen){ fd_release(fd); fd_release(connfd); - - retv.ret = connifd; - - memcpy(addr, &peer->addr_un, peer->addrlen); - *addrlen = peer->addrlen; + + retv.ret = connifd; return retv; diff --git a/src/sys/syscalls/chdir.c b/src/sys/syscalls/chdir.c index 33ec04a4..92611f20 100644 --- a/src/sys/syscalls/chdir.c +++ b/src/sys/syscalls/chdir.c @@ -6,6 +6,7 @@ #include #include #include +#include syscallret syscall_chdir(const char* path){ syscallret retv; @@ -17,10 +18,18 @@ syscallret syscall_chdir(const char* path){ return retv; } - size_t len = strlen(path); + size_t len; + + retv.errno = u_strlen(path, &len); + if(retv.errno) + return retv; + char buff[len+1]; - strcpy(buff, path); + retv.errno = u_strcpy(buff, path); + + if(retv.errno) + return retv; proc_t* proc = arch_getcls()->thread->proc; diff --git a/src/sys/syscalls/chmodat.c b/src/sys/syscalls/chmodat.c index 25a8fd3c..7485dd61 100644 --- a/src/sys/syscalls/chmodat.c +++ b/src/sys/syscalls/chmodat.c @@ -4,6 +4,7 @@ #include #include #include +#include // flags is ignored for now @@ -17,11 +18,19 @@ syscallret syscall_fchmodat(int dirfd, const char* path, mode_t mode, int flags) return retv; } - size_t len = strlen(path); + size_t len; + + retv.errno = u_strlen(path, &len); + + if(retv.errno) + return retv; char buff[len+1]; - strcpy(buff, path); + retv.errno = u_strcpy(buff, path); + + if(retv.errno) + return retv; proc_t* proc = arch_getcls()->thread->proc; diff --git a/src/sys/syscalls/chroot.c b/src/sys/syscalls/chroot.c index 80fbb055..6a9ee6af 100644 --- a/src/sys/syscalls/chroot.c +++ b/src/sys/syscalls/chroot.c @@ -3,6 +3,7 @@ #include #include #include +#include syscallret syscall_chroot(const char* path){ @@ -14,11 +15,19 @@ syscallret syscall_chroot(const char* path){ return retv; } - size_t len = strlen(path); + size_t len; + + retv.errno = u_strlen(path, &len); + + if(retv.errno) + return retv; char buff[len+1]; - strcpy(buff, path); + retv.errno = u_strcpy(buff, path); + + if(retv.errno) + return retv; proc_t* proc = arch_getcls()->thread->proc; diff --git a/src/sys/syscalls/clock_get.c b/src/sys/syscalls/clock_get.c index 0c1a898e..01458dfc 100644 --- a/src/sys/syscalls/clock_get.c +++ b/src/sys/syscalls/clock_get.c @@ -3,6 +3,7 @@ #include #include #include +#include #define CLOCK_REALTIME 0 @@ -19,7 +20,8 @@ syscallret syscall_clock_gettime(int clockid, struct timespec *tp){ switch(clockid){ case CLOCK_REALTIME: - *tp = arch_timekeeper_gettime(); + struct timespec t = arch_timekeeper_gettime(); + retv.errno = u_memcpy(tp, &t, sizeof(struct timespec)); break; default: retv.errno = EINVAL; diff --git a/src/sys/syscalls/execve.c b/src/sys/syscalls/execve.c index d4adb97c..5b46fde4 100644 --- a/src/sys/syscalls/execve.c +++ b/src/sys/syscalls/execve.c @@ -9,6 +9,7 @@ #include #include #include +#include static void destroyvec(char* vec[], size_t vecsize){ for(uintmax_t p = 0; p < vecsize; ++p){ @@ -30,17 +31,28 @@ syscallret syscall_execve(const char* name, char* const argv[], char* const envp return retv; } - size_t namelen = strlen(name); // XXX user strlen + size_t namelen; + retv.errno = u_strlen(name, &namelen); + + if(retv.errno) + return retv; + size_t argc = 0; size_t envc = 0; - // this probably should be checked in a safer way - - while(argv[argc]){ + while(1){ + char* tmp; + retv.errno = u_memcpy(&tmp, &argv[argc], sizeof(argv[argc])); + if(!tmp) + break; ++argc; } - - while(envp[envc]){ + + while(1){ + char* tmp; + retv.errno = u_memcpy(&tmp, &envp[envc], sizeof(envp[envc])); + if(!tmp) + break; ++envc; } @@ -66,28 +78,31 @@ syscallret syscall_execve(const char* name, char* const argv[], char* const envp return retv; } - strcpy(namebuff, name); // XXX user strcpy + int err = u_strcpy(namebuff, name); - int err = 0; + // XXX + // this is still not that safe, later make it even safer. for(uintmax_t arg = 0; arg < argc && err == 0; ++arg){ - size_t len = strlen(argv[arg]); // XXX user strlen + size_t len; + err = u_strlen(argv[arg], &len); argbuff[arg] = alloc(len+1); if(!argbuff[arg]){ err = ENOMEM; break; } - strcpy(argbuff[arg], argv[arg]); // XXX user strcpy + u_strcpy(argbuff[arg], argv[arg]); } for(uintmax_t env = 0; env < envc && err == 0; ++env){ - size_t len = strlen(envp[env]); // XXX user strlen + size_t len; + u_strlen(envp[env], &len); envbuff[env] = alloc(len+1); if(!envbuff[env]){ err = ENOMEM; break; } - strcpy(envbuff[env], envp[env]); // XXX user strcpy + u_strcpy(envbuff[env], envp[env]); } if(err){ diff --git a/src/sys/syscalls/fstat.c b/src/sys/syscalls/fstat.c index 684fc2b6..5bae2b0b 100644 --- a/src/sys/syscalls/fstat.c +++ b/src/sys/syscalls/fstat.c @@ -26,10 +26,14 @@ syscallret syscall_fstat(int ifd, stat* st){ return retv; } - memcpy(st, &fd->node->st, sizeof(stat)); // XXX user memcpy - fd_release(fd); + retv.errno = u_memcpy(st, &fd->node->st, sizeof(stat)); + + if(retv.errno) + return retv; + + retv.errno = 0; retv.ret = 0; diff --git a/src/sys/syscalls/fstatat.c b/src/sys/syscalls/fstatat.c index 229e4784..3ae04ad5 100644 --- a/src/sys/syscalls/fstatat.c +++ b/src/sys/syscalls/fstatat.c @@ -5,6 +5,7 @@ #include #include #include +#include // we don't care about flags yet @@ -17,11 +18,19 @@ syscallret syscall_fstatat(int ifd, char* path, stat* st, int flags){ return retv; } - size_t len = strlen(path); + size_t len; + + retv.errno = u_strlen(path, &len); + + if(retv.errno) + return retv; char buff[len+1]; - strcpy(buff, path); + retv.errno = u_strcpy(buff, path); + + if(retv.errno) + return retv; proc_t* proc = arch_getcls()->thread->proc; @@ -57,12 +66,11 @@ syscallret syscall_fstatat(int ifd, char* path, stat* st, int flags){ if(retv.errno) goto _fail; - - memcpy(st, &node->st, sizeof(stat)); // XXX user memcpy - vfs_close(node); - retv.ret = 0; + retv.errno = u_memcpy(st, &node->st, sizeof(stat)); + + retv.ret = retv.errno ? -1 : 0; _fail: diff --git a/src/sys/syscalls/getdirent.c b/src/sys/syscalls/getdirent.c index 9477b398..4150c9b3 100644 --- a/src/sys/syscalls/getdirent.c +++ b/src/sys/syscalls/getdirent.c @@ -3,6 +3,7 @@ #include #include #include +#include syscallret syscall_getdirent(int ifd, void* buff, size_t max_size){ syscallret retv; @@ -42,7 +43,12 @@ syscallret syscall_getdirent(int ifd, void* buff, size_t max_size){ retv.ret *= sizeof(dent_t); - memcpy(buff, kbuff, retv.ret); // XXX use user memcpy + retv.errno = u_memcpy(buff, kbuff, retv.ret); + + if(retv.errno){ + retv.ret = -1; + return retv; + } fd_release(fd); diff --git a/src/sys/syscalls/linkat.c b/src/sys/syscalls/linkat.c index 511ff22c..70d0ad36 100644 --- a/src/sys/syscalls/linkat.c +++ b/src/sys/syscalls/linkat.c @@ -5,6 +5,7 @@ #include #include #include +#include static int gettarget(fd_t** targ, dirnode_t** targnode, int ifd, proc_t* proc){ @@ -44,14 +45,29 @@ syscallret syscall_linkat(int srcdirfd, const char* srcpath, int tgtdirfd, const return retv; } - size_t srclen = strlen(srcpath); - size_t tgtlen = strlen(tgtpath); + size_t srclen; + size_t tgtlen; + + retv.errno = u_strlen(srcpath, &srclen); + if(retv.errno) + return retv; + + retv.errno = u_strlen(tgtpath, &tgtlen); + if(retv.errno) + return retv; char srcbuff[srclen+1]; char tgtbuff[tgtlen+1]; - strcpy(srcbuff, srcpath); - strcpy(tgtbuff, tgtpath); + + + retv.errno = u_strcpy(srcbuff, srcpath); + if(retv.errno) + return retv; + + retv.errno = u_strcpy(tgtbuff, tgtpath); + if(retv.errno) + return retv; proc_t* proc = arch_getcls()->thread->proc; diff --git a/src/sys/syscalls/mkdir.c b/src/sys/syscalls/mkdir.c index f0af2205..2c4b027e 100644 --- a/src/sys/syscalls/mkdir.c +++ b/src/sys/syscalls/mkdir.c @@ -3,6 +3,7 @@ #include #include #include +#include syscallret syscall_mkdirat(int dirfd, const char* pathname, mode_t mode){ syscallret retv; @@ -15,9 +16,20 @@ syscallret syscall_mkdirat(int dirfd, const char* pathname, mode_t mode){ proc_t* proc = arch_getcls()->thread->proc; - char path[strlen(pathname)+1]; + size_t len; + + retv.errno = u_strlen(pathname, &len); - strcpy(path, pathname); + if(retv.errno) + return retv; + + char path[len+1]; + + + retv.errno = u_strcpy(path, pathname); + + if(retv.errno) + return retv; dirnode_t* target; fd_t* targetfd; diff --git a/src/sys/syscalls/open.c b/src/sys/syscalls/open.c index fa350fe8..17f4c709 100644 --- a/src/sys/syscalls/open.c +++ b/src/sys/syscalls/open.c @@ -7,6 +7,8 @@ #include #include #include +#include +#include syscallret syscall_openat(int dirfd, const char* pathname, int flags, mode_t mode){ syscallret retv; @@ -16,14 +18,20 @@ syscallret syscall_openat(int dirfd, const char* pathname, int flags, mode_t mod retv.errno = EFAULT; return retv; } + + size_t len; - const char* name = alloc(strlen(pathname) + 1); // XXX use an user specific strlen func - if(!name){ - retv.errno = ENOMEM; + retv.errno = u_strlen(pathname, &len); + + if(retv.errno) return retv; - } - strcpy(name, pathname); // XXX use an user specific strcpy + char name[len+1]; + + retv.errno = u_strcpy(name, pathname); + + if(retv.errno) + return retv; proc_t* proc = arch_getcls()->thread->proc; @@ -34,7 +42,6 @@ syscallret syscall_openat(int dirfd, const char* pathname, int flags, mode_t mod if(err){ retv.errno = err; - free(name); return retv; } @@ -47,7 +54,6 @@ syscallret syscall_openat(int dirfd, const char* pathname, int flags, mode_t mod if(err){ retv.errno = err; - free(name); fd_release(fd); fd_free(&proc->fdtable, fd); return retv; @@ -106,7 +112,6 @@ syscallret syscall_openat(int dirfd, const char* pathname, int flags, mode_t mod fd_release(fd); - free(name); retv.errno = 0; retv.ret = ifd; @@ -122,7 +127,6 @@ syscallret syscall_openat(int dirfd, const char* pathname, int flags, mode_t mod fd_release(fd); fd_free(&proc->fdtable, fd); - free(name); return retv; }