Adds dummy logger + tests and starts the compile

Makefile.am

@@ -1,7 +1,7 @@
 bin_PROGRAMS = asmsh child
-noinst_LIBRARIES = libasmsh.a
+noinst_LIBRARIES = libcheck_asmsh.a
 
-libasmsh_a_SOURCES = mmap_parse.c
+libcheck_asmsh_a_SOURCES = mmap_parse.c compile.c logger.c
 
 asmsh_SOURCES = asmsh.c $(libasmsh_a_SOURCES)
 child_SOURCES = child.s

compile.c

@@ -0,0 +1,595 @@
+#include "compile.h"
+
+static void _child_cleanup(asmsh_asmc_child_t *child);
+
+asmsh_asmc_ctx_t* asmsh_asmc_ctx_default()
+{
+	char * const args[] = ASMSH_COMPILE_ARGS;
+	return asmsh_asmc_ctx(ASMSH_COMPILE_AS, ASMSH_COMPILE_OBJ, args, 1, NULL);
+}
+
+
+asmsh_asmc_ctx_t* asmsh_asmc_ctx(const char *progname, \
+		const char *result_path, char* const args[], int pre_spawn,
+		struct timeval *ctimeout)
+{
+
+	const struct timeval default_timeout = {.tv_sec = 1, .tv_usec = 250000};
+	asmsh_asmc_ctx_t *res;
+
+	int argc; // args count
+	int errno_bck; // errno will take this value in err labels
+	int tmpfd;
+	char *temp_name;
+
+	int i;
+	char * const *ptr;
+
+	if((res = malloc(sizeof(*res))) == NULL)
+	{
+		errno_bck =  errno;
+		goto err_alloc_res;
+	}
+	bzero(res, sizeof(res));
+
+	if(asmsh_asmc_buildarg(progname, result_path, args,
+			&res->args, &res->progname, &res->respath) < 0)
+	{
+		errno_bck = errno;
+		goto err_buildarg;
+	}
+
+	res->child.pid = -1;
+	res->pre_spawn = pre_spawn?1:0;
+	if(res->pre_spawn)
+	{
+		asmsh_asmc_spawn(res);
+	}
+
+	memcpy(&(res->ctimeout), ctimeout?ctimeout:&default_timeout,
+			sizeof(struct timeval));
+
+	free(temp_name);
+	return res;
+
+err_buildarg:
+	free(res);
+err_alloc_res:
+	errno = errno_bck;
+	return NULL;
+}
+
+
+void asmsh_asmc_ctx_free(asmsh_asmc_ctx_t *ctx)
+{
+	pid_t cpid;
+	int wstatus;
+	char **ptr;
+
+	if(ctx->child.pid > 0)
+	{
+		cpid = waitpid(ctx->child.pid, &wstatus, WNOHANG);
+		if(cpid != -1 && cpid != 0)
+		{
+			if(WCOREDUMP(wstatus))
+			{
+				dprintf(2, "Child %d segfault\n", cpid);
+				ctx->child.pid = 0;
+			}
+			else if(WIFEXITED(wstatus))
+			{
+				if(WEXITSTATUS(wstatus))
+				{
+					dprintf(2, "Child exited with status %d\n",
+							WEXITSTATUS(wstatus));
+				}
+				ctx->child.pid = 0;
+			}
+		}
+		if(ctx->child.pid > 0)
+		{
+			if(kill(ctx->child.pid, SIGKILL) == -1)
+			{
+				perror("Unable to kill child process");
+			}
+		}
+		ctx->child.pid = 0;
+		close(ctx->child.pipe_stdin);
+	}
+	if(ctx->respath)
+	{
+		unlink(ctx->respath);
+	}
+	
+	for(ptr = ctx->args; *ptr; ptr++) { free(*ptr); }
+	free(ctx->args);
+	free(ctx);
+}
+
+
+int asmsh_asmc_compile(asmsh_asmc_ctx_t *ctx, const char *instr, asmsh_bytecode_t *res)
+{
+	char *reason = NULL;
+	pid_t wpid;
+	int wstatus;
+
+	if(asmsh_asmc_syntax(instr, &reason) == -1)
+	{
+		dprintf(2, "Syntax error %s : '%s'\n",
+				reason, instr);
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(!ctx->pre_spawn && asmsh_asmc_spawn(ctx) == -1)
+	{
+		return -1;
+	}
+
+	wpid = waitpid(ctx->child.pid, &wstatus, WNOHANG);
+	if(wpid == -1)
+	{
+		perror("Unable to check child state");
+		ctx->child.pid = -1;
+		_child_cleanup(&ctx->child);
+		return -1;
+	}
+	else if (wpid)
+	{
+		if(WCOREDUMP(wstatus))
+		{
+			dprintf(2, "Child %d segfault\n", ctx->child.pid);
+		}
+		else if (WIFEXITED(wstatus))
+		{
+			dprintf(2, "Child %d exited with status %d\n",
+					ctx->child.pid,
+					WEXITSTATUS(wstatus));
+		}
+		else
+		{
+			dprintf(2, "Child %d in unknown status %d\n",
+					ctx->child.pid, wstatus);
+			_child_cleanup(&ctx->child);
+		}
+		return -1;
+	}
+
+
+	return asmsh_asmc_compile_unsafe(ctx, instr, res);
+}
+
+int asmsh_asmc_compile_unsafe(asmsh_asmc_ctx_t *ctx, const char *_instr,
+		asmsh_bytecode_t *res)
+{
+	int ret;
+	size_t instr_sz;
+	pid_t wpid;
+	int wstatus, sigfd;
+	sigset_t sigfdmask, oldmask;
+	fd_set sigset;
+	struct timeval stimeout;
+	char *instr;
+
+	sigemptyset(&sigfdmask);
+	sigaddset(&sigfdmask, SIGCHLD);
+	sigfillset(&sigfdmask);
+
+	/// TODO : early (context ?) sigprocmask ?
+	if((sigprocmask(SIG_BLOCK, &sigfdmask, &oldmask) == -1))
+	{
+		perror("Unable to sigmask");
+		goto err_early;
+	}
+	if((sigfd = signalfd(-1, &sigfdmask, SFD_NONBLOCK)) == -1)
+	{
+		perror("Unable to sigfd");
+		goto err_sigfd;
+	}
+
+
+	instr_sz = strlen(_instr);
+	instr = alloca(instr_sz+1);
+	memcpy(instr, _instr, instr_sz);
+	instr[instr_sz] = '\n';
+	instr[instr_sz+1] = '\0';
+	instr_sz++;
+
+	ret = write(ctx->child.pipe_stdin, instr, instr_sz);
+	if(ret < 0)
+	{
+		perror("Unable to send instruction to child process");
+		goto err;
+	}
+	else if(ret < instr_sz)
+	{
+		asmsh_log_error("Unable to write the whole instruction in one write, bailout !\n");
+		close(ctx->child.pipe_stdin);
+		goto err;
+	}
+	close(ctx->child.pipe_stdin);
+	close(ctx->child.pipe_stderr);
+
+	FD_ZERO(&sigset);
+	FD_SET(sigfd, &sigset);
+
+	stimeout = ctx->ctimeout;
+	do
+	{
+		if(select(sigfd+1, &sigset, NULL, NULL, &ctx->ctimeout) == 0)
+		{
+			//compilation timeout t_t
+			asmsh_log_error("Compilation timeout");
+			goto err;
+		}
+
+		wpid = waitpid(ctx->child.pid, &wstatus, 0);
+	}while(!wpid);
+
+	if(wpid == -1)
+	{
+		perror("Unable to wait for as to exit");
+		goto err_stderr;
+	}
+	if(WCOREDUMP(wstatus))
+	{
+		asmsh_log_error("as segfault will compiling");
+		goto err_stderr;
+	}
+	if(!WIFEXITED(wstatus))
+	{
+		asmsh_log_error("as didn't exited");
+		goto err_stderr;
+	}
+	if(WEXITSTATUS(wstatus))
+	{
+		asmsh_log_error("GNU as did not exited with 0 status");
+		goto err_stderr;
+	}
+	if((sigprocmask(SIG_BLOCK, &oldmask, NULL) == -1))
+	{
+		perror("Unable to restore sigmask");
+		goto err;
+	}
+
+	ctx->child.pid = 0;
+	if(ctx->pre_spawn && asmsh_asmc_spawn(ctx) == -1)
+	{
+		perror("Unable to pre-spawn");
+		goto err;
+	}
+	
+	return asmh_asmc_bytecode_from_obj(ctx->respath, res);
+
+
+err_stderr:
+	// TODO read stderr & log it
+err:
+	close(sigfd);
+err_sigfd:
+	sigprocmask(SIG_BLOCK, &oldmask, NULL);
+err_early:
+	_child_cleanup(&ctx->child);
+	return -1;
+}
+
+int asmsh_asmc_spawn(asmsh_asmc_ctx_t *ctx)
+{
+	int fpid;
+	int pipes[2][2];
+	int err;
+	int i;
+
+	if(ctx->child.pid > 0)
+	{
+		errno = EUCLEAN;
+		return -1;
+	}
+
+	for(i=0; i<2; i++)
+	{
+		if(pipe(pipes[i]) == -1)
+		{
+			goto err_pipe;
+		}
+	}
+	fpid = fork();
+	if(fpid == -1)
+	{
+		err = errno;
+		goto err_fork;
+	}
+	else if (fpid == 0)
+	{
+		asmsh_asmc_child(pipes, ctx->progname, ctx->args);
+	}
+
+	close(pipes[0][0]);
+	close(pipes[1][1]);
+
+	ctx->child.pid = fpid;
+	ctx->child.pipe_stdin = pipes[0][1];
+	ctx->child.pipe_stderr = pipes[1][0];
+
+	return 0;
+
+err_fork:
+	i=1;
+err_pipe:
+	for(i; i>=0; i--)
+	{
+		close(pipes[i][0]);
+		close(pipes[i][1]);
+	}
+	errno = err;
+	return -1;
+}
+
+
+void asmsh_asmc_child(const int std_pipes[2][2], const char *progname, char* const args[])
+{
+	close(std_pipes[0][1]);
+	if(dup2(std_pipes[0][0], 0) < 0)
+	{
+		perror("Unable to pipe stdin");
+		exit(1);
+	}
+	execvp(progname, args);
+	perror("execvp failed");
+	close(std_pipes[0][0]);
+	exit(2);
+}
+
+
+int asmsh_asmc_syntax(const char* instr, char **reason)
+{
+
+#define explain(ptr, reason){\
+if(ptr) {\
+	*ptr = strdup(reason);\
+	if(!*ptr) { \
+		int e = errno;\
+		perror("Unable to strdup to explain syntax error");\
+		errno=e;return -1;}}}
+	
+	const unsigned char *ptr;
+
+	switch(*instr)
+	{
+		case '.':
+			explain(reason, "Cannot starts with '.'");
+			goto err;
+		default:
+			break;
+	}
+
+	ptr = instr;
+	while(*ptr)
+	{
+		switch(*ptr)
+		{
+			case '\n':
+			case ';':
+			case '#':
+				explain(reason, "Contains forbidden char");
+				goto err;
+			default:
+				break;
+		}
+		if(*ptr < 0x20 || *ptr > 0x7E)
+		{
+			explain(reason, "Contains char in unexpected value range");
+			goto err;
+		}
+		ptr++;
+	}
+
+	*reason = NULL;
+	errno = 0;
+	return 0;
+err:
+	errno = EINVAL;
+	return -1;
+#undef explain
+}
+
+static void _child_cleanup(asmsh_asmc_child_t *child)
+{
+	if(child->pid > 0)
+	{
+		kill(child->pid, SIGKILL);
+	}
+	if(child->pipe_stdin > 0)
+	{
+		close(child->pipe_stdin);
+	}
+	if(child->pipe_stderr > 0)
+	{
+		close(child->pipe_stderr);
+	}
+	child->pid = child->pipe_stdin = child->pipe_stderr = -1;
+}
+
+
+int asmh_asmc_bytecode_from_obj(const char *objfile, asmsh_bytecode_t *bytecode)
+{
+	/*TODO parse ELF header instead of harcoded addr ?
+	  	at least check if the object file has the expected
+	  	size for the whole file.
+	   Header parsing is better in case the ELF organisation is
+	   platform/version dependent ?
+	*/
+	// ELF 64 constants
+	const int bytecode_sz_off = 0x138;
+	const int bytecode_sz_sz = 4;
+	const int bytecode_off = 0x40;
+
+	int fd, err;
+	off_t off;
+	ssize_t rret;
+	unsigned int bytecode_sz;
+
+	if((fd = open(objfile, O_RDONLY)) < 0)
+	{
+		perror("Unable to open bytecode's object file");
+		return -1;
+	}
+
+	if((off = lseek(fd, bytecode_sz_off, SEEK_SET)) != bytecode_sz_off)
+	{
+		/// TODO check off
+		perror("Unable to seek at bytecode size offset");
+		err = errno;
+		goto err;
+	}
+
+	if((rret = read(fd, &bytecode_sz, bytecode_sz_sz)) != bytecode_sz_sz)
+	{
+		err = errno;
+		if(rret < 0)
+		{
+			perror("Unable to read bytecode size");
+		}
+		else
+		{
+			dprintf(2, "Unable to read the 4 bytes of the bytecode size\n");
+			err = ENODATA;
+		}
+		goto err;
+	}
+
+	if(bytecode_sz == 0)
+	{
+		dprintf(2, "Null bytecode size");
+		err = ENODATA;
+		goto err;
+	}
+	if(bytecode_sz > sizeof(bytecode->bytes))
+	{
+		dprintf(2, "Bytecode size invalid, too many bytes (%d)\n",
+				bytecode_sz);
+		err = ENOBUFS;
+		goto err;
+	}
+	if((off = lseek(fd, bytecode_off, SEEK_SET)) != bytecode_off)
+	{
+		/// TODO check off
+		perror("Unable to seek at bytecode offset");
+		err = errno;
+		goto err;
+	}
+
+	bytecode->size = bytecode_sz;
+	if((rret = read(fd, bytecode->bytes, bytecode_sz)) != bytecode_sz)
+	{
+		err = errno;
+		if(rret < 0)
+		{
+			perror("Unable to read bytecode");
+		}
+		else
+		{
+			dprintf(2, "Unable to read the %d bytes of bytecode\n");
+			err = ENODATA;
+		}
+		goto err;
+	}
+
+	close(fd);
+	return 0;
+
+err:
+	close(fd);
+	errno = err;
+	return -1;
+}
+
+
+int asmsh_asmc_buildarg(const char* progname, const char *result_tpl, \
+		char *const args_in[],
+		char ***args_o, char **progname_o, char **respath_o)
+{
+	int argc, tmpfd, err, i;
+	char *tempname;
+	char* const *args_ptr;
+
+	if((tempname = strdupa(result_tpl)) == NULL)
+	{
+		return -1;
+	}
+	if((tmpfd = mkstemp(tempname)) == -1)
+	{
+		err = errno;
+		perror("Unable to create temporary result .o file");
+		errno = err;
+		return -1;
+	}
+	close(tmpfd);
+
+	args_ptr = args_in;
+	argc = 0;
+	for(i=0;i<2;i++) // here we overflow if args_in was malformed
+	{
+		while(*args_ptr) { args_ptr++; argc++; }
+		args_ptr++;
+		argc++;
+	}
+	if((*args_o = malloc(sizeof(char*)*(argc))) == NULL)
+	{
+		err = errno;
+		perror("unable to allocate compiler args array");
+		goto err_malloc;
+	}
+
+	if(((*args_o)[0] = strdup(progname)) == NULL)
+	{
+		err = errno;
+		perror("unable to allocate compiler first argument");
+		goto err_progname;
+	}
+	*progname_o = (*args_o)[0];
+	*respath_o = NULL;
+
+	for(i=1; i<argc-1; i++)
+	{
+		char *const *tocopy;
+		if(args_in[i])
+		{
+			tocopy = &(args_in[i]);
+		}
+		else
+		{
+			tocopy = &tempname;
+		}
+		(*args_o)[i] = strdup(*tocopy);
+		if(!(*args_o)[i])
+		{
+			perror("Unable to copy compiler args");
+			goto err_dupargs;
+		}
+		if(!args_in[i])
+		{
+			*respath_o = (*args_o)[i];
+		}
+	}
+	(*args_o)[argc-1] = NULL;
+
+	return 0;
+
+err_dupargs:
+	i--;
+	while(i>0)
+	{
+		free((*args_o)[i]);
+		i--;
+	}
+
+err_progname:
+	free(args_o);
+	*args_o = NULL;
+err_malloc:
+	unlink(tempname);
+	errno = err;
+	return -1;
+}
+

