Suppress all compilation warnings

Makefile.am

@@ -10,7 +10,7 @@ child_SOURCES = child.s
 asmsh_LDADD=child_bin.o
 asmsh_LDFLAGS=-g -O2
 
-AM_CFLAGS=-Wall
+AM_CFLAGS=-Wall -Werror
 AM_CCASFLAGS=-g -O0
 child_LDFLAGS=-nostdlib
 

asm_env.c

@@ -42,6 +42,7 @@ asmsh_env_t* asmsh_env(const char *childpath)
 	res->childpath = NULL;
 	if(childpath && (res->childpath = strdup(childpath)) == NULL)
 	{
+		err=errno;
 		goto err_pathdup;
 	}
 
@@ -53,6 +54,7 @@ asmsh_env_t* asmsh_env(const char *childpath)
 
 	if(asmsh_env_update(res) < 0)
 	{
+		err=errno;
 		goto err;
 	}
 	
@@ -89,7 +91,7 @@ int asmsh_env_write_mem(asmsh_env_t *env, void *addr, const unsigned char *buf,
 {
 	int err;
 	u_int64_t data;
-	char written;
+	unsigned char written;
 	char bleft  = (u_int64_t)addr % 8;
 
 	written = 0;
@@ -162,7 +164,7 @@ int asmsh_env_write_code(asmsh_env_t *env, asmsh_bytecode_t *bcode)
 
 int asmsh_env_step(asmsh_env_t *env, int *status)
 {
-	int err, ret;
+	int err;
 
 	if(status) { *status = 0; }
 
@@ -278,12 +280,14 @@ static int _asmsh_env_spawn(asmsh_env_t *env)
 
 	if(ptrace(PTRACE_ATTACH, env->pid, 0, 0) == -1)
 	{
+		err=errno;
 		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");
 		goto err;
 	}
@@ -353,6 +357,7 @@ static int _asmsh_env_spawn(asmsh_env_t *env)
 		*/
 		if(asmsh_env_step(env, NULL))
 		{
+			err=errno;
 			goto err;
 		}
 	}

asmsh.c

@@ -30,7 +30,7 @@ int main(int argc, char *argv[], char *envp[])
 	asmsh_logger_t *logger;
 	asmsh_t sh;
 	
-	int ret;
+	int ret = 0;
 	char *cmd;
 	char prompt[64];
 	bzero(prompt, sizeof(prompt));
@@ -56,7 +56,7 @@ int main(int argc, char *argv[], char *envp[])
 	{
 		snprintf(prompt, sizeof(prompt)-1,
 				"asmsh@%p > ",
-				sh.env->regs.rip);
+				(void*)sh.env->regs.rip);
 		cmd = readline(prompt);
 		if(!cmd)
 		{
@@ -78,7 +78,6 @@ int main(int argc, char *argv[], char *envp[])
 		add_history(cmd);
 	}
 
-end:
 	asmsh_cleanup(&sh);
 
 	HIST_ENTRY **hist = history_list();
@@ -92,8 +91,4 @@ end:
 	free(hpath);
 
 	return ret;
-
-err:
-	ret = 1;
-	goto end;
 }

compile.c

@@ -32,20 +32,14 @@ asmsh_asmc_ctx_t* asmsh_asmc_ctx(const char *progname, \
 	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));
+	bzero(res, sizeof(*res));
 
 	if(asmsh_asmc_buildarg(progname, result_path, args,
 			&res->args, &res->progname, &res->respath) < 0)
