Starts implementing asmsh commands

Makefile.am

@@ -1,6 +1,7 @@
 bin_PROGRAMS = asmsh child
 
-libcheck_asmsh_a_SOURCES = mmap_parse.c asm_env.c compile.c logger.c completion.c shell.c
+libcheck_asmsh_a_SOURCES = mmap_parse.c asm_env.c compile.c logger.c \
+			   completion.c shell.c shell_cmds.c
 
 asmsh_SOURCES = asmsh.c $(libcheck_asmsh_a_SOURCES)
 child_SOURCES = child.s

asmsh.c

@@ -9,33 +9,6 @@
 #include "shell.h"
 #include "completion.h"
 
-static void print_regs(asmsh_env_t *env)
-{
-	asmsh_env_update_regs(env);
-	struct user_regs_struct *r = &env->regs;
-	
-#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\
-flags: %c%c%c%c|%c%c%c\n\
-       ODSZ|APC\n\
-",	r->rax, r->rbx, r->rcx, r->rdx,\
-	r->rbp, r->rsi, r->rdi, r->rsp,\
-	r->r8, r->r9, r->r10, r->r11,\
-	r->r12, r->r13, r->r14, r->r15,\
-	r->rip, r->eflags,\
-	r->cs, r->ds, r->es, r->fs, r->gs, r->ss,
-	FLG(11,'O'), FLG(10, 'D'), FLG(7, 'S'), FLG(6, 'Z'),
-	FLG(4, 'A'), FLG(2, 'P'), FLG(0, 'C'));
-
-#undef FLG
-}
-
 int main(int argc, char *argv[], char *envp[])
 {
 	asmsh_logger_t *logger;
@@ -62,7 +35,6 @@ int main(int argc, char *argv[], char *envp[])
 
 	while(1)
 	{
-		print_regs(sh.env);
 		snprintf(prompt, sizeof(prompt)-1,
 				"asmsh@%p > ",
 				sh.env->regs.rip);

compile.c

@@ -544,7 +544,7 @@ int asmh_asmc_bytecode_from_obj(const char *objfile, asmsh_bytecode_t *bytecode)
 
 	if(bytecode_sz == 0)
 	{
-		dprintf(2, "Null bytecode size");
+		asmsh_log_error("Null bytecode size");
 		err = ENODATA;
 		goto err;
 	}

shell.c

@@ -14,6 +14,7 @@ int asmsh_init(asmsh_t *sh, const char *child_path)
 		asmsh_env_free(sh->env);
 		goto err;
 	}
+	sh->child_path = strdup(child_path); // TODO check error
 	return 0;
 err:
 	bzero(sh, sizeof(asmsh_t));
@@ -32,6 +33,14 @@ void asmsh_cleanup(asmsh_t *sh)
 	{
 		asmsh_env_free(sh->env);
 	}
+	if(sh->child_path)
+	{
+		free(sh->child_path);
+	}
+	if(sh->last_instr)
+	{
+		free(sh->last_instr);
+	}
 	bzero(sh, sizeof(asmsh_t));
 }
 
@@ -81,6 +90,7 @@ static int _compile_step(asmsh_t *sh, const char *cmd)
 	sh->last_bcode = bcode;
 	if(sh->last_instr) { free(sh->last_instr); }
 	sh->last_instr = strdup(cmd);
+
 char buf[256];
 int _ret;
 _ret = snprintf(buf, 255, "'%s' = 0x", cmd);
@@ -116,15 +126,25 @@ asmsh_log_info(buf);
 static int _handle_command(asmsh_t *sh, const char *cmd)
 {
 	const int clen = strlen(cmd);
+	const asmsh_cmd_t *match;
+	int ret;
 
-	if(clen <= 1)
+	asmsh_cmd_args_t *args;
+
+	args = asmsh_cmd_parse(cmd);
+	if(!args)
 	{
-		asmsh_log_error("No command given");
-		return 0;
+		asmsh_log_error("Parse error"); // TODO better error
+		return -1;
 	}
-	if(strncmp(cmd, ".quit", clen) == 0)
+
+	match = asmsh_cmd_match(args->cmd, strlen(args->cmd));
+	if(!match)
 	{
-		asmsh_cleanup(sh);
-		return 1;
+		asmsh_log_error("Unknow command");
+		return -1;
 	}
+	ret = match->cmd(sh, args);
+	asmsh_cmd_args_free(args);
+	return ret;
 }