compile.h

@@ -0,0 +1,149 @@
+#ifndef ASMSH_COMPILE_H
+#define ASMSH_COMPILE_H
+#include "config.h"
+
+#include <alloca.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/select.h>
+#include <sys/signalfd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "logger.h"
+
+/** Define the default assembler (GNU as) */
+#define ASMSH_COMPILE_AS "as"
+#define ASMSH_COMPILE_ARGS {"", "-O2", "-f", "-ad", "-o", NULL, "-c", "-", NULL}
+#define ASMSH_COMPILE_OBJ "/tmp/asmsh_jit_XXXXXX"
+
+typedef struct asmsh_asmc_ctx_s asmsh_asmc_ctx_t;
+typedef struct asmsh_asmc_child_s asmsh_asmc_child_t;
+typedef struct asmsh_bytecode_s asmsh_bytecode_t;
+
+struct asmsh_asmc_child_s
+{
+	/** Compiler subprocess PID (waiting code on piped STDIN) */
+	pid_t pid;
+	/** Write endpoint of subprocess's piped STDIN  */
+	int pipe_stdin;
+	/** Read endpoint of subprocess's piped STDERR */
+	int pipe_stderr;
+};
+
+struct asmsh_asmc_ctx_s
+{
+	/** NULL terminated list of args for child subprocess,
+	 * arg[0] is progname */
+	char **args;
+	/** Points on args[0] */
+	char *progname;
+	/** Points on the result path argument (value of -o) */
+	char *respath;
+
+	/** Compilation timeout  */
+	struct timeval ctimeout;
+
+	/** A child, that can be spawn in advance */
+	asmsh_asmc_child_t child;
+
+	/** If true pre spawn childs */
+	char pre_spawn;
+};
+
+/** Compilation result, 1 instruction bytecode */
+struct asmsh_bytecode_s
+{
+	/** Instruction bytes */
+	unsigned char bytes[15];
+	/** Instruction size */
+	char size;
+};
+
+/**
+ * Check if :
+ * - contains no ';' nor '#' nor '\n'
+ * - only contains char in range [0x20 .. 0x7E]
+ * - do not begins by '.'
+ *
+ * @param char* The instruction to pre-check
+ * @param char** If not null contains a reason on failure (and must be freed)
+ * @return 0 if instr has a valid syntax else -1
+ */
+int asmsh_asmc_syntax(const char* instr, char **reason);
+
+/** Return a default compilation context */
+asmsh_asmc_ctx_t* asmsh_asmc_ctx_default();
+
+/** Return a new compilation context
+ * @param char* The assembler name/path
+ * @param char* The result path for the compiled obj as mkstemp(3) template
+ * @param char*[] The assembler list of arguments, without the argv[0] progname and with NULL as a placeholder for the result path
+ * @param int If 0 no child are pre-spawned, else a child is spawned in returned context
+ * @param struct timeval* Compilation timeout
+ */
+asmsh_asmc_ctx_t* asmsh_asmc_ctx(const char *progname, \
+		const char *result_path, char* const args[], int pre_spawn,
+		struct timeval *ctimeout);
+
+/** Free all compile context resources */
+void asmsh_asmc_ctx_free(asmsh_asmc_ctx_t *ctx);
+
+/** Compile an instruction
+ * @param asmsh_asmc_ctx_t* The context
+ * @param const char* The instruction to compile
+ * @param asmsh_bytecode_t* Pointer on the result struct
+ * @return 0 if ok else -1  on failure with errno set
+ */
+int asmsh_asmc_compile(asmsh_asmc_ctx_t *ctx, const char *instr, asmsh_bytecode_t *res);
+
+int asmsh_asmc_compile_unsafe(asmsh_asmc_ctx_t *ctx, const char *_instr, asmsh_bytecode_t *res);
+
+/** Spawn an assembler process child process
+ * @return 0 if no error else -1
+ */
+int asmsh_asmc_spawn(asmsh_asmc_ctx_t *ctx);
+
+/**Child process main function
+ * @param int[2][2] The pipes for stdin and stderr in this order
+ * @param *char The path/name of the assembler executable
+ * @param *char[] The NULL terminated list of arguments for the assembler
+ * @return NEVER
+ */
+void asmsh_asmc_child(const int std_pipes[2][2], const char *progname, char* const args[]);
+
+/** Given an object file, extract the "bytecode"
+ *
+ * Copy the .text segment of an ELF file
+ * @param const char* the object file path
+ * @param asmsh_bytecode_t* The result bytecode
+ *
+ * @return 0 if no error else -1
+ */
+int asmh_asmc_bytecode_from_obj(const char *objfile, asmsh_bytecode_t *bytecode);
+
+/** Forge compiler arguments.
+ *
+ * The constructed arguments list will be allocated in args_o.
+ * Put progname as first argument, result_tpl will replace the first NULL encountered
+ * in the args_in array. args_in is an array of argument, that will be copied in
+ * args_o. 
+ * @param const char* The compiler name/path
+ * @param const char* An mkstemp() file template
+ * @param char *const[] The NULL terminated list of arguments, the first will
+ * 	be replaced by the progname value. And the first encountered NULL will
+ * 	be affected to the temporary result file (from result_tpl)
+ * @param char** The resulting args
+ * @return 0 if no error else -1
+ */
+int asmsh_asmc_buildarg(const char* progname, const char *result_tpl, \
+		char *const args_in[],
+		char ***args_o, char **progname_o, char **respath_o);
+
+
+#endif