@@ -64,7 +58,6 @@ asmsh_asmc_ctx_t* asmsh_asmc_ctx(const char *progname, \
 	memcpy(&(res->ctimeout), ctimeout?ctimeout:&default_timeout,
 			sizeof(struct timeval));
 
-	free(temp_name);
 	return res;
 
 err_buildarg:
@@ -232,7 +225,7 @@ int asmsh_asmc_compile_unsafe(asmsh_asmc_ctx_t *ctx, const char *_instr,
 	{
 		FD_ZERO(&sigset);
 		FD_SET(sigfd, &sigset);
-		if(select(sigfd+1, &sigset, NULL, NULL, &ctx->ctimeout) == 0)
+		if(select(sigfd+1, &sigset, NULL, NULL, &stimeout) == 0)
 		{
 			//compilation timeout t_t
 			asmsh_log_error("Compilation timeout");
@@ -373,6 +366,7 @@ int asmsh_asmc_spawn(asmsh_asmc_ctx_t *ctx)
 	{
 		if(pipe(pipes[i]) == -1)
 		{
+			err=errno;
 			goto err_pipe;
 		}
 	}
@@ -400,7 +394,7 @@ int asmsh_asmc_spawn(asmsh_asmc_ctx_t *ctx)
 err_fork:
 	i=1;
 err_pipe:
-	for(i; i>=0; i--)
+	for(; i>=0; i--)
 	{
 		close(pipes[i][0]);
 		close(pipes[i][1]);
@@ -456,7 +450,7 @@ if(ptr) {\
 			break;
 	}
 
-	ptr = instr;
+	ptr = (const unsigned char*)instr;
 	while(*ptr)
 	{
 		switch(*ptr)
@@ -587,7 +581,8 @@ int asmh_asmc_bytecode_from_obj(const char *objfile, asmsh_bytecode_t *bytecode)
 		}
 		else
 		{
-			dprintf(2, "Unable to read the %d bytes of bytecode\n");
+			dprintf(2, "Unable to read the %d bytes of bytecode\n",
+					bytecode_sz);
 			err = ENODATA;
 		}
 		goto err;
@@ -662,6 +657,7 @@ int asmsh_asmc_buildarg(const char* progname, const char *result_tpl, \
 		(*args_o)[i] = strdup(*tocopy);
 		if(!(*args_o)[i])
 		{
+			err=errno;
 			perror("Unable to copy compiler args");
 			goto err_dupargs;
 		}

completion.c

@@ -32,6 +32,7 @@ char **asmsh_completion(const char *buf, const char *text, int start, int end)
 		return asmsh_compl_arg(buf, text, start);
 	}
 	// command completion handling
+	return NULL;
 }
 
 
@@ -286,10 +287,9 @@ err:
 
 static int _completion_upper_macro(const char *macro, const char *start, char **ret, size_t *i)
 {
-	int stlen, len, oi, need_cmp;
+	int stlen, len, need_cmp;
 	char buf[32]; /* large enough */
 	char fmt[32];
-	oi = *i;
 	len = strlen(macro);
 	stlen = strlen(start);
 
@@ -419,3 +419,45 @@ static int _completion_macro_match(const char *macro, const char *text, int mlen
 	return 1;
 }
 
+#if HAVE_LIBREADLINE == 1
+static char **_asmsh_completion_res;
+static char **_asmsh_completion_cur;
+static int _asmsh_completion_st[2];
+extern int rl_attempted_completion_over;
+extern const char* rl_special_prefixes;
+extern const char* rl_basic_word_break_characters;
+char *asmsh_rl_completion_gen(const char *text, int state)
+{
+	if(!state)
+	{
+		_asmsh_completion_res = asmsh_completion(rl_line_buffer,
+							text,
+							_asmsh_completion_st[0],
+							_asmsh_completion_st[1]);
+		_asmsh_completion_cur = _asmsh_completion_res;
+		if(!_asmsh_completion_res)
+		{
+			return NULL;
+		}
+	}
+	char *res = *_asmsh_completion_cur;
+	if(!*_asmsh_completion_cur)
+	{
+		free(_asmsh_completion_res);
+	}
+	else
+	{
+		*_asmsh_completion_cur = NULL;
+		_asmsh_completion_cur++;
+	}
+	return res;
+}
+char **asmsh_rl_completion(const char *text, int start, int end)
+{
+	rl_attempted_completion_over = 1;
+	_asmsh_completion_st[0]=start;
+	_asmsh_completion_st[1]=end;
+	return rl_completion_matches(text, asmsh_rl_completion_gen);
+}
+#endif
+

completion.h

@@ -59,45 +59,8 @@ struct asmsh_completion_s
 char **asmsh_completion(const char *buf, const char *text, int start, int end);
 
 #if HAVE_LIBREADLINE == 1
-static char **_asmsh_completion_res;
-static char **_asmsh_completion_cur;
-static int _asmsh_completion_st[2];
-static char *asmsh_rl_completion_gen(const char *text, int state)
-{
-	if(!state)
-	{
-		_asmsh_completion_res = asmsh_completion(rl_line_buffer,
-							text,
-							_asmsh_completion_st[0],
-							_asmsh_completion_st[1]);
-		_asmsh_completion_cur = _asmsh_completion_res;
-		if(!_asmsh_completion_res)
-		{
-			return NULL;
-		}
-	}
-	char *res = *_asmsh_completion_cur;
-	if(!*_asmsh_completion_cur)
-	{
-		free(_asmsh_completion_res);
-	}
-	else
-	{
-		*_asmsh_completion_cur = NULL;
-		_asmsh_completion_cur++;
-	}
-	return res;
-}
-extern int rl_attempted_completion_over;
-extern const char* rl_special_prefixes;
-extern const char* rl_basic_word_break_characters;
-static char **asmsh_rl_completion(const char *text, int start, int end)
-{
-	rl_attempted_completion_over = 1;
-	_asmsh_completion_st[0]=start;
-	_asmsh_completion_st[1]=end;
-	return rl_completion_matches(text, asmsh_rl_completion_gen);
-}
+char *asmsh_rl_completion_gen(const char *text, int state);
+char **asmsh_rl_completion(const char *text, int start, int end);
 #endif
 
 /** Return all possible instructions given a start */

history.c

@@ -104,4 +104,6 @@ int load_history(const char *history_path, add_history_f *add_h)
 		}
 	}while(readed && readed == wanted);
 	close(fd);
+	return 0;
 }
+

logger.c

@@ -118,12 +118,15 @@ int asmsh_logger_strdup(asmsh_logger_t *logger, char **result, size_t *res_sz)
 	asmsh_log_msg_t *cur;
 	char *buf_ptr;
 	int ret;
+	int err;
 
 	*res_sz = 0;
 	buf_ptr = *result = malloc(buf_sz = BUF_ALLOC);
 	if(*result == NULL)
 	{
+		err=errno;
 		perror("Enable to allocate buffer for log messages");
+		errno=err;
 		return -1;
 	}
 
@@ -135,6 +138,14 @@ int asmsh_logger_strdup(asmsh_logger_t *logger, char **result, size_t *res_sz)
 		{
 			buf_sz += BUF_ALLOC;
 			void *tmp = realloc(*result, buf_sz);
+			if(!tmp)
+			{
+				err=errno;
+				perror("Unable to strdup logline");
+				errno=err;
+				return -1;
+			}
+			result=tmp;
 		}
 		else
 		{
@@ -142,6 +153,7 @@ int asmsh_logger_strdup(asmsh_logger_t *logger, char **result, size_t *res_sz)
 			cur = cur->nxt;
 		}
 	}
+	return 0;
 }
 
 int asmsh_log(asmsh_logger_t *logger, asmsh_loglevel_t lvl, const char caller[],

mmap_parse.c

@@ -52,12 +52,6 @@ int child_mmap_get(pid_t child_pid, child_mmap_l *maps)
 
 	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)
