Makes the log function & macros variadic

asm_env.c

 	if((res = malloc(sizeof(*res))) == NULL)
 	{
 		err = errno;
-		perror("Unable to allocate env");
+		asmsh_log_perror("Unable to allocate env");
 		errno = err;
 		return NULL;
 	}
 		if(errno)
 		{
 			err = errno;
-			perror("Unable to peektext in order to allign write");
+			asmsh_log_perror("Unable to peektext in order to allign write");
 			errno = err;
 			return -1;
 		}
 		if(ptrace(PTRACE_POKETEXT, env->pid, wr_addr, data) < 0)
 		{
 			err = errno;
-			perror("Unable to poketext in order to allign write");
+			asmsh_log_perror("Unable to poketext in order to allign write");
 			errno = err;
 			return -1;
 		}
 		if(ptrace(PTRACE_POKETEXT, env->pid, env->code_write_ptr, data) < 0)
 		{
 			err = errno;
-			perror("Unable to poketext");
+			asmsh_log_perror("Unable to poketext");
 			errno = err;
 			return -1;
 		}
 	if(ptrace(PTRACE_SINGLESTEP, env->pid, NULL, 0) < 0)
 	{
 		err = errno;
-		perror("Unable to ptrace singlestep");
+		asmsh_log_perror("Unable to ptrace singlestep");
 		goto err;
 	}
 	if(waitpid(env->pid, &env->status, 0) < 0)
 	{
 		err = errno;
-		perror("Unable to wait for child process to stop on step");
+		asmsh_log_perror("Unable to wait for child process to stop on step");
 		goto err;
 	}
 	if(status) { *status = env->status; }
 	if(ptrace(PTRACE_GETREGS, asmenv->pid, NULL, &(asmenv->regs)) < 0)
 	{
 		int err = errno;
-		perror("ptrace getregs error");
+		asmsh_log_perror("ptrace getregs error");
 		errno = err;
 		return -1;
 	}
 	if((env->pid = fork()) == -1)
 	{
 		err = errno;
-		perror("Unable to fork!");
+		asmsh_log_perror("Unable to fork!");
 		goto err_fork;
 	}
 	else if(env->pid == 0)
 	if(waitpid(env->pid, &wstatus, WUNTRACED) < 0)
 	{
 		err=errno;
-		perror("Unable to wait for child process");
+		asmsh_log_perror("Unable to wait for child process");
 		goto err;
 	}
 	if(!WIFSTOPPED(wstatus))
 	if(ptrace(PTRACE_ATTACH, env->pid, 0, 0) == -1)
 	{
 		err=errno;
-		perror("Unable to attach to child process");
+		asmsh_log_perror("Unable to attach to child process");
 		goto err;
 	}
 
 	if(waitpid(env->pid, &wstatus, 0) < 0)
 	{
 		err=errno;
-		perror("Unable to wait for child process");
+		asmsh_log_perror("Unable to wait for child process");
 		goto err;
 	}
 	if(!WIFSTOPPED(wstatus))
 	if(ptrace(PTRACE_SETOPTIONS, env->pid, NULL, PTRACE_O_TRACEEXEC) < 0)
 	{
 		err = errno;
-		perror("ptrace setoptions failed");
+		asmsh_log_perror("ptrace setoptions failed");
 		goto err;
 	}
 
 		if(ptrace(PTRACE_CONT, env->pid, NULL, 0) < 0)
 		{
 			err = errno;
-			perror("ptrace CONT failed after attach");
+			asmsh_log_perror("ptrace CONT failed after attach");
 			goto err;
 		}
 
 		if(waitpid(env->pid, &wstatus, 0) < 0)
 		{
 			err = errno;
-			perror("Unable to wait for child process to stop after exec");
+			asmsh_log_perror("Unable to wait for child process to stop after exec");
 			goto err;
 		}
 		if(wstatus >> 8 != (SIGTRAP | (PTRACE_EVENT_EXEC<<8)) && \
 		if(ptrace(PTRACE_SYSCALL, env->pid, NULL, 0) < 0)
 		{
 			err = errno;
-			perror("Unable to ptrace syscall");
-			dprintf(2, "ptrace syscall failed on %d time\n", i+1);
+			asmsh_log_error("Unable to ptrace syscall on %dth time : %s",
+					i+1, strerror(errno));
 			goto err;
 		}
 		if(waitpid(env->pid, &wstatus, 0) < 0)
 		{
 			err = errno;
-			perror("Unable to wait for child process to stop on syscall");
+			asmsh_log_perror("Unable to wait for child process to stop on syscall");
 			goto err;
 		}
 		if(wstatus != 1407 && wstatus != 263551)
 	{
 		int err = errno;
 		perror("Unable to strdupa asmsh childpath :/");
+		//asmsh_log_perror("Unable to strdupa asmsh childpath :/");
+		///! @todo dump logs before exit !
 		exit(err?err:-1);
 	}
 
 	execve(childpath, argv, envp);
 	int err = errno;
 	perror("Unable to execve");
+	//asmsh_log_perror("Child is unable to execve");
+	///! @todo dump logs before exit !
 	exit(err?err:-1);
 }
 
 static char *asmsh_env_tmpexec()
 {
 	char *ret = strdup("asmsh_child_XXXXXXXXX");
+	int err;
 	if(!ret)
 	{
-		perror("getting a temporary file name");
+		err = errno;
+		asmsh_log_perror("getting a temporary file name");
+		errno = err;
 		return NULL;
 	}
 	int tmpfd = mkstemp(ret);
 	if(tmpfd < 0)
 	{
-		perror("Unable to mk temporary file");
+		err = errno;
+		asmsh_log_perror("Unable to mk temporary file");
+		errno = err;
 		return NULL;
 	}
 	const int sz = &_binary_child_end - &_binary_child_start;
 	int rsz = write(tmpfd, &_binary_child_start, sz);
 	if(rsz<sz)
 	{
-		perror("Unable to write the child executable");
+		// TODO : differenciate incomplete write & error !
+		err = errno;
+		asmsh_log_perror("Unable to write the child executable");
 		free(ret);
+		errno = err;
 		return NULL;
 	}
 	fchmod(tmpfd, 0555);

asmsh.c

 
 	if(asmsh_init(&sh, CHILD_EXEC_PATH))
 	{
-		perror("Unable to init shell");
+		asmsh_log_error("Unable to init shell : %s", strerror(errno));
 		asmsh_logger_dprint(2, logger);
 		return 1;
 	}

logger.c

 }
 
 int asmsh_log(asmsh_logger_t *logger, asmsh_loglevel_t lvl, const char caller[],
-		const char *msg)
+		const char *msg, ...)
 {
 	if(!logger)
 	{
 	}
 	if(lvl < logger->min_level) { return 0; }
 
+	va_list ap;
 	size_t caller_len, msg_len, total_len;
 
 	caller_len = strlen(caller);
-	msg_len = strlen(msg);
-	total_len = msg_len  + caller_len + 2 + sizeof(asmsh_log_msg_t);
+	va_start(ap, msg);
+	msg_len = vsnprintf(NULL, 0, msg, ap) + 1;
+	va_end(ap);
+	total_len = msg_len  + caller_len + 1 + sizeof(asmsh_log_msg_t);
 
 	if(logger->msgs_alloc <= logger->msgs_sz + total_len)
 	{
 	logger->nxt->msg = logger->nxt->caller + caller_len + 1;
 
 	strncpy(logger->nxt->caller, caller, caller_len+1);
-	strncpy(logger->nxt->msg, msg, msg_len+1);
+	va_start(ap, msg);
+	vsnprintf(logger->nxt->msg, msg_len, msg, ap);
+	va_end(ap);
 
 	logger->nxt->nxt = (asmsh_log_msg_t*)((char*)logger->nxt->msg+total_len);
 	logger->nxt = logger->nxt->nxt;

logger.h

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdarg.h>
 #include <time.h>
 
 ///! TODO varargs macro & log functions, perror etc.
-#define asmsh_log_trace(msg) \
-	asmsh_log(_default_logger, ASMSH_TRACE, __FUNCTION__, msg)
-#define asmsh_log_debug(msg) \
-	asmsh_log(_default_logger, ASMSH_DEBUG, __FUNCTION__, msg)
-#define asmsh_log_info(msg) \
-	asmsh_log(_default_logger, ASMSH_INFO, __FUNCTION__, msg)
-#define asmsh_log_warning(msg) \
-	asmsh_log(_default_logger, ASMSH_WARN, __FUNCTION__, msg)
-#define asmsh_log_error(msg) \
-	asmsh_log(_default_logger, ASMSH_ERR, __FUNCTION__, msg)
-#define asmsh_log_fatal(msg) \
-	asmsh_log(_default_logger, ASMSH_FATAL, __FUNCTION__, msg)
+#define asmsh_log_trace(msg_args...) \
+	asmsh_log(_default_logger, ASMSH_TRACE, __FUNCTION__, msg_args)
+#define asmsh_log_debug(msg_args...) \
+	asmsh_log(_default_logger, ASMSH_DEBUG, __FUNCTION__, msg_args)
+#define asmsh_log_info(msg_args...) \
+	asmsh_log(_default_logger, ASMSH_INFO, __FUNCTION__, msg_args)
+#define asmsh_log_warning(msg_args...) \
+	asmsh_log(_default_logger, ASMSH_WARN, __FUNCTION__, msg_args)
+#define asmsh_log_error(msg_args...) \
+	asmsh_log(_default_logger, ASMSH_ERR, __FUNCTION__, msg_args)
+#define asmsh_log_fatal(msg_args...) \
+	asmsh_log(_default_logger, ASMSH_FATAL, __FUNCTION__, msg_args)
+#define asmsh_log_perror(msg) \
+	asmsh_log_error("%s : %s", msg, strerror(errno));
 
 #define ASMSH_LOG_BUFFER_ALLOC 4096
 
 }
 
 
-int asmsh_log(asmsh_logger_t *logger, asmsh_loglevel_t lvl, const char caller[], const char *msg);
+int asmsh_log(asmsh_logger_t *logger, asmsh_loglevel_t lvl, const char caller[], const char *msg, ...);
 
 
 const char * asmsh_loglevel_name(asmsh_loglevel_t lvl);