示例#1
0
VMState *
vm_newstate_no_code(VMInterruptPolicy interrupt_policy)
{
    VMState *newstate = NULL;
    err_malloc(newstate = calloc(1, sizeof(VMState)));

    // ramsize is in bytes
    err_malloc(newstate->ram = calloc(ramsize, 1));

#ifdef VM_WITH_THREADS
    err(pthread_mutex_init(&newstate->lock, NULL) == 0,
        "pthread_mutex_init",
        VM_OSERROR);
#endif

    // We make all registers ints
    err_malloc(newstate->registers = calloc(nregisters, sizeof(OPCODE_TYPE)));
    err_malloc(newstate->pins = calloc(npins, sizeof(OPCODE_TYPE)));
    newstate->interrupt_policy = interrupt_policy;
    newstate->break_async = false;

    return newstate;
error:
    vm_closestate(newstate);
    return NULL;
}
示例#2
0
文件: vm.c 项目: sihida/essig
/* allocation functions */
VMState *
vm_newstate(void *program, 
            size_t program_size,
            VMInterruptPolicy interrupt_policy)
{
    VMState *newstate = NULL;
    err_malloc(newstate = calloc(1, sizeof(VMState)));
    
    // ramsize is in bytes
    err_malloc(newstate->ram = calloc(ramsize, 1));
    
#ifdef VM_WITH_THREADS
    err(pthread_mutex_init(&newstate->lock, NULL) == 0,
        "pthread_mutex_init",
        VM_OSERROR);
#endif
    
    // We make all registers ints
    err_malloc(newstate->registers = calloc(nregisters, sizeof(int)));
    newstate->interrupt_policy = interrupt_policy;
    newstate->interrupts = NULL;
    newstate->break_async = false;
    newstate->breakpoints = NULL;

    if (!_read_elf(newstate, program, program_size))
        goto error;
    
    return newstate;
error:
    vm_closestate(newstate);
    return NULL;
}
示例#3
0
文件: vm.c 项目: sihida/essig
bool
vm_write(VMState *state, VMStateDiff *diff, VMInfoType type, 
         size_t destaddr, OPCODE_TYPE value)
{
    OPCODE_TYPE *dest; 
    VMSingleStateDiff *singlediff;
    
    if (!(dest =_get_location(state, type, destaddr)))
        goto error;
    
    /* update our diffs */
    err_malloc((singlediff = malloc(sizeof(VMSingleStateDiff))));
    singlediff->oldval = *dest;
    singlediff->newval = value;
    singlediff->type = type;
    singlediff->location = destaddr;
    
    singlediff->next = (VMIterable *) diff->singlediff;
    diff->singlediff = singlediff;
    
    /* finally, write the value */
    *dest = value;
    return true;
    
error:
    return false;
}
示例#4
0
文件: vm.c 项目: sihida/essig
static Opcode *
disassemble(unsigned int *assembly, size_t assembly_length) 
{
    Opcode *result = NULL;
    size_t i, j;

    err_malloc(result = malloc(sizeof(Opcode) * assembly_length));
    // Walk though assembly
    for (i = 0; i < assembly_length; ++i) {
        // Walk through opcode handlers
        for (j = 0; j < n_opcode_handlers; ++j) {
            // If the opcode matches an opcode handlers opcode, we found our handler
            if ((assembly[i] & opcode_handlers[j].mask) == opcode_handlers[j].opcode) {
                result->opcode_index = j;
                result->opcode = assembly[i];
                break;
            }
        }
    }

    return result;
error:
    free(result);
    return NULL;
}
示例#5
0
char			*make_full_path(char *file, char *path)
{
	char	*full;
	int		size;
	int		i;
	int		a;

	a = 0;
	i = 0;
	if (!file || !path)
		return (NULL);
	if (file[0] == '/')
		return (ft_strdup(file));
	size = ft_strlen(file) + ft_strlen(path) + 1;
	if (!(full = (char*)malloc(sizeof(*full) * (size + 1))))
		err_malloc();
	while (path[i])
		full[a++] = path[i++];
	full[a++] = '/';
	i = 0;
	while (file[i])
		full[a++] = file[i++];
	full[a] = '\0';
	return (full);
}
示例#6
0
t_piece	*read_chunk(int fd, char *execute)
{
	char		*line;
	char		buff;
	t_piece		*piece;
	static int	count;

	if (!(piece = ft_memalloc(4 * sizeof(t_piece))))
		err_malloc();
	ft_bzero(piece, sizeof(t_piece));
	if (read_line(fd, &line) == 0)
		return (0);
	if (read(fd, &buff, 1) != 1)
		*execute = 0;
	else if (buff != '\n')
		err_reading();
	if (lee_fill(line, piece) == 0)
		err_reading();
	free(line);
	line = NULL;
	count++;
	if (count > 26)
		err_reading();
	return (piece);
}
示例#7
0
文件: vm.c 项目: sihida/essig
VMStateDiff *
vm_newdiff(void)
{
    VMStateDiff *newdiff = NULL;
    err_malloc(newdiff = calloc(1, sizeof(VMStateDiff)));
    return newdiff;
error:
    vm_closediff(newdiff);
    return NULL;
}
示例#8
0
文件: vm.c 项目: markflorisson/essig
VMState *
vm_newstate_no_code(VMInterruptPolicy interrupt_policy)
{
    VMState *newstate = NULL;
    err_malloc(newstate = calloc(1, sizeof(VMState)));
    
    err_malloc(newstate->chunk = calloc(CHUNK_END, 1));
    
#ifdef VM_WITH_THREADS
    err(pthread_mutex_init(&newstate->lock, NULL) == 0,
        "pthread_mutex_init",
        VM_OSERROR);
#endif
    
    newstate->interrupt_policy = interrupt_policy;
    newstate->break_async = false;
    
    return newstate;
error:
    vm_closestate(newstate);
    return NULL;
}
示例#9
0
文件: vm.c 项目: sihida/essig
/*! Create a new interrupt item */
static VMInterruptItem *
vm_new_interrupt_item(VMInterruptType interrupt_type, unsigned int cycles)
{
    VMInterruptItem *result = NULL;
    
    err_malloc(result = calloc(1, sizeof(VMInterruptItem)));
    result->interrupt_type = interrupt_type;
    result->cycles = cycles;
    return result;
error:
    free(result);
    return NULL;
}
示例#10
0
文件: vm.c 项目: sihida/essig
bool 
vm_break(VMState *state, size_t code_offset) 
{
    VMBreakpoint *bp = NULL;
    err_malloc(bp = calloc(1, sizeof(VMBreakpoint)));
    /* prepend breakpoint */
    bp->next = (VMIterable *) state->breakpoints;
    bp->offset = code_offset;
    state->breakpoints = bp;
    return true;
error:
    free(bp);
    return false;
}
示例#11
0
/* Except in response to the WM_INITDIALOG message, the dialog box procedure
   should return nonzero if it processes the message, and zero if it does
   not. - see DialogProc */