config.h.in

@@ -9,6 +9,9 @@
 /* Define to 1 if you have the `fork' function. */
 #undef HAVE_FORK
 
+/* Define to 1 if you have the `gmtime_r' function. */
+#undef HAVE_GMTIME_R
+
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
 
@@ -38,8 +41,8 @@
 /* Define to 1 if you have the <string.h> header file. */
 #undef HAVE_STRING_H
 
-/* Define to 1 if you have the `strtoull' function. */
-#undef HAVE_STRTOULL
+/* Define to 1 if you have the `strtoull,' function. */
+#undef HAVE_STRTOULL_
 
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #undef HAVE_SYS_STAT_H

configure.ac

@@ -62,7 +62,7 @@ AC_TYPE_SIZE_T
 AC_FUNC_FORK
 AC_FUNC_MALLOC
 AC_FUNC_REALLOC
-AC_CHECK_FUNCS([bzero strtoull])
+AC_CHECK_FUNCS([bzero strtoull, gmtime_r])
 
 AC_CONFIG_FILES([Makefile tests/Makefile])
 AC_OUTPUT

logger.c

@@ -0,0 +1,229 @@
+#include "logger.h"
+
+asmsh_logger_t *_default_logger=NULL;
+
+int asmsh_logger_setup(asmsh_logger_t *logger)
+{
+	if(logger)
+	{
+		_default_logger = logger;
+		return 0;
+	}
+	_default_logger = asmsh_logger_new(ASMSH_WARN);
+
+	return (_default_logger == NULL) ? -1 : 0;
+}
+
+
+asmsh_logger_t* asmsh_logger_new(asmsh_loglevel_t min_level)
+{
+	asmsh_logger_t *res;
+	int err;
+
+	if((res = malloc(sizeof(*res))) == NULL)
+	{
+		err = errno;
+		dprintf(2, "Error allocating logger");
+		errno = err;
+		return NULL;
+	}
+	if((res->msgs = malloc(ASMSH_LOG_BUFFER_ALLOC)) == NULL)
+	{
+		err = errno;
+		dprintf(2, "Error allocating logger's buffer");
+		goto err_msgs;
+	}
+	res->min_level = min_level;
+	res->msgs_sz = 0;
+	res->msgs_alloc = ASMSH_LOG_BUFFER_ALLOC;
+	res->nxt = res->msgs;
+
+	return res;
+
+err_msgs:
+	free(res);
+	errno = err;
+	return NULL;
+}
+
+
+void asmsh_logger_free(asmsh_logger_t* logger)
+{
+	if(logger->msgs) { free(logger->msgs); }
+	free(logger);
+}
+
+int asmsh_logger_dprint(int fd, asmsh_logger_t *logger)
+{
+	const int BUF_ALLOC = 4096;
+	char *buf;
+	int bufsz, ret, res;
+	asmsh_log_msg_t *cur;
+
+	if((buf = malloc(BUF_ALLOC)) == NULL)
+	{
+		return -1;
+	}
+	bufsz = BUF_ALLOC;
+
+	cur = (asmsh_log_msg_t*)logger->msgs;
+	res = 0;
+	while(cur != logger->nxt)
+	{
+		ret = asmsh_log_default_fmt(cur, buf, bufsz);
+		if(ret < 0)
+		{
+			perror("Unable to format log message");
+			continue;
+		}
+		else if (ret == BUF_ALLOC)
+		{
+			buf[BUF_ALLOC-1] = '\0';
+			for(int i=0; i<3; i++)
+			{
+				buf[BUF_ALLOC-(2+i)] = '.';
+			}
+		}
+		res += dprintf(fd, buf); /// TODO check result
+		cur = cur->nxt;
+	}
+	free(buf);
+	return res;
+}
+
+int asmsh_logger_strdup(asmsh_logger_t *logger, char **result, size_t *res_sz)
+{
+	const int BUF_ALLOC = 4096;
+	size_t buf_sz;
+	asmsh_log_msg_t *cur;
+	char *buf_ptr;
+	int ret;
+
+	*res_sz = 0;
+	buf_ptr = *result = malloc(buf_sz = BUF_ALLOC);
+	if(*result == NULL)
+	{
+		perror("Enable to allocate buffer for log messages");
+		return -1;
+	}
+
+	cur = (asmsh_log_msg_t*)logger->msgs;
+	while(cur != logger->nxt)
+	{
+		ret = asmsh_log_default_fmt(cur, buf_ptr, buf_sz - *res_sz);
+		if(ret == (*res_sz - buf_sz))
+		{
+			buf_sz += BUF_ALLOC;
+			void *tmp = realloc(*result, buf_sz);
+		}
+		else
+		{
+			*res_sz += ret;
+			cur = cur->nxt;
+		}
+	}
+}
+
+int asmsh_log(asmsh_logger_t *logger, asmsh_loglevel_t lvl, const char caller[],
+		const char *msg)
+{
+	if(!logger)
+	{
+		logger = _default_logger = asmsh_logger_new(ASMSH_TRACE);
+	}
+	if(lvl < logger->min_level) { return 0; }
+
+	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);
+
+	if(logger->msgs_alloc <= logger->msgs_sz + total_len)
+	{
+		void *tmp;
+		logger->msgs_alloc += ASMSH_LOG_BUFFER_ALLOC;
+		tmp = realloc(logger->msgs, logger->msgs_alloc);
+		if(tmp <= 0)
+		{
+			return -1;
+		}
+		if(tmp != logger->msgs)
+		{
+			logger->nxt = tmp + ((void*)logger->nxt - (void*)logger->msgs);
+		}
+		logger->msgs = tmp;
+	}
+	if(logger->msgs_alloc <= logger->msgs_sz + total_len)
+	{
+		// still to short just after realloc, more than
+		// ASMSH_LOG_BUFFER_ALLOC is needed, something seems
+		// to be wrong
+		errno = EMSGSIZE;
+		return -1;
+	}
+
+	logger->msgs_sz += total_len;
+
+	logger->nxt->level = lvl;
+	if(time(&(logger->nxt->timestamp)) < 0)
+	{
+		return -1;
+	}
+	logger->nxt->caller = (char*)((logger->nxt)+1);
+	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);
+
+	logger->nxt->nxt = (asmsh_log_msg_t*)((void*)logger->nxt->msg+total_len);
+	logger->nxt = logger->nxt->nxt;
+
+	return 0;
+
+}
+
+const char * asmsh_loglevel_name(asmsh_loglevel_t lvl)
+{
+	switch(lvl)
+	{
+		case ASMSH_TRACE:
+			return "TRACE";
+		case ASMSH_DEBUG:
+			return "DEBUG";
+		case ASMSH_INFO:
+			return "INFO";
+		case ASMSH_WARN:
+			return "WARN";
+		case ASMSH_ERR:
+			return "ERR";
+		case ASMSH_FATAL:
+			return "FATAL";
+		default:
+			return "UNKNW";
+	}
+}
+
+int asmsh_log_default_fmt(asmsh_log_msg_t *msg, char *res, int sz)
+{
+	int ret;
+	struct tm msg_tm;
+	char dtstr[32];
+
+	if(gmtime_r(&msg->timestamp, &msg_tm) == NULL)
+	{
+		strncpy(res, "DATETIME ERROR", sz);
+		return -1;
+	}
+
+	if(strftime(dtstr, sizeof(dtstr), "%FT%H:%M:%S+00:00", &msg_tm) == 0)
+	{
+		strncpy(res, "DATETIME FMT ERROR", sz);
+		return -1;
+	}
+
+	ret = snprintf(res, sz, "%s [%s](%s) : %s\n",
+			dtstr, asmsh_loglevel_name(msg->level),
+			msg->caller, msg->msg);
+	return ret;
+}