@@ -104,7 +98,6 @@ int child_mmap_get_fd(int maps_fd, 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)
 		{
@@ -126,14 +119,12 @@ err:
 
 int child_mmap_parseline(char *line, child_mmap_t *maps)
 {
-	char *ptr, *orig, *endptr;
+	char *orig, *endptr;
 	unsigned long long parsed;
-	int errno_bck, cperm;
+	int cperm;
 	size_t i;
 	int major;
 
-	void **addr_ptr[2] = {&maps->start, &maps->stop};
-	const char addr_sep[2] = "- ";
 	const char perms[3] = "rwx";
 	const int perms_val[3] = {PROT_READ, PROT_WRITE, PROT_EXEC};
 
@@ -150,7 +141,7 @@ int child_mmap_parseline(char *line, child_mmap_t *maps)
 	*line = endptr+1;\
 }
 	
-	ptr = orig = line;
+	orig = line;
 
 	parsefield(&line, '-', 16, &maps->start);
 	parsefield(&line, ' ', 16, &maps->stop);
@@ -207,9 +198,7 @@ int child_mmap_parseline(char *line, child_mmap_t *maps)
 	return 0;
 
 	err_inval:
-		errno_bck = errno;
 		dprintf(2, "Invalid procfs/[pid]/maps content '%s'", orig);
-	err:
 		return -1;
 }
 

shell.c

@@ -71,9 +71,9 @@ int asmsh_exec(asmsh_t *sh, const char *cmd)
 		return -1;
 	}
 
-	int clen, ret;
+	int ret;
 	//lstrip whitespace
-	for(cmd; *cmd && (*cmd == ' ' || *cmd == '\t'); cmd++);
+	for(; *cmd && (*cmd == ' ' || *cmd == '\t'); cmd++);
 	if(!*cmd) { return 0; }
 
 	switch(*cmd)