shell.h

@@ -16,6 +16,7 @@ struct asmsh_s
 	asmsh_asmc_ctx_t *cctx;
 	asmsh_env_t *env;
 
+	char *child_path;
 	char *last_instr;
 	asmsh_bytecode_t last_bcode;
 
@@ -27,4 +28,6 @@ void asmsh_cleanup(asmsh_t *sh);
 /** @return <0 on error 0 on ok 1 on exit */
 int asmsh_exec(asmsh_t *sh, const char *cmd);
 
+#include "shell_cmds.h"
+
 #endif

shell_cmds.c

@@ -0,0 +1,102 @@
+#include "shell_cmds.h"
+
+const asmsh_cmd_t *asmsh_cmd_match(const char *text, int tlen)
+{
+	for(const asmsh_cmd_t *cmd=asmsh_CMDS; cmd->str; cmd++)
+	{
+		const int clen = strlen(cmd->str);
+		if(cmd->sm && tlen >= cmd->sm && tlen < clen)
+		{
+			if(!strncmp(cmd->str, text, tlen))
+			{
+				return cmd;
+			}
+			continue;
+		}
+		else if(tlen != clen) { continue; }
+		else
+		{
+			int cmp = strncmp(text, cmd->str, tlen);
+			if(cmp < 0)
+			{
+				break;
+			}
+			else if(!cmp)
+			{
+				return cmd;
+			}
+		}
+	}
+	return NULL;
+}
+
+
+asmsh_cmd_args_t *asmsh_cmd_parse(const char *cmd)
+{
+	asmsh_cmd_args_t *ret;
+	int cmdlen, err, argno;
+	const char *ptr, *arg;
+
+	if(!cmd || !*cmd || *cmd != '.') { return NULL; }
+
+	if(!(ret = malloc(sizeof(*ret))))
+	{
+		asmsh_log_fatal("Unable to allocate command");
+		return NULL;
+	}
+	bzero(ret, sizeof(*ret));
+
+	cmdlen=0;
+	for(ptr=cmd; *ptr && *ptr != ' ' && *ptr != '\t' && *ptr != '\n'; ptr++)
+	{
+		cmdlen++;
+	}
+	if(cmdlen > ASMSH_CMD_MAXLEN)
+	{
+		asmsh_log_error("Invalid command"); //TODO printf command
+		err=EINVAL;
+		goto err;
+	}
+	strncpy(ret->cmd, cmd, cmdlen);
+	ret->cmd[cmdlen] = '\0';
+	// lstrip white chars
+	for(ptr; *ptr && *ptr == ' ' && *ptr == '\t' && *ptr == '\n'; ptr++);
+	if(!*ptr)
+	{
+		// end of command
+		ret->args[0] = NULL;
+		return ret;
+	}
+	arg = ptr;
+	argno=0;
+	do
+	{
+		int arglen = 0;
+		for(ptr; *ptr && *ptr != ' '&& *ptr != '\t' && *ptr != '\n'; ptr++)
+		{
+			arglen++;
+		}
+		ret->args[argno] = strndup(arg, arglen);
+		if(!ret->args[argno])
+		{
+			err=errno;
+			goto err;
+		}
+		argno++;
+		if(argno >= ASMSH_CMD_MAXARG)
+		{
+			//too many arguments
+			err=EINVAL;
+			goto err;
+		}
+		// lstrip white chars
+		for(ptr; *ptr && *ptr == ' ' && *ptr == '\t' && *ptr == '\n'; ptr++);
+	}while(*ptr);
+
+	ret->args[argno] = NULL;
+	return ret;
+err:
+	for(char **p=ret->args; *p; p++) { free(*p); }
+	errno = err;
+	free(ret);
+}

shell_cmds.h