logger.h

@@ -0,0 +1,113 @@
+#ifndef ASMSH_LOGGER_H
+#define ASMSH_LOGGER_H
+#include "config.h"
+/** A logger suitable for a shell
+ *
+ * Collect messages and deliver them when needed
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.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_BUFFER_ALLOC 4096
+
+typedef struct asmsh_logger_s asmsh_logger_t;
+typedef struct asmsh_log_msg_s asmsh_log_msg_t;
+typedef enum asmsh_loglevel_e asmsh_loglevel_t;
+
+extern asmsh_logger_t *_default_logger;
+
+
+enum asmsh_loglevel_e
+{
+	ASMSH_TRACE = 0,
+	ASMSH_DEBUG = 10,
+	ASMSH_INFO = 20,
+	ASMSH_WARN = 30,
+	ASMSH_ERR = 40,
+	ASMSH_FATAL = 50
+};
+
+
+struct asmsh_log_msg_s
+{
+	asmsh_loglevel_t level;
+	time_t timestamp;
+	char *caller;
+	char *msg;
+	asmsh_log_msg_t *nxt;
+};
+
+
+struct asmsh_logger_s
+{
+	asmsh_loglevel_t min_level;
+	/** Buffered messages
+	 * 
+	 * A single buffer is used to store asmsh_log_msg_t and the
+	 * associated strings (caller & msg)
+	 * msgs will be a sequence of [asmsh_log_msg_t][char*(caller)][char*(msg)]...
+	 */
+	void *msgs;
+	/** Point on the address of the next message */
+	asmsh_log_msg_t *nxt;
+	/** Memory used by stored messages */
+	size_t msgs_sz;
+	/** Allocated buffer for messages */
+	size_t msgs_alloc;
+};
+
+
+static inline int asmsh_logger_msg_islast(asmsh_logger_t *logger, asmsh_log_msg_t *msg) {
+	return ((void*)msg) == ((void*)logger->nxt);
+}
+
+
+static inline int asmsh_logger_empty(asmsh_logger_t *logger) {
+	return asmsh_logger_msg_islast(logger, (asmsh_log_msg_t*)logger->msgs);
+}
+
+
+/** If null use default min_level of WARN
+ * @param asmsh_logger_t* Optionnal logger to set
+ * @return 0 if ok else -1
+ */
+int asmsh_logger_setup(asmsh_logger_t *logger);
+
+asmsh_logger_t* asmsh_logger_new(asmsh_loglevel_t min_level);
+
+void asmsh_logger_free(asmsh_logger_t* logger);
+
+int asmsh_logger_dprint(int fd, asmsh_logger_t *logger);
+
+/// Collect & format messages before printing them on stderr
+static inline int asmsh_logger_stderr(asmsh_logger_t *logger) {
+	return asmsh_logger_dprint(2, logger);
+}
+
+
+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);
+
+int asmsh_log_default_fmt(asmsh_log_msg_t *msg, char *res, int sz);
+
+#endif