@@ -144,23 +144,27 @@ static int _compile_step(asmsh_t *sh, const char *cmd)
 
 static int _handle_command(asmsh_t *sh, const char *cmd)
 {
-	const int clen = strlen(cmd);
 	const asmsh_cmd_t *match;
-	int ret;
+	int ret, err;
 
 	asmsh_cmd_args_t *args;
 
 	args = asmsh_cmd_parse(cmd);
 	if(!args)
 	{
+		err=errno;
 		asmsh_log_error("Parse error"); // TODO better error
+		errno=err;
 		return -1;
 	}
 
 	match = asmsh_cmd_match(args->cmd, strlen(args->cmd));
 	if(!match)
 	{
+		err=errno;
 		asmsh_log_error("Unknow command");
+		asmsh_cmd_args_free(args);
+		errno=err;
 		return -1;
 	}
 	ret = match->cmd(sh, args);

shell_cmds.c

@@ -75,7 +75,7 @@ asmsh_cmd_args_t *asmsh_cmd_parse(const char *cmd)
 	strncpy(ret->cmd, cmd, cmdlen);
 	ret->cmd[cmdlen] = '\0';
 	// lstrip white chars
-	for(ptr; *ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n'); ptr++);
+	for(; *ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n'); ptr++);
 	if(!*ptr)
 	{
 		// end of command
@@ -87,7 +87,7 @@ asmsh_cmd_args_t *asmsh_cmd_parse(const char *cmd)
 	do
 	{
 		int arglen = 0;
-		for(ptr; *ptr && *ptr != ' ' && *ptr != '\t' && *ptr != '\n'; ptr++)
+		for(; *ptr && *ptr != ' ' && *ptr != '\t' && *ptr != '\n'; ptr++)
 		{
 			arglen++;
 		}
@@ -107,7 +107,7 @@ asmsh_cmd_args_t *asmsh_cmd_parse(const char *cmd)
 			goto err;
 		}
 		// lstrip white chars
-		for(ptr; *ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n'); ptr++);
+		for(; *ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n'); ptr++);
 		arg=ptr;
 	}while(*ptr);
 
@@ -121,6 +121,18 @@ err:
 	return NULL;
 }
 
+
+void asmsh_cmd_args_free(asmsh_cmd_args_t *args)
+{
+	if(!args) { return; }
+	for(char **a=args->args; *a; a++)
+	{
+		free(*a);
+	}
+	free(args);
+}
+
+
 int asmsh_cmd_bcode(asmsh_t *sh, char *argbuf, int bufsz, int argc, char **args)
 {
 	asmsh_bytecode_t bcode;

shell_cmds.h

@@ -74,16 +74,7 @@ const asmsh_cmd_t *asmsh_cmd_match(const char *cmd, int stop);
 /** @return NULL on error or ptr on new cmd args */
 asmsh_cmd_args_t *asmsh_cmd_parse(const char *cmd);
 
-static void asmsh_cmd_args_free(asmsh_cmd_args_t *args)
-{
-	if(!args) { return; }
-	for(char **a=args->args; *a; a++)
-	{
-		free(*a);
-	}
-	free(args);
-}
-
+void asmsh_cmd_args_free(asmsh_cmd_args_t *args);
 
 const char *asmsh_cmd_help(asmsh_t *sh);
 
@@ -129,12 +120,12 @@ static int _print_regs(asmsh_t *sh, asmsh_cmd_args_t *args)
 	
 #define FLG(b, l) ( (r->eflags & (1<<b))?l:'-' )
 
-	printf("rax: %016lx rbx: %016lx rcx: %016lx rdx: %016lx\n\
-rbp: %016lx rsi: %016lx rdi: %016lx rsp: %016lx\n\
- r8: %016lx  r9: %016lx r10: %016lx r11: %016lx\n\
-r12: %016lx r13: %016lx r14: %016lx r15: %016lx\n\
-rip: %016lx flg: %016lx\n\
-cs: %04x ds: %04x es: %04x fs:%04x gs: %04x ss:%04x\n\
+	printf("rax: %016llx rbx: %016llx rcx: %016llx rdx: %016llx\n\
+rbp: %016llx rsi: %016llx rdi: %016llx rsp: %016llx\n\
+ r8: %016llx  r9: %016llx r10: %016llx r11: %016llx\n\
+r12: %016llx r13: %016llx r14: %016llx r15: %016llx\n\
+rip: %016llx flg: %016llx\n\
+cs: %04llx ds: %04llx es: %04llx fs:%04llx gs: %04llx ss:%04llx\n\
 flags: %c%c%c%c|%c%c%c\n\
        ODSZ|APC\n\
 ",	r->rax, r->rbx, r->rcx, r->rdx,\
@@ -157,6 +148,7 @@ static int _reset(asmsh_t *sh, asmsh_cmd_args_t *args)
 	asmsh_cleanup(sh);
 	asmsh_init(sh, childpath);
 	free(childpath);
+	return 0;
 }
 
 // Display CPU flag resister values
@@ -215,10 +207,9 @@ static const asmsh_cmd_t asmsh_CMDS[] = {
 static int _help(asmsh_t *sh, asmsh_cmd_args_t *args)
 {
 	char buf[4096], abuf[64];
-	int ret, pret;
+	int ret;
 
 	ret = snprintf(buf, 4096, "Available commands :\n");
-	pret = ret;
 	for(const asmsh_cmd_t *cmd = asmsh_CMDS; cmd->str; cmd++)
 	{
 		snprintf(abuf, 64, "%s %s", cmd->sms, cmd->usage);