@@ -0,0 +1,165 @@
+#ifndef ASMSH_SHELL_CMDS_H
+#define ASMSH_SHELL_CMDS_H
+#include "config.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "logger.h"
+
+#define ASMSH_CMD_MAXLEN 31
+#define ASMSH_CMD_MAXARG 15
+
+typedef struct asmsh_cmd_s asmsh_cmd_t;
+typedef struct asmsh_cmd_args_s asmsh_cmd_args_t;
+#include "shell.h"
+
+/** @return <0 on recoverable error 0 on ok, 1+status on exit */
+typedef int (asmsh_cmd_f)(asmsh_t*, asmsh_cmd_args_t*);
+
+struct asmsh_cmd_s
+{
+	const char *str;
+	asmsh_cmd_f *cmd;
+	/**If non-zero indicate the minimum of chars to
+	 * match. ".quit" while have 2 to match starting
+	 * from ".q"
+	 */
+	unsigned char sm;
+
+	const char *sms;
+	const char *usage;
+	const char *desc;
+};
+
+struct asmsh_cmd_args_s
+{
+	char cmd[ASMSH_CMD_MAXLEN+1];
+	char *args[ASMSH_CMD_MAXARG+1];
+};
+
+static int _quit(asmsh_t *sh, asmsh_cmd_args_t *args)
+{
+	asmsh_cleanup(sh);
+	return 1;
+}
+
+static int _print_regs(asmsh_t *sh, asmsh_cmd_args_t *args)
+{
+	asmsh_env_t *env = sh->env;
+	asmsh_env_update_regs(env);
+	struct user_regs_struct *r = &env->regs;
+	
+#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\
+flags: %c%c%c%c|%c%c%c\n\
+       ODSZ|APC\n\
+",	r->rax, r->rbx, r->rcx, r->rdx,\
+	r->rbp, r->rsi, r->rdi, r->rsp,\
+	r->r8, r->r9, r->r10, r->r11,\
+	r->r12, r->r13, r->r14, r->r15,\
+	r->rip, r->eflags,\
+	r->cs, r->ds, r->es, r->fs, r->gs, r->ss,
+	FLG(11,'O'), FLG(10, 'D'), FLG(7, 'S'), FLG(6, 'Z'),
+	FLG(4, 'A'), FLG(2, 'P'), FLG(0, 'C'));
+
+#undef FLG
+	return 0;
+}
+
+static int _reset(asmsh_t *sh, asmsh_cmd_args_t *args)
+{
+	char *childpath = strdup(sh->child_path);
+	asmsh_cleanup(sh);
+	asmsh_init(sh, childpath);
+	free(childpath);
+}
+
+static int _flags(asmsh_t *sh, asmsh_cmd_args_t *args)
+{
+	printf("Flags :\n");
+#define printFLG(name, b) printf(" (%2d)%16s : %d\n", b, name,\
+		(sh->env->regs.eflags & (1<<b))?1:0);
+	printFLG("Overflow", 11);
+	printFLG("Direction", 10);
+	printFLG("Sign", 7);
+	printFLG("Zero", 6);
+	printFLG("Auxiliary carry", 4);
+	printFLG("Parity", 2);
+	printFLG("Carry", 0);
+#undef printFLG
+#define EFLG(b,n) ((sh->env->regs.eflags & (1<<b))?n:'-')
+	printf("%c%c%c%c %c%c%c\n",
+			EFLG(11,'O'), EFLG(10, 'D'), EFLG(7,'S'), EFLG(6,'Z'),
+			EFLG(4,'A'), EFLG(2, 'P'), EFLG(0, 'C'));
+	return 0;
+}
+
+static int _help(asmsh_t *sh, asmsh_cmd_args_t *args);
+
+static const asmsh_cmd_t asmsh_CMDS[] = {
+	{".flags", _flags, 2,
+	 ".f(lags)", "",
+	 "display CPU flags"},
+	{".help", _help, 2,
+	 ".h(elp)","[cmd]",
+	 "display this help or the help of specified command"},
+	{".quit", _quit, 2,
+	 ".q(uit)","",
+	 "quit asmsh"},
+	{".regs", _print_regs, 1,
+	".(regs)", "",
+	"display registers value"},
+	{".reset", _reset, 0,
+	 ".reset", "",
+	 "reset the shell"},
+	{NULL, NULL, 0},
+};
+
+static int _help(asmsh_t *sh, asmsh_cmd_args_t *args)
+{
+	char buf[4096], abuf[64];
+	int ret, pret;
+
+	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);
+		ret += snprintf(buf+ret, 4096-ret, "  %-18s : %s\n", 
+				abuf, cmd->desc);
+	}
+	dprintf(2, buf);
+	return 0;
+}
+
+/**@param const char* the text to match
+ * @param int the len of the text to match
+ * @return a ptr or NULL
+ */
+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);
+}
+
+
+const char *asmsh_cmd_help(asmsh_t *sh);
+
+#endif