mmap_parse.c

@@ -2,13 +2,8 @@
 
 int child_mmap_get(pid_t child_pid, child_mmap_l *maps)
 {
-	const int RDBUF_SZ = 4095;
 	char procfs_path[PATH_MAX+1];
-	char rdbuf[RDBUF_SZ+1];
-	char *line, *endline;
 	int ret, maps_fd;
-	size_t curmap;
-	void *tmp;
 	
 	if(child_pid == -1)
 	{
@@ -25,12 +20,41 @@ int child_mmap_get(pid_t child_pid, child_mmap_l *maps)
 		return -1;
 	}
 
+	if(child_mmap_get_fd(maps_fd, maps) < 0)
+	{
+		ret = -1;
+	}
+	else
+	{
+		ret = 0;
+	}
+
+	close(maps_fd);
+	return ret;
+
+err:
+	ret = errno;
+	close(maps_fd);
+	errno = ret;
+	return -1;
+}
+
+int child_mmap_get_fd(int maps_fd, child_mmap_l *maps)
+{
+	const int RDBUF_SZ = 4095;
+	char rdbuf[RDBUF_SZ+1];
+	char *line, *endline;
+	int ret;
+	size_t curmap;
+	void *tmp;
+	
 	curmap = 0;
 
 	do
 	{
 		ret = read(maps_fd, rdbuf, RDBUF_SZ);
 		if(ret < 0) { goto err; }
+		else if(ret == 0) { break; }
 		rdbuf[ret] = '\0';
 		line = endline = rdbuf;
 		while(*endline)
@@ -49,6 +73,7 @@ int child_mmap_get(pid_t child_pid, child_mmap_l *maps)
 				ret = child_mmap_parseline(line, &maps->maps[curmap]);
 				if(ret < 0) { goto err; }
 				line = endline + 1;
+				curmap++;
 			}
 			endline++;
 		}
@@ -58,18 +83,18 @@ int child_mmap_get(pid_t child_pid, child_mmap_l *maps)
 
 	if(curmap < maps->size)
 	{
+		dprintf(2, "debug realloc : %d %d\n", curmap, maps->size);
 		tmp = realloc(maps->maps, sizeof(child_mmap_t) * curmap);
 		if(!tmp)
 		{
+			perror("err");
 			goto err;
 		}
 		maps->maps = tmp;
 		maps->size = curmap;
 	}
 
-
 	return 0;
-
 err:
 	ret = errno;
 	close(maps_fd);
@@ -83,6 +108,7 @@ int child_mmap_parseline(char *line, child_mmap_t *maps)
 	unsigned long long parsed;
 	int errno_bck, cperm;
 	size_t i;
+	int major;
 
 	void **addr_ptr[2] = {&maps->start, &maps->stop};
 	const char addr_sep[2] = "- ";
@@ -90,29 +116,23 @@ int child_mmap_parseline(char *line, child_mmap_t *maps)
 	const int perms_val[3] = {PROT_READ, PROT_WRITE, PROT_EXEC};
 
 #define parsefield(line, sep, base, mapfield) {\
-unsigned long long p; char *endptr;\
-errno = 0;\
-p = strtoull(line, &endptr, base);\
-if(errno || *endptr != sep) { goto err_inval; }\
-*mapfield=p;
-
-
+	unsigned long long p; char *endptr;\
+	errno = 0;\
+	p = strtoull(*line, &endptr, base);\
+	if(errno || *endptr != sep) {\
+		dprintf(2, "*line : '%s' %s\n", *line, #mapfield);\
+		if(errno != ERANGE) { errno=EINVAL; }\
+		goto err_inval;\
+	}\
+	*mapfield=(typeof(*mapfield))p;\
+	*line = endptr+1;\
+}
+	
 	ptr = orig = line;
 
-	for(i=0; i<2; i++)
-	{
-		errno = 0;
-		parsed = strtoull(line, &endptr, 16);
-		if(errno || *endptr != addr_sep[i])
-		{
-			goto err_inval;
-		}
-
-		*addr_ptr[i] = (void*)parsed;
+	parsefield(&line, '-', 16, &maps->start);
+	parsefield(&line, ' ', 16, &maps->stop);
 
-		line = endptr+1;
-	}
-	
 	cperm = 1;
 	maps->perm = 0;
 	for(i=0; i<3; i++)
@@ -142,6 +162,25 @@ if(errno || *endptr != sep) { goto err_inval; }\
 
 	line++;
 
+	parsefield(&line, ' ', 16, &maps->offset);
+	parsefield(&line, ':', 10, &major);
+	parsefield(&line, ' ', 10, &maps->device);
+	maps->device |= major << 8; // WARNING : hardcoded major shift
+	//parsefield(&line, ' ', 10, &maps->inode);
+
+	errno = 0;
+	parsed = strtoull(line, &endptr, 10);
+	if(errno || (*endptr != ' ' && *endptr != '\0'))
+	{
+		if(errno != ERANGE) { errno = EINVAL; }
+		goto err_inval;
+	}
+	maps->inode = parsed;
+	line = endptr;
+
+	while(*line==' ') { line++; }
+
+	maps->pathname = strndup(line, PATH_MAX * 8);
 
 	return 0;
 

mmap_parse.h

@@ -1,6 +1,8 @@
 #ifndef ASMSH_MMAP_PARSE_H
 #define ASMSH_MMAP_PARSE_H
 
+#include "config.h"
+
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -9,8 +11,10 @@
 #include <limits.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <unistd.h>
 
+
 extern int errno;
 
 typedef struct child_mmap_s child_mmap_t;
@@ -41,6 +45,15 @@ struct child_mmap_list
  */
 int child_mmap_get(pid_t child_pid, child_mmap_l *maps);
 
+/** Parse an opened /proc/[pid]/map file
+ *
+ * @param int opened file descriptor
+ * @param child_mmap_l A child map that will be filled with child's mmaps
+ * @return 0 if no error else -1
+ */
+int child_mmap_get_fd(int maps_fd, child_mmap_l *maps);
+
+
 
 int child_mmap_parseline(char *line, child_mmap_t *map);
 

regen.sh

@@ -1,18 +1,22 @@
 #!/bin/sh
 
-make distclean
-rm -v ar-lib aclocal.m4 "config.h.in~" compile COPYING depcomp INSTALL install-sh missing test-driver configure Makefile.in tests/Makefile.in 2>/dev/null
-rm -vR autom4te.cache/ .deps 2>/dev/null
 
-if [ "$1" =  "--clean" ]
-then
-	exit 0
-fi
+case $1
+in
+	--clean|-c)
+		make distclean
+		rm -v ar-lib aclocal.m4 "config.h.in~" compile COPYING depcomp INSTALL install-sh missing test-driver configure Makefile.in tests/Makefile.in 2>/dev/null
+		rm -vR autom4te.cache/ .deps 2>/dev/null
+		exit 0
+		;;
+	--regen|-r)
+		sh tests/regen.sh
+		autoreconf
+		;;
+	--new|-n|*)
+		sh tests/regen.sh
+		autoheader
+		autoreconf -i -m
+		;;
+esac
 
-sh tests/regen.sh
-autoheader
-autoreconf -i -m
-#automake --add-missing
-#autoconf
-#automake --add-missing
-#autoreconf

tests/Makefile.am

@@ -1,9 +0,0 @@
-TESTS = tests_mmap
-check_PROGRAMS = tests_mmap
-#noinst_HEADERS = ttail_check.h
-EXTRA_DIST = samples
-
-tests_mmap_SOURCES = tests_mmap.c
-tests_mmap_CFLAGS = @CHECK_CFLAGS@
-tests_mmap_LDADD = $(top_builddir)/libasmsh.a @CHECK_LIBS@
-

