syscalls: make a bunch of system calls use the new user memory operations

src/sys/syscalls/accept.c

@@ -3,6 +3,7 @@
 #include <kernel/fd.h>
 #include <arch/cls.h>
 #include <arch/spinlock.h>
+#include <kernel/ustring.h>
 
 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;
 	

src/sys/syscalls/chdir.c

@@ -6,6 +6,7 @@
 #include <arch/cls.h>
 #include <kernel/sched.h>
 #include <sys/stat.h>
+#include <kernel/ustring.h>
 
 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;
 

src/sys/syscalls/chmodat.c

@@ -4,6 +4,7 @@
 #include <arch/cls.h>
 #include <kernel/fd.h>
 #include <kernel/sched.h>
+#include <kernel/ustring.h>
 
 // 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;
 

src/sys/syscalls/chroot.c

@@ -3,6 +3,7 @@
 #include <kernel/sched.h>
 #include <kernel/vmm.h>
 #include <arch/cls.h>
+#include <kernel/ustring.h>
 
 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;
 

src/sys/syscalls/clock_get.c

@@ -3,6 +3,7 @@
 #include <kernel/vmm.h>
 #include <time.h>
 #include <errno.h>
+#include <kernel/ustring.h>
 
 #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;

src/sys/syscalls/execve.c

@@ -9,6 +9,7 @@
 #include <kernel/elf.h>
 #include <arch/cls.h>
 #include <arch/interrupt.h>
+#include <kernel/ustring.h>
 
 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){

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;
 

src/sys/syscalls/fstatat.c

@@ -5,6 +5,7 @@
 #include <kernel/vfs.h>
 #include <arch/spinlock.h>
 #include <string.h>
+#include <kernel/ustring.h>
 
 // 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:
 	

src/sys/syscalls/getdirent.c

@@ -3,6 +3,7 @@
 #include <arch/cls.h>
 #include <sys/stat.h>
 #include <kernel/vmm.h>
+#include <kernel/ustring.h>
 
 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);
 

src/sys/syscalls/linkat.c

@@ -5,6 +5,7 @@
 #include <kernel/fd.h>
 #include <kernel/sched.h>
 #include <string.h>
+#include <kernel/ustring.h>
 
 
 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;
 

src/sys/syscalls/mkdir.c

@@ -3,6 +3,7 @@
 #include <arch/cls.h>
 #include <string.h>
 #include <sys/types.h>
+#include <kernel/ustring.h>
 
 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;

src/sys/syscalls/open.c

@@ -7,6 +7,8 @@
 #include <errno.h>
 #include <kernel/alloc.h>
 #include <stddef.h>
+#include <string.h>
+#include <kernel/ustring.h>
 
 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;
 
 }