예제 #1
0
파일: bin_java.c 프로젝트: 0xroot/radare2
static RList* entries(RBinArch *arch) {
	RBinAddr *ptr;
	RList *ret = r_list_new ();
	if (!ret) return NULL;
	ret->free = free;
	if (!(ptr = R_NEW (RBinAddr)))
		return ret;
	memset (ptr, '\0', sizeof (RBinAddr));
	ptr->offset = ptr->rva = r_bin_java_get_entrypoint (arch->bin_obj);
	r_list_append (ret, ptr);
	return ret;
}
예제 #2
0
파일: bin_te.c 프로젝트: 17twenty/radare2
static RBinAddr* binsym(RBinFile *arch, int type) {
	RBinAddr *ret = NULL;
	switch (type) {
	case R_BIN_SYM_MAIN:
		if (!(ret = R_NEW (RBinAddr)))
			return NULL;
		memset (ret, '\0', sizeof (RBinAddr));
		ret->offset = ret->rva = r_bin_te_get_main_offset (arch->o->bin_obj);
		break;
	}
	return ret;
}
예제 #3
0
파일: op.c 프로젝트: commiebstrd/radare2
R_API RAnalOp *r_anal_op_copy (RAnalOp *op) {
	RAnalOp *nop = R_NEW (RAnalOp);
	*nop = *op;
	nop->mnemonic = strdup (op->mnemonic);
	nop->src[0] = r_anal_value_copy (op->src[0]);
	nop->src[1] = r_anal_value_copy (op->src[1]);
	nop->src[2] = r_anal_value_copy (op->src[2]);
	nop->dst = r_anal_value_copy (op->dst);
	r_strbuf_init (&nop->esil);
	r_strbuf_set (&nop->esil, r_strbuf_get (&op->esil));
	return nop;
}
예제 #4
0
파일: syscall.c 프로젝트: 0xroot/radare2
R_API RSyscall* r_syscall_new() {
	RSyscall *rs = R_NEW (RSyscall);
	if (rs) {
		rs->fd = NULL;
		rs->sysptr = NULL; //syscalls_linux_x86;
		rs->sysport = sysport_x86;
		rs->syspair = NULL;
		rs->printf = (PrintfCallback)printf;
		rs->regs = fastcall_x86;
	}
	return rs;
}
예제 #5
0
파일: lock.c 프로젝트: ericfode/radare2
R_API struct r_th_lock_t *r_th_lock_new() {
	RThreadLock *thl = R_NEW(RThreadLock);
	if (thl) {
		thl->refs = 0;
#if HAVE_PTHREAD
		pthread_mutex_init (&thl->lock, NULL);
#elif __WIN32__
		//thl->lock = CreateSemaphore(NULL, 0, 1, NULL);
		InitializeCriticalSection(&thl->lock);
#endif
	}
	return thl;
}
예제 #6
0
R_API RThreadLock *r_th_lock_new() {
	RThreadLock *thl = R_NEW(RThreadLock);
	if (thl) {
		thl->refs = 0;
#if HAVE_PTHREAD
		pthread_mutex_init (&thl->lock, NULL);
#elif __WIN32__ || __WINDOWS__ && !defined(__CYGWIN__)
		//thl->lock = CreateSemaphore(NULL, 0, 1, NULL);
		InitializeCriticalSection(&thl->lock);
#endif
	}
	return thl;
}
예제 #7
0
파일: bin_rar.c 프로젝트: 17twenty/radare2
static RList* entries(RBinFile *arch) {
	RList* ret = r_list_new ();;
	RBinAddr *ptr = NULL;
	if (!ret) return NULL;
	ret->free = free;
	if (!memcmp (arch->buf+0x30, "\x00\x00\x00\x00\x20\x73\x74\x64\x6f\x75\x74\x20\x21\x55\x0c\xcd", 16)) {
		if ((ptr = R_NEW (RBinAddr))) {
			ptr->rva = ptr->offset = 0x9a;
			r_list_append (ret, ptr);
		}
	}
	return ret;
}
예제 #8
0
static RBinAddr* binsym(RBinArch *arch, int sym) {
	ut64 addr;
	RBinAddr *ret = NULL;
	switch (sym) {
	case R_BIN_SYM_MAIN:
		addr = MACH0_(r_bin_mach0_get_main) (arch->bin_obj);
		if (!addr || !(ret = R_NEW (RBinAddr)))
			return NULL;
		memset (ret, '\0', sizeof (RBinAddr));
		ret->offset = ret->rva = addr;
		break;
	}
	return ret;
}
예제 #9
0
파일: op.c 프로젝트: glandium/radare2
R_API RAnalOp *r_anal_op_new() {
	RAnalOp *op = R_NEW (RAnalOp);
	if (op) {
		memset (op, 0, sizeof (RAnalOp));
		op->mnemonic = NULL;
		op->addr = -1;
		op->jump = -1;
		op->fail = -1;
		op->ref = -1;
		op->value = -1;
		op->next = NULL;
	}
	return op;
}
예제 #10
0
파일: bin_bios.c 프로젝트: eddyb/radare2
static RList* entries(RBinArch *arch) {
    RList *ret;
    RBinAddr *ptr = NULL;

    if (!(ret = r_list_new ()))
        return NULL;
    ret->free = free;
    if (!(ptr = R_NEW (RBinAddr)))
        return ret;
    memset (ptr, '\0', sizeof (RBinAddr));
    ptr->offset = ptr->rva = 0xffff0;
    r_list_append (ret, ptr);
    return ret;
}
예제 #11
0
R_API RStrpool* r_strpool_new (int sz) {
	RStrpool *p = R_NEW (RStrpool);
	if (!p) return NULL;
	if (sz<1) sz = 1024;
	p->size = sz;
	p->len = 0;
	p->str = malloc (sz);
	if (!p->str) {
		free (p);
		return NULL;
	}
	p->str[0] = 0;
	return p;
}
예제 #12
0
파일: bin_java.c 프로젝트: 0xroot/radare2
static RList* lines(RBinArch *arch) {
	int i;
	char *file = strdup (arch->file);
	RList *list = r_list_new ();
	RBinJavaObj *b = arch->bin_obj;
	file = r_str_replace (file, ".class", ".java", 0);
	for (i=0; i<b->lines.count; i++) {
		RBinDwarfRow *row = R_NEW (RBinDwarfRow);
		r_bin_dwarf_line_new (row, b->lines.addr[i], file, b->lines.line[i]);
		r_list_append (list, row);
	}
	free (file);
	return list;
}
예제 #13
0
static RList* entries(RBinFile *arch) {
	RList* ret;
	RBinAddr *ptr = NULL;

	if (!(ret = r_list_new ()))
		return NULL;
	ret->free = free;
	if ((ptr = R_NEW (RBinAddr))) {
		ptr->paddr = 8*4;
		ptr->vaddr = 8*4;// + baddr (arch);
		r_list_append (ret, ptr);
	}
	return ret;
}
예제 #14
0
파일: io_w32.c 프로젝트: djpohly/radare2
static RIODesc *w32__open(RIO *io, const char *pathname, int rw, int mode) {
	if (!memcmp (pathname, "w32://", 6)) {
		RIOW32 *w32 = R_NEW (RIOW32);
		const char *filename= pathname+6;
		w32->hnd = CreateFile (filename,
			GENERIC_READ | rw?GENERIC_WRITE:0,
			FILE_SHARE_READ | rw?FILE_SHARE_WRITE:0,
			NULL, OPEN_ALWAYS, 0, NULL);
		if (w32->hnd != INVALID_HANDLE_VALUE)
			return r_io_desc_new (&r_io_plugin_w32, getw32fd (w32),
				pathname, rw, mode, w32);
		free (w32);
	}
	return NULL;
}
예제 #15
0
파일: bb.c 프로젝트: BatchDrake/radare2
R_API RAnalBlock *r_anal_bb_new() {
	RAnalBlock *bb = R_NEW (RAnalBlock);
	if (!bb) return NULL;
	memset (bb, 0, sizeof (RAnalBlock));
	bb->addr = -1;
	bb->jump = -1;
	bb->fail = -1;
	bb->type = R_ANAL_BB_TYPE_NULL;
#if R_ANAL_BB_HAS_OPS
	bb->ops = r_anal_op_list_new ();
#endif
	bb->cond = NULL;
	bb->fingerprint = NULL;
	bb->diff = r_anal_diff_new ();
	return bb;
}
예제 #16
0
파일: io_shm.c 프로젝트: BatchDrake/radare2
static RIODesc *shm__open(RIO *io, const char *pathname, int rw, int mode) {
	if (!memcmp (pathname, "shm://", 6)) {
		RIOShm *shm = R_NEW (RIOShm);
		const char *ptr = pathname+6;
		shm->id = getshmid (ptr);
		shm->buf = shmat (shm->id, 0, 0);
		shm->fd = getshmfd (shm);
		shm->size = SHMATSZ;
		if (shm->fd != -1) {
			eprintf ("Connected to shared memory 0x%08x\n", shm->id);
			return r_io_desc_new (&r_io_plugin_shm, shm->fd, pathname, rw, mode, shm);
		}
		eprintf ("Cannot connect to shared memory (%d)\n", shm->id);
		free (shm);
	}
	return NULL;
}
예제 #17
0
static RList* entries(RBinFile *arch)
{
	RList *ret = r_list_new ();
	RBinAddr *ptr = NULL;

	if (arch && arch->buf != NULL) {
		if (!ret)
			return NULL;
		ret->free = free;
		if (!(ptr = R_NEW (RBinAddr)))
			return ret;
		memset (ptr, '\0', sizeof (RBinAddr));
		ptr->offset = ptr->rva = 0x100;
		r_list_append (ret, ptr);
	}
	return ret;
}
예제 #18
0
파일: socket.c 프로젝트: moon2l/radare2
R_API RSocket *r_socket_new (int is_ssl) {
	RSocket *s = R_NEW (RSocket);
	s->is_ssl = is_ssl;
#if HAVE_LIB_SSL
	if (is_ssl) {
		s->sfd = NULL;
		s->ctx = NULL;
		s->bio = NULL;
		if (!SSL_library_init ()) {
			r_socket_free (s);
			return NULL;
		}
		SSL_load_error_strings ();
	}
#endif
	return s;
}
예제 #19
0
static RList* entries(RBinFile *arch) {
	RList* ret = r_list_new ();;
	RBinAddr *ptr = NULL;
	RRarBinObj *bin_obj = arch && arch->o ? arch->o->bin_obj : NULL;
	const ut8 *buf = bin_obj ? r_buf_buffer (bin_obj->buf) : NULL;
	ut64 sz = arch && bin_obj ? r_buf_size (bin_obj->buf) : 0;

	if (!ret) return NULL;
	ret->free = free;
	if (bin_obj && sz > 0x30 && !memcmp (buf+0x30, RAR_CONST, 16)) {
		if ((ptr = R_NEW (RBinAddr))) {
			ptr->vaddr = ptr->paddr = 0x9a;
			r_list_append (ret, ptr);
		}
	}
	return ret;
}
예제 #20
0
static RIODesc *__open(struct r_io_t *io, const char *file, int rw, int mode) {
	if (__plugin_open (io, file, 0)) {
		char *pidpath;
		RIOW32Dbg *dbg = R_NEW (RIOW32Dbg);
		if (dbg == NULL)
			return NULL;
		dbg->pid = atoi (file+9);
		if (__attach (dbg) == -1) {
			free (dbg);
			return NULL;
		}
		pidpath = r_sys_pid_to_path (dbg->pid);
		RETURN_IO_DESC_NEW (&r_io_plugin_w32dbg, -1,
			pidpath, rw | R_IO_EXEC, mode, dbg);
	}
	return NULL;
}
예제 #21
0
파일: io.c 프로젝트: pixilla/radare2
R_API struct r_io_t *r_io_new() {
	RIO *io = R_NEW (RIO);
	if (!io) return NULL;
	io->fd = NULL;
	io->write_mask_fd = -1;
	io->redirect = NULL;
	io->printf = (void*) printf;
	io->plugin = NULL;
	io->raised = -1;
	r_io_cache_init (io);
	r_io_map_init (io);
	r_io_section_init (io);
	r_io_plugin_init (io);
	r_io_desc_init (io);
	r_io_undo_init (io);
	return io;
}
예제 #22
0
파일: map.c 프로젝트: pixilla/radare2
R_API RDebugMap *r_debug_map_new (char *name, ut64 addr, ut64 addr_end, int perm, int user) {
	RDebugMap *map;
	if (name == NULL || addr >= addr_end) {
		eprintf ("r_debug_map_new: error assert(%"PFMT64x">=%"PFMT64x")\n", addr, addr_end);
		return NULL;
	}
	map = R_NEW (RDebugMap);
	if (map) {
		map->name = strdup (name);
		map->addr = addr;
		map->addr_end = addr_end;
		map->size = addr_end-addr;
		map->perm = perm;
		map->user = user;
	}
	return map;
}
예제 #23
0
파일: ht.c 프로젝트: ericfode/radare2
SdbHash* ht_new(void) {
	SdbHash *ht = R_NEW (SdbHash);
	if (!ht) return NULL;
	// TODO: use slices here
	ht->list = ls_new ();
	ht->size = hash_sizes[0].size;
	ht->table = calloc (ht->size, sizeof (*ht->table));
	if (!ht->table) {
		free (ht);
		return NULL;
	}
	ht->size_index = 0;
	ht->entries = 0;
	ht->deleted_entries = 0;
	ht->rehash = hash_sizes[ht->size_index].rehash;
	ht->max_entries = hash_sizes[ht->size_index].max_entries;
	return ht;
}
예제 #24
0
파일: bin_te.c 프로젝트: KarjamP/radare2
static RList* entries(RBinFile *arch) {
	RList* ret;
	RBinAddr *ptr = NULL;
	struct r_bin_te_addr_t *entry = NULL;

	if (!(ret = r_list_new ()))
		return NULL;
	ret->free = free;
	if (!(entry = r_bin_te_get_entrypoint (arch->o->bin_obj)))
		return ret;
	if ((ptr = R_NEW (RBinAddr))) {
		ptr->paddr = entry->paddr;
		ptr->vaddr = entry->vaddr;
		r_list_append (ret, ptr);
	}
	free (entry);
	return ret;
}
예제 #25
0
파일: tree.c 프로젝트: rchiossi/radare2
RAnalType* new_array_node(char* name, short type, short sign, short modifier, long size) {
	RAnalTypeArray *iarr = R_NEW (RAnalTypeArray);
	RAnalType *tmp;
	iarr->name = name;
	iarr->count = size;
	iarr->type = (type & R_ANAL_VAR_TYPE_SIZE_MASK) |
		((sign << R_ANAL_VAR_TYPE_SIGN_SHIFT) & R_ANAL_VAR_TYPE_SIGN_MASK) |
		((modifier << R_ANAL_VAR_TYPE_MODIFIER_SHIFT) & R_ANAL_VAR_TYPE_MODIFIER_MASK);
	tmp = R_NEW0 (RAnalType);
	tmp->next = NULL;
	tmp->type = R_ANAL_TYPE_ARRAY;
	tmp->custom.a = iarr;
	// FIXME: Temporary hack to use global variable
	// Need to remove that in next release
	// and provide proper way to handle global tree
	// outside from this file

	return tmp;
}
예제 #26
0
파일: pool.c 프로젝트: 0xroot/radare2
R_API RMemoryPool *r_mem_pool_new(int nodesize, int poolsize, int poolcount) {
	RMemoryPool *mp = R_NEW (RMemoryPool);
	if (mp) {
		if (poolsize<1)
			poolsize = ALLOC_POOL_SIZE;
		if (poolcount<1)
			poolcount = ALLOC_POOL_COUNT;
		// TODO: assert nodesize?;
		mp->poolsize = poolsize;
		mp->poolcount = poolcount;
		mp->nodesize = nodesize;
		mp->npool = -1;
		mp->ncount = mp->poolsize; // force init
		mp->nodes = (ut8**) malloc (sizeof (void*) * mp->poolcount);
		if (mp->nodes == NULL)
			return NULL;
	}
	return mp;
}
예제 #27
0
파일: ls.c 프로젝트: kolen/radare2
SDB_API SdbListIter *ls_prepend(SdbList *list, void *data) {
	SdbListIter *it = R_NEW (SdbListIter);
	if (!it) {
		return NULL;
	}
	if (list->head) {
		list->head->p = it;
	}
	it->data = data;
	it->n = list->head;
	it->p = NULL;
	list->head = it;
	if (!list->tail) {
		list->tail = it;
	}
	list->length++;
	list->sorted = false;
	return it;
}
예제 #28
0
static RList* entries(RBinArch *arch) {
	RList *ret;
	RBinAddr *ptr = NULL;
	struct r_bin_mach0_addr_t *entry = NULL;

	if (!(ret = r_list_new ()))
		return NULL;
	ret->free = free;
	if (!(entry = MACH0_(r_bin_mach0_get_entrypoint) (arch->bin_obj)))
		return ret;
	if ((ptr = R_NEW (RBinAddr))) {
		memset (ptr, '\0', sizeof (RBinAddr));
		ptr->offset = entry->offset;
		ptr->rva = entry->addr;
		r_list_append (ret, ptr);
	}
	free (entry);
	return ret;
}
예제 #29
0
파일: io_ptrace.c 프로젝트: kuduka/radare2
static RIODesc *__open(struct r_io_t *io, const char *file, int rw, int mode) {
	char *pidpath;
	int ret = -1;
	if (__plugin_open (io, file,0)) {
		int pid = atoi (file+9);
		ret = ptrace (PTRACE_ATTACH, pid, 0, 0);
		if (file[0]=='p')  //ptrace
			ret = 0;
		else
		if (ret == -1) {
#ifdef __ANDROID__
		eprintf ("ptrace_attach: Operation not permitted\n");
#else
			switch (errno) {
			case EPERM:
				ret = pid;
				eprintf ("ptrace_attach: Operation not permitted\n");
				break;
			case EINVAL:
				perror ("ptrace: Cannot attach");
				eprintf ("ERRNO: %d (EINVAL)\n", errno);
				break;
			}
#endif
		} else
		if (__waitpid (pid))
			ret = pid;
		else eprintf ("Error in waitpid\n");
		if (ret != -1) {
			RIODesc *desc;
			RIOPtrace *riop = R_NEW (RIOPtrace);
			riop->pid = riop->tid = pid;
			open_pidmem (riop);
			pidpath = r_sys_pid_to_path (pid);
			desc = r_io_desc_new (&r_io_plugin_ptrace, pid,
				pidpath, R_TRUE, mode, riop);
			free (pidpath);
			return desc;
		}
	}
	return NULL;
}
예제 #30
0
파일: mixed.c 프로젝트: AmesianX/radare2
R_API int r_mixed_key(RMixed *m, int key, int size) {
	if (size>0 && r_mixed_key_check (m, key, size)) {
		if (m->keys[key]) {
			m->keys[key]->size = size;
		} else {
			m->keys[key] = R_NEW (RMixedData);
			if (!m->keys[key])
				return false;
			m->keys[key]->size = size;
			switch (size) {
			case 1: case 2: case 4:
				m->keys[key]->hash.ht = r_hashtable_new ();
				return true;
			case 8: m->keys[key]->hash.ht64 = r_hashtable64_new ();
				return true;
			}
		}
	}
	return false;
}