tests/asmsh_check.h

@@ -0,0 +1,92 @@
+#ifndef _asmsh_check_h__
+#define _asmsh_check_h__
+
+#include <check.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <libgen.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+/**@brief Start a asmsh test
+ *@param const char* suite_str test suite string
+ *@param const char* tc_str test case string
+ */
+#define ASMSH_CHECK_START(suite_str, tc_str) \
+Suite * asmsh_test_suite(void) \
+{\
+	Suite *s;\
+	TCase *tc;\
+	s = suite_create(suite_str);\
+	tc = tcase_create(tc_str);
+
+
+/**@brief Set the setup & teardown fixture
+ *@param void (*setup)()
+ *@param void (*teardown)()
+ */
+#define ASMSH_SET_FIXTURE(setup, teardown) \
+		tcase_add_checked_fixture(tc, setup, teardown)
+/**@brief Add a test function defined using START_TEST(name) { ... } END_TEST
+ */
+#define ASMSH_ADD_TEST(test) tcase_add_test(tc, test)
+#define ASMSH_ADD_LOOP_TEST(test, start, stop) tcase_add_loop_test(tc, test, start, stop);
+
+/**@brief End a asmsh test */
+#define ASMSH_CHECK_END \
+	suite_add_tcase(s, tc);\
+	return s;\
+}\
+\
+int main(int argc, char **argv) {\
+	int n_fail;\
+	Suite *su;\
+	SRunner *sr;\
+	n_fail = chdir(dirname(argv[0])); /* move in ./tests dir */ \
+	if(n_fail < 0)\
+	{\
+		perror("Unable to chdir in tests folder");\
+	}\
+	su = asmsh_test_suite();\
+	sr = srunner_create(su);\
+	srunner_set_fork_status(sr, CK_FORK);\
+	srunner_run_all(sr, CK_VERBOSE);\
+	n_fail = srunner_ntests_failed(sr);\
+	srunner_free(sr);\
+	return (n_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;\
+}
+
+#define ck_assert_printf(test, format, ...) {\
+	char _err_msg[512];\
+	snprintf(_err_msg, sizeof(char) * 512,format, __VA_ARGS__);\
+	ck_assert_msg(test, _err_msg);\
+}
+
+#define close_stdpipe() {\
+	close(STDPIPE);\
+	STDPIPE = -1;\
+}
+
+#define send_sample_stdpipe(id) {\
+	int ret;\
+	char buff[1024];\
+	while((ret= read(samples_fd[id], buff, 1024)) > 0)\
+	{\
+		ret = write(STDPIPE, buff, strlen(buff));\
+		if(ret < 0)\
+		{\
+			perror("Unable to write through pipe");\
+			ck_abort_msg("Unable to write through pipe");\
+		}\
+	}\
+	if(ret < 0)\
+	{\
+		perror("Unable to read through pipe");\
+		ck_abort_msg("Unable to read through pipe");\
+	}\
+}
+
+
+#endif

tests/regen.sh

@@ -7,15 +7,24 @@ progs="$(echo *.c | sed -e 's/\.c / /g' -e 's/\.c$//')"
 cat << __EOF__ > Makefile.am
 TESTS = $progs
 check_PROGRAMS = $progs
-#noinst_HEADERS = ttail_check.h
+noinst_HEADERS = asmsh_check.h
 EXTRA_DIST = samples
+
+TESTLIB_NAME=libcheck_asmsh.a
+TESTLIB=\$(top_builddir)/\$(TESTLIB_NAME)
+
+\$(TESTLIB):
+	make -C \$(top_builddir) \$(TESTLIB_NAME)
+
+.PHONY: \$(TESTLIB)
 __EOF__
 
 for p in $progs
 do
-	echo "
+	cat << __EOF__ >> Makefile.am
 ${p}_SOURCES = ${p}.c
 ${p}_CFLAGS = @CHECK_CFLAGS@
-${p}_LDADD = \$(top_builddir)/libasmsh.a @CHECK_LIBS@
-"
-done >> Makefile.am
+${p}_LDADD = \$(TESTLIB) @CHECK_LIBS@
+__EOF__
+
+done

tests/samples/procfs_pid_maps

@@ -0,0 +1,7 @@
+00400000-00452000 r-xp 00000000 08:02 173521      /usr/bin/dbus-daemon
+00651000-00652000 r--p 00051000 08:02 173521      /usr/bin/dbus-daemon
+00652000-00655000 rw-p 00052000 08:02 173521      /usr/bin/dbus-daemon
+00e03000-00e24000 rw-p 00000000 00:00 0           [heap]
+00e24000-011f7000 rw-s 00000000 00:00 0           [heap]
+35b1a20000-35b1a21000 rw-p 00020000 13:12 135522  /usr/lib64/ld-2.15.so
+35b1a21000-35b1a22000 rw-p 00000000 00:00 0

tests/tests_compile.c

@@ -0,0 +1,189 @@
+#define _GNU_SOURCE
+#include <check.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "asmsh_check.h"
+#include "compile.h"
+
+static const char *valid_syntax[] = {
+	"mov %rax, %rbx",
+	"mov %al, %ah",
+	"add 1, %rbx",
+};
+static const int valid_syntax_sz = sizeof(valid_syntax)/sizeof(*valid_syntax);
+
+START_TEST(test_syntax_valid)
+{
+	const char *instr = valid_syntax[_i];
+	char *reason = NULL;
+	int ret;
+
+	ret = asmsh_asmc_syntax(instr, &reason);
+
+	ck_assert_int_eq(ret, 0);
+	ck_assert_ptr_null(reason);
+}
+END_TEST
+
+static const char *invalid_syntax[] = {
+	"mov %rax, %rbx;",
+	"mov %al, %ah\n",
+	"#add 1, %rbx",
+	".section text",
+};
+static const int invalid_syntax_sz = sizeof(invalid_syntax)/sizeof(*invalid_syntax);
+
+START_TEST(test_syntax_invalid)
+{
+	const char *instr = invalid_syntax[_i];
+	char *reason = NULL;
+	int ret;
+
+	ret = asmsh_asmc_syntax(instr, &reason);
+
+	ck_assert_int_eq(ret, -1);
+	ck_assert_ptr_nonnull(reason);
+	free(reason);
+}
+END_TEST
+
+
+static char* const bargs0[] = ASMSH_COMPILE_ARGS;
+static char* const bargs1[] = { "foo", "bar", NULL, NULL, "poison"};
+static char* const* const bargs[] = {bargs0, bargs1};
+static const char *bobj[] = {
+		ASMSH_COMPILE_OBJ,
+		"abcXXXXXX",
+};
+static const char *basmc[] = {
+		ASMSH_COMPILE_AS,
+		"cc"
+};
+static const int buildarg_sz = sizeof(bobj)/sizeof(*bobj);
+
+
+START_TEST(test_buildarg)
+{
+	char *const *args_in = bargs[_i];
+	const char *result_tpl = bobj[_i];
+	const char *prgname = basmc[_i];
+	int ret;
+
+	char *progname, *respath;
+	char **args;
+	int i;
+
+	ret = asmsh_asmc_buildarg(prgname, result_tpl, args_in,
+			&args, &progname, &respath);
+	ck_assert_int_eq(ret, 0);
+
+	ck_assert_ptr_nonnull(respath);
+	unlink(respath);
+
+	ck_assert_ptr_nonnull(args);
+	ck_assert_ptr_nonnull(progname);
+	
+	i=0;
+	while(args[i])
+	{
+		if(i == 0)
+		{
+			ck_assert_str_eq(progname, args[0]);
+			ck_assert_str_eq(progname, prgname);
+		}
+		else if(args_in[i])
+		{
+			ck_assert_str_eq(args_in[i], args[i]);
+		}
+		else
+		{
+			ck_assert_str_eq(args[i], respath);
+		}
+		free(args[i]);
+		i++;
+	}
+	ck_assert_ptr_null(args[i]);
+	free(args);
+}
+END_TEST
+
+START_TEST(test_ctx)
+{
+	int i;
+	const char *_args[] = ASMSH_COMPILE_ARGS;
+	const char **args = _args;
+	asmsh_asmc_ctx_t *ctx = asmsh_asmc_ctx_default();
+
+	ck_assert_ptr_nonnull(ctx);
+	ck_assert_ptr_nonnull(ctx->respath);
+	unlink(ctx->respath);
+	ck_assert_ptr_nonnull(ctx->progname);
+	ck_assert_str_eq(ctx->args[0], ctx->progname);
+
+	i=1;
+	while(args[i])
+	{
+		ck_assert_str_eq(ctx->args[i], args[i]);
+		i++;
+	}
+	ck_assert_str_eq(ctx->args[i], ctx->respath);
+
+	i++;
+	while(args[i])
+	{
+		ck_assert_str_eq(ctx->args[i], args[i]);
+		i++;
+	}
+	ck_assert_ptr_null(ctx->args[i]);
+
+	asmsh_asmc_ctx_free(ctx);
+}
+END_TEST
+
+typedef struct
+{
+	asmsh_bytecode_t bcode;
+	char *instr;
+} compile_sample_t;
+
+static const compile_sample_t comp_samples[] = {
+	{{"\x48\x83\xc0\x03\0", 4}, "add $3, %rax"},
+	{{"\x48\x89\xc3\0", 3}, "mov %rax, %rbx"},
+	{{"\x31\xc0\0", 2}, "xor %rax, %rax"},
+	{{"\x53\0", 1}, "push %rbx"},
+	{{"\x0f\x05\0", 2}, "syscall"},
+};
+
+static const int comp_samples_sz = sizeof(comp_samples)/sizeof(*comp_samples);
+
+
+START_TEST(test_compile)
+{
+	int ret;
+	asmsh_bytecode_t bcode;
+	asmsh_asmc_ctx_t *ctx = asmsh_asmc_ctx_default();
+
+	ret = asmsh_asmc_compile(ctx, comp_samples[_i].instr, &bcode);
+
+	ck_assert_int_eq(ret, 0);
+	ck_assert_int_eq(bcode.size, comp_samples[_i].bcode.size);
+	ck_assert_mem_eq(bcode.bytes, comp_samples[_i].bcode.bytes,
+			bcode.size);
+	//ck_assert_str_eq(bcode.bytes, comp_samples[_i].bcode.bytes);
+
+	asmsh_asmc_ctx_free(ctx);
+}
+END_TEST
+
+/// TODO loop test on asmsh_asmc_ctx with various args
+
+ASMSH_CHECK_START("compilation tests", "testing compilation functions")
+	ASMSH_ADD_LOOP_TEST(test_buildarg, 0, buildarg_sz);
+	ASMSH_ADD_LOOP_TEST(test_syntax_valid, 0, valid_syntax_sz);
+	ASMSH_ADD_LOOP_TEST(test_syntax_invalid, 0, invalid_syntax_sz);
+	ASMSH_ADD_TEST(test_ctx);
+	ASMSH_ADD_LOOP_TEST(test_compile, 0, comp_samples_sz);
+ASMSH_CHECK_END