BOOL CALLBACK CommandHelpDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	if (lParam);		/* remove warning */
	if (wParam);		/* remove warning */

	switch (msg)
	{
	case WM_INITDIALOG:
		{
		char * tmp = err_malloc(8192);
		char tmp2[MAX_PATH * 2];
		argumentspec *as;
		int i;

		LocalizeDialog (hwndDlg, "IDD_COMMANDHELP_DLG");

		as = (argumentspec*) lParam;

		*tmp = 0;

		strcpy (tmp, "Command line options:\n\n");
		for (i = 0; i < as->arg_cnt; i ++)
		{
			if (!as->args[i].Internal)
			{
				sprintf(tmp2, "%s\t%s\n", as->args[i].short_name, as->args[i].long_name);
				strcat(tmp,tmp2);
			}
		}

		strcat (tmp, "\nExamples:\n\nMount a volume as X:\ttruecrypt.exe /q /v volume.tc /l X\nDismount a volume X:\ttruecrypt.exe /q /d X");

		SetWindowText (GetDlgItem (hwndDlg, IDC_COMMANDHELP_TEXT), (char*) tmp);
		return 1;
		}

	case WM_COMMAND:
		EndDialog (hwndDlg, IDOK);
		return 1;
	case WM_CLOSE:
		EndDialog (hwndDlg, 0);
		return 1;
	}

	return 0;
}
示例#12
0
/* Except in response to the WM_INITDIALOG message, the dialog box procedure
   should return nonzero if it processes the message, and zero if it does
   not. - see DialogProc */