tests/tests_logger.c

@@ -0,0 +1,249 @@
+#define _GNU_SOURCE
+#include <check.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "asmsh_check.h"
+#include "logger.h"
+
+START_TEST(test_logger_new)
+{
+	asmsh_logger_t *logger;
+	asmsh_loglevel_t lvls[] = {ASMSH_DEBUG, ASMSH_WARN, ASMSH_FATAL};
+
+	for(int i = 0; i<sizeof(lvls) / sizeof(*lvls); i++)
+	{
+		logger = asmsh_logger_new(lvls[i]);
+
+		ck_assert_ptr_nonnull(logger);
+		ck_assert_int_eq((logger->min_level), lvls[i]);
+		ck_assert_uint_eq((logger->msgs_sz), 0);
+		ck_assert_uint_eq((logger->msgs_alloc), ASMSH_LOG_BUFFER_ALLOC);
+
+		asmsh_logger_free(logger);
+	}
+
+}
+END_TEST
+
+START_TEST(test_log_default_fmt)
+{
+	asmsh_log_msg_t msg;
+	char buf[4096];
+	int ret;
+
+	msg.level = ASMSH_DEBUG;
+	msg.timestamp = 0;
+	msg.caller = "TestCaller";
+	msg.msg = "foo bar";
+	msg.nxt = &msg;
+
+	ret = asmsh_log_default_fmt(&msg, buf, sizeof(buf));
+	if(ret == -1)
+	{
+		dprintf(2, "log fmt error : '%s'\n", buf);
+	}
+
+	ck_assert_uint_eq(strlen(buf), ret);
+	ck_assert_str_eq(buf, "1970-01-01T00:00:00+00:00 [DEBUG](TestCaller) : foo bar\n");
+
+}
+END_TEST
+
+
+START_TEST(test_log_function_lvl_nolog)
+{
+	asmsh_logger_t *logger;
+	asmsh_log_msg_t *msg;
+
+	logger = asmsh_logger_new(ASMSH_INFO);
+
+	ck_assert_int_eq(asmsh_log(logger, ASMSH_DEBUG, "caller", "msg"), 0);
+
+	ck_assert_uint_eq(logger->msgs_alloc, ASMSH_LOG_BUFFER_ALLOC);
+	ck_assert_ptr_nonnull(logger->msgs);
+	ck_assert_ptr_eq(logger->msgs, logger->nxt);
+	ck_assert_int_ne(asmsh_logger_empty(logger), 0);
+}
+END_TEST
+
+static const char *msg_samples[][2] = {
+	{"caller", "msg"},
+	{"superfoofun", "super \"long\" message :P"},
+	{"...", "woot"},
+};
+static const int msg_samples_sz = sizeof(msg_samples)/sizeof(*msg_samples);
+
+
+START_TEST(test_log_function_lvl_singlelog)
+{
+	asmsh_log_msg_t *msg;
+	asmsh_logger_t *logger;
+	const char *caller, *testmsg;
+	size_t total_len;
+
+	
+	caller = msg_samples[_i][0];
+	testmsg = msg_samples[_i][1];
+	total_len = sizeof(asmsh_log_msg_t);
+	total_len += strlen(caller) + strlen(testmsg) + 2;
+
+	logger = asmsh_logger_new(ASMSH_INFO);
+
+	ck_assert_int_eq(asmsh_log(logger, ASMSH_ERR, caller, testmsg), 0);
+
+	ck_assert_uint_eq(logger->msgs_alloc, ASMSH_LOG_BUFFER_ALLOC);
+	ck_assert_ptr_nonnull(logger->msgs);
+
+	msg = (asmsh_log_msg_t*)logger->msgs;
+
+	ck_assert_ptr_nonnull(msg->caller);
+	ck_assert_ptr_nonnull(msg->msg);
+
+	ck_assert_str_eq(caller, msg->caller);
+	ck_assert_str_eq(testmsg, msg->msg);
+
+	ck_assert_uint_eq(logger->msgs_sz, total_len);
+
+	asmsh_logger_free(logger);
+}
+END_TEST
+
+
+START_TEST(test_log_function_lvl_logs)
+{
+
+	asmsh_log_msg_t *msg;
+	asmsh_logger_t *logger;
+	logger = asmsh_logger_new(ASMSH_INFO);
+
+	const char *caller, *testmsg;
+	size_t total_len = 0;
+
+	for(int i=0; i<msg_samples_sz; i++)
+	{
+		
+		caller = msg_samples[i][0];
+		testmsg = msg_samples[i][1];
+		total_len += sizeof(asmsh_log_msg_t);
+		total_len += strlen(caller) + strlen(testmsg) + 2;
+
+		ck_assert_int_eq(asmsh_log(logger, ASMSH_INFO, caller, testmsg), 0);
+	}
+
+	ck_assert_ptr_nonnull(logger->msgs);
+
+	msg = (asmsh_log_msg_t*)logger->msgs;
+	for(int i=0; i<msg_samples_sz; i++)
+	{
+		
+		caller = msg_samples[i][0];
+		testmsg = msg_samples[i][1];
+
+		ck_assert_ptr_nonnull(msg->caller);
+		ck_assert_ptr_nonnull(msg->msg);
+		ck_assert_int_eq(msg->level, ASMSH_INFO);
+
+		ck_assert_str_eq(caller, msg->caller);
+		ck_assert_str_eq(testmsg, msg->msg);
+
+		msg = msg->nxt;
+	}
+	ck_assert_uint_eq(logger->msgs_sz, total_len);
+	asmsh_logger_free(logger);
+}
+END_TEST
+
+
+START_TEST(test_log_dprint)
+{
+	asmsh_log_msg_t *msg;
+	asmsh_logger_t *logger;
+	logger = asmsh_logger_new(ASMSH_INFO);
+
+	const char *caller, *testmsg;
+	char *exptr, *expt, *res;
+	size_t total_len = 0;
+	int tmp_fd;
+	const char _tmpname[] = "/tmp/dprintXXXXXX";
+	char *tmpname = strdupa(_tmpname);
+
+	for(int i=0; i<msg_samples_sz; i++)
+	{
+		
+		caller = msg_samples[i][0];
+		testmsg = msg_samples[i][1];
+		total_len += sizeof(asmsh_log_msg_t);
+		total_len += strlen(caller) + strlen(testmsg) + 2;
+
+		ck_assert_int_eq(asmsh_log(logger, ASMSH_INFO, caller, testmsg), 0);
+	}
+	ck_assert_ptr_nonnull(logger->msgs);
+
+	// forcing time to 1970-01-01T00:00:00+00:00
+	msg = logger->msgs;
+	while(msg != logger->nxt)
+	{
+		msg->timestamp = 0;
+
+		msg = msg->nxt;
+	}
+
+	if((expt = malloc(logger->msgs_alloc)) == NULL)
+	{
+		perror("Unable to allocate expected result");
+		ck_abort_msg("Unable to allocate expt");
+	}
+	*expt = '\0';
+	exptr = expt;
+
+	for(int i=0; i<msg_samples_sz; i++)
+	{
+		
+		caller = msg_samples[i][0];
+		testmsg = msg_samples[i][1];
+		int ret = sprintf(exptr,
+				"1970-01-01T00:00:00+00:00 [INFO](%s) : %s\n",
+				caller, testmsg);
+		exptr += ret;
+		if(exptr-expt > logger->msgs_alloc)
+		{
+			ck_abort_msg("WTF");
+		}
+	}
+
+	tmp_fd = mkstemp(tmpname);
+	
+	int printed_sz = asmsh_logger_dprint(tmp_fd, logger);
+
+
+	lseek(tmp_fd, SEEK_SET, 0);
+
+	if((res = malloc(printed_sz+16)) == NULL)
+	{
+		perror("Unable to allocate result");
+		ck_abort_msg("unable to allocate result");
+	}
+
+	printed_sz = read(tmp_fd, res, printed_sz+15);
+	res[printed_sz] = '\0';
+	close(tmp_fd);
+	unlink(tmpname);
+
+	ck_assert_str_eq(expt, res);
+
+	asmsh_logger_free(logger);
+}
+END_TEST
+
+
+ASMSH_CHECK_START("logger tests", "unit tests various logger function")
+	ASMSH_ADD_TEST(test_logger_new);
+	ASMSH_ADD_TEST(test_log_default_fmt);
+	ASMSH_ADD_TEST(test_log_function_lvl_nolog);
+	ASMSH_ADD_LOOP_TEST(test_log_function_lvl_singlelog, 0, msg_samples_sz);
+	ASMSH_ADD_TEST(test_log_function_lvl_logs);
+	ASMSH_ADD_TEST(test_log_dprint);
+ASMSH_CHECK_END