BOOL CALLBACK CommandHelpDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	if (lParam);		/* remove warning */
	if (wParam);		/* remove warning */

	switch (msg)
	{
	case WM_INITDIALOG:
		{
		char * tmp = err_malloc(8192);
		char tmp2[MAX_PATH * 2];
		argumentspec *as;
		int i;

		LocalizeDialog (hwndDlg, "IDD_COMMANDHELP_DLG");

		as = (argumentspec*) lParam;

		*tmp = 0;

		StringCbCopyA (tmp, 8192, "Command line options:\n\n");
		for (i = 0; i < as->arg_cnt; i ++)
		{
			if (!as->args[i].Internal)
			{
				StringCchPrintf(tmp2, MAX_PATH * 2, "%s\t%s\n", as->args[i].short_name, as->args[i].long_name);
				StringCchCat(tmp, 8192, tmp2);
			}
		}

		SetWindowText (GetDlgItem (hwndDlg, IDC_COMMANDHELP_TEXT), (char*) tmp);
		
		TCfree(tmp);
		return 1;
		}

	case WM_COMMAND:
		EndDialog (hwndDlg, IDOK);
		return 1;
	case WM_CLOSE:
		EndDialog (hwndDlg, 0);
		return 1;
	}

	return 0;
}
示例#13
0
bool
vm_register_interrupt_callable(VMState *state, interrupt_callable *func,
                               void *argument)
{
    VMInterruptCallable *callable;

    err_malloc(callable = calloc(1, sizeof(VMInterruptCallable)));
    callable->func = func;
    callable->argument = argument;
    /* prepend our struct in the linked list */
    callable->next = state->interrupt_callables;
    state->interrupt_callables = callable;
    return true;
error:
    free(callable);
    return false;
}
示例#14
0
void
put_code(VMState *state)
{
    Opcode *opcodes;
    
    err_malloc(opcodes = malloc(sizeof(Opcode) * 2));
    opcodes[0].opcode_index = 0; /* noop */
    opcodes[0].instruction = 0;
    opcodes[1].opcode_index = get_index("rjmp");
    opcodes[1].instruction = 0b1100111111111110; /* rjmp -2 */
    
    state->instructions = opcodes;
    state->instructions_size = 2;
    
    return;
error:
    check_error(false);
}
示例#15
0
int
create_iwatch_thread(pthread_t *id, int fd, queue_t q)
{
	int err;
	struct watch_data_t *wdata;

	wdata = malloc(sizeof(struct watch_data_t));
	if (wdata == NULL) {
		err_malloc(errno);
		err_msg("error[create_iwatch_thread]: Unable to malloc watch data.\n");
		return -1;
	}

	wdata->fd = fd;
	wdata->q = q;

	err = create_joinable_thread(id, watch, wdata);
	if (err < 0)
		err_create_joinable_thread(errno);

	return err;
}
示例#16
0
char			*get_name(char *str)
{
	char	*name;
	int		i;

	i = 0;
	if (!str)
		return (NULL);
	while (str[i] != '=' && str[i])
		++i;
	--i;
	if (!(name = (char*)malloc(sizeof(*name) * (i + 2))))
		err_malloc();
	i = 0;
	while (str[i] != '=' && str[i])
	{
		name[i] = str[i];
		++i;
	}
	name[i] = '\0';
	return (name);
}
示例#17
0
文件: vm.c 项目: markflorisson/essig
bool
vm_write_nbytes(VMState *state, VMStateDiff *diff, VMInfoType type,
         size_t destaddr, BIGTYPE value, int nbytes)
{
    char *location;
    VMSingleStateDiff *singlediff;
    
    if (!(location = _get_location(state, type, destaddr, NULL)))
        goto error;
    
    if (diff) {
        /* update our diffs */
        err_malloc((singlediff = malloc(sizeof(VMSingleStateDiff))));
        /* We already did error checking, don't do it again. Read and store
           in host endianness so rstep can write to uC endianness. */
        singlediff->oldval = vm_info(state, type, destaddr, NULL);
        
#ifdef VM_DEBUG
        singlediff->newval = value;
#endif
        
        singlediff->type = type;
        singlediff->location = destaddr;
        singlediff->nbytes = nbytes;
        singlediff->next = diff->singlediff;
        diff->singlediff = singlediff;
    }
    
    /* finally, write the value */
    vm_convert_endianness((char *) &value, nbytes);
    memcpy(location, &value, nbytes);
    
    return true;
    
error:
    return false;
}
示例#18
0
static Opcode *
disassemble(OPCODE_TYPE *assembly, size_t assembly_length)
{
    Opcode *result = NULL;
    OpcodeHandler *op_handler = NULL;
    size_t i, j;
    bool some_error = false, is_arg = false;

    err_malloc(result = malloc(sizeof(Opcode) * assembly_length));
    for (i = 0; i < assembly_length; ++i) {
        bool found = false;
        char *name;
        OPCODE_TYPE instruction = assembly[i];

        vm_convert_to_host_endianness((char *) &instruction,
                                      sizeof(instruction));

        for (j = 0; opcode_handlers[j].opcode_name; ++j) {
            op_handler = &opcode_handlers[j];
            if ((assembly[i] & op_handler->mask) == op_handler->opcode) {
                result[i].opcode_index = j;
                result[i].instruction = assembly[i];
                found = true;
                name = op_handler->opcode_name;
                break;
            }
        }

        if (!found) {
            /* This is another (16-bits) argument to an instruction. Apparently
               no instruction handler could be found for the argument. We try
               to find a handler in any case to allow simulation of code that
               (incorrectly or maliciously) jumps to an argument. */
            result[i].opcode_index = 0; /* noop */
            result[i].instruction = assembly[i];
            name = "noop";

            if (!is_arg) {
                some_error = true;
#ifdef VM_DEBUG
                fprintf(
                    stderr,
                    LOCATION " Cannot handle instruction 0x%x at address "
                    "offset 0x%x.\n",
                    (unsigned int) assembly[i],
                    (unsigned int) (i * sizeof(OPCODE_TYPE)));
#endif
                /* vm_seterrno(VM_ILLEGAL_INSTRUCTION); */
            }
        }

        is_arg = op_handler->next_is_arg;
    }

    if (some_error) {
        fprintf(stderr, "WARNING: Some opcodes are not implemented, "
                "simulation might not work properly.\n");
    }

    return result;
error:
    free(result);
    return NULL;
}