tests/tests_mmap.c

@@ -0,0 +1,98 @@
+#include <check.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "asmsh_check.h"
+#include "mmap_parse.h"
+
+#define PARSE_FD_SAMPLE "samples/procfs_pid_maps"
+
+typedef struct {
+	child_mmap_t map;
+	char *line;
+} mmap_linecheck_t;
+
+START_TEST (test_parse_line)
+{
+	child_mmap_t res;
+	size_t i;
+
+	mmap_linecheck_t lcheck[] = {
+		{{(void*)0x123456, (void*)0x654321,
+		 MAP_PRIVATE, 0, 0, 0, "[stack]"},
+		"123456-654321 ---p 00000000 0:0 0        [stack]"},
+		{{(void*)0, (void*)0x1000,
+		 PROT_READ | PROT_WRITE | PROT_EXEC | MAP_SHARED,
+		 1, (13<<8)+12, 123, "[stack]"},
+		"0-01000 rwxs 00000001 13:12 123      [stack]"},
+		{{(void*)0x35b1800000, (void*)0x35b1820000,
+		 PROT_READ | PROT_EXEC | MAP_PRIVATE, 0x1f000, (8<<8)+2, 135522, "/usr/lib64/ld-2.15.so"},
+		"35b1800000-35b1820000 r-xp 0001f000 08:02 135522      /usr/lib64/ld-2.15.so"},
+	};
+
+	for(i=0; i<sizeof(lcheck) / sizeof(mmap_linecheck_t); i++)
+	{
+		ck_assert_int_eq(child_mmap_parseline(lcheck[i].line, &res), 0);
+		ck_assert_ptr_eq(lcheck[i].map.start, res.start);
+		ck_assert_ptr_eq(lcheck[i].map.stop, res.stop);
+		ck_assert_int_eq(lcheck[i].map.perm, res.perm);
+		ck_assert(lcheck[i].map.offset == res.offset);
+		ck_assert(lcheck[i].map.device == res.device);
+		ck_assert(lcheck[i].map.inode == res.inode);
+		ck_assert_str_eq(lcheck[i].map.pathname, res.pathname);
+	}
+}
+END_TEST
+
+START_TEST (test_parse_fd)
+{
+	child_mmap_l maps;
+	int fd, ret;
+
+	child_mmap_t checks[] = {
+		{(void*)0x400000, (void*)0x452000,
+		 PROT_READ | PROT_EXEC | MAP_PRIVATE, 0, (8<<8)+2, 173521,
+		 "/usr/bin/dbus-daemon"},
+		{(void*)0x651000, (void*)0x652000,
+		 PROT_READ | MAP_PRIVATE, 0, (8<<8)+2, 173521,
+		 "/usr/bin/dbus-daemon"},
+		{(void*)0x652000, (void*)0x655000,
+		 PROT_READ | PROT_WRITE | MAP_PRIVATE, 0, (8<<8)+2, 173521,
+		 "/usr/bin/dbus-daemon"},
+		{(void*)0xe3000, (void*)0xe24000,
+		 PROT_READ | PROT_WRITE | MAP_PRIVATE, 0, 0, 0,
+		 "[heap]"},
+		{(void*)0x24000, (void*)0x11f7000,
+		 PROT_READ | PROT_WRITE | MAP_SHARED, 0, 0, 0,
+		 "[heap]"},
+		{(void*)0x35b1a20000, (void*)0x35b1a21000,
+		 PROT_READ | PROT_WRITE | MAP_PRIVATE, 0x20000, (13<<8)+12, 135522,
+		 "/usr/lib64/ld-2.15.so"},
+		{(void*)0x35b1a21000, (void*)0x35b1a22000,
+		 PROT_READ | PROT_WRITE | MAP_PRIVATE, 0x20000, 0, 0,
+		 ""},
+	};
+
+	bzero(&maps, sizeof(child_mmap_l));
+	fd = open(PARSE_FD_SAMPLE, O_RDONLY);
+	if(fd < 0)
+	{
+		perror("Unable to open sample");
+		ck_abort_msg("Unable to open sample");
+	}
+	
+	ret = child_mmap_get_fd(fd, &maps);
+
+	ck_assert_int_eq(ret, 0);
+
+	close(fd);
+}
+END_TEST
+
+ASMSH_CHECK_START("/proc/[pid]/map file parser", "parsing tests")
+	ASMSH_ADD_TEST(test_parse_line);
+	ASMSH_ADD_TEST(test_parse_fd);
+ASMSH_CHECK_END
+