/* free a binary tree */
void btree_free(BTree *tree)
{
if (tree->left != NULL)
btree_free(tree->left);
if (tree->right != NULL)
btree_free(tree->right);
free(tree->str);
free(tree);
}
void btree_free(BTree *tree)
{
if (tree != NULL)
{
btree_free(tree->left);
btree_free(tree->right);
if (tree->str != NULL)
{
free(tree->str);
}
free(tree);
}
}
void btree_free(BTree *tree)
{
if (tree == NULL) {
return;
}
if (tree->right != NULL) {
btree_free(tree->right);
}
if (tree->left != NULL) {
btree_free(tree->left);
}
free(tree->str);
free(tree);
}
int main(void)
{
btree_tree *tmp;
uint32_t data_idx;
size_t size;
time_t ts;
char *data;
int i;
char testdata[11];
// testing too large data
tmp = btree_create("test.mmap", 102, 204, 10);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
for (i = 0; i < 205; i++) {
if (btree_insert(tmp, i * 3, &data_idx)) {
sprintf(testdata, "H: %07d", i);
btree_set_data(tmp, data_idx, testdata, 10, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
}
btree_dump(tmp);
btree_free(tmp);
return 0;
}
int main() {
BTree *tree;
BTree *find;
int depth;
char *array[11];
array[0] = "5";
array[1] = "1";
array[2] = "6";
array[3] = "9";
array[4] = "0";
array[5] = "4";
array[6] = "3";
array[7] = "8";
array[8] = "2";
array[9] = "7";
array[10] = "4";
tree = array_to_btree(array);
/*print_preorder(tree);*/
printLevelOrder(tree,5);
depth = btree_depth(tree);
printf("d_array:%d\n", depth);
find = btree_find(tree, "A");
/*print_preorder(find);*/
if(find == NULL){
printf("Not found.\n");
}else{
printLevelOrder(find,5);
}
btree_free(tree);
test_insert();
return 0;
}
int test_insert() {
BTree *tree;
BTree *find;
int depth;
tree = NULL;
printf("The numbers should be in ascending order.\n");
btree_insert(&tree, "5");
btree_insert(&tree, "1");
btree_insert(&tree, "6");
btree_insert(&tree, "9");
btree_insert(&tree, "0");
btree_insert(&tree, "4");
btree_insert(&tree, "3");
btree_insert(&tree, "8");
btree_insert(&tree, "2");
btree_insert(&tree, "7");
btree_insert(&tree, "4");
/*print_preorder(tree);*/
printLevelOrder(tree,5);
depth = btree_depth(tree);
printf("d_single:%d\n", depth);
find = btree_find(tree, "Z");
/*print_preorder(find);*/
if(find == NULL){
printf("Not found.\n");
}else{
printLevelOrder(find,5);
}
btree_free(tree);
return 0;
}
void
h_table_free( h_table_t *table )
{
btree_free( table->tree );
free( table->data_arr );
}
int main(int argc, char *argv[])
{
btree_tree *tmp;
FILE *f;
char urlBuffer[2048], *data;
uint64_t id;
uint64_t i = 0;
uint32_t data_idx;
tmp = btree_create("test.mmap", 128, 700000, 2048);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
f = fopen(argv[1], "r");
while (!feof(f)) {
fgets(urlBuffer, 2048, f);
data = strchr(urlBuffer, ' ');
if (data) {
data++;
data[-1] = '\0';
id = atoll(urlBuffer);
if (btree_insert(tmp, id, &data_idx) == 1) {
btree_set_data(tmp, data_idx, data, strlen(data), time(NULL));
}
}
i++;
}
btree_free(tmp);
return 0;
}
int main(void)
{
btree_tree *tmp;
uint32_t data_idx;
tmp = btree_create("test.mmap", 3, 400, 1024);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
setup(tmp);
btree_insert(tmp, 'd', &data_idx);
btree_insert(tmp, 'f', &data_idx);
btree_insert(tmp, 'v', &data_idx);
btree_delete(tmp, 'i');
btree_delete(tmp, 'f');
btree_delete(tmp, 'e');
btree_delete(tmp, 'y');
btree_delete(tmp, 't');
btree_dump_dot(tmp);
btree_free(tmp);
return 0;
}
static int L_readini( lua_State* L )
{
const char* filename;
inifile_t* inifile = NULL;
inireader_iterator_t* iter = NULL;
inireader_entry_t* current = NULL;
btree_element_t* root = NULL;
btree_element_t* groupelement = NULL;
btree_element_t* grouproot = NULL;
PARAM_STRING( filename );
if ( ( inifile = inireader_open( filename ) ) == NULL )
{
return_error();
}
// Add every entry into a btree to get the arrays and groups in one piece later
DEBUGLOG( "Creating btree" );
root = btree_create();
iter = inireader_get_iterator( inifile, 0, 0, 0, 0 );
DEBUGLOG( "Filling up btree" );
for ( current = inireader_iterate( iter ); current != NULL; current = inireader_iterate( iter ) )
{
DEBUGLOG( "Searching for or adding group: %s", current->group );
// Find group element
groupelement = btree_find( root, current->group );
if ( groupelement == NULL )
{
// A new grouproot needs to be created
DEBUGLOG( "Creating new grouproot" );
grouproot = btree_create();
btree_add( &root, current->group, grouproot );
}
else
{
// Retrieve the already added grouproot
DEBUGLOG( "Setting grouproot" );
grouproot = ( btree_element_t* )groupelement->data;
}
// Add the new element to the grouptree
btree_add( &grouproot, current->identifier, current );
}
// Traverse the tree and put our inivalues onto the lua stack
DEBUGLOG( "Creating initial lua table" );
lua_newtable( L );
readini_tree_traverse( L, root );
DEBUGLOG( "Freeing the btree data" );
// Free the group trees
readini_tree_free( root );
// Free the main tree
btree_free( root );
// Close the inifile
inireader_close( inifile );
return 1;
}
extern void function_free(Function* f) {
if(f->tree != 0) ftree_free(f->tree);
if(f->fmd != 0) ftree_free(f->fmd);
if(f->btree != 0) btree_free(f->btree);
if(f->table != 0) btable_free(f->table);
if(f->symbol != 0) free(f->symbol);
if(f->vars != 0) free(f->vars);
}
static
void free_index(void *index, enum index_type type) {
if (index == NULL) return;
switch(type) {
case SORTED: sindex_free(index); return;
case BTREE: btree_free(index); return;
case IDX_INVALID: assert(false);
}
}
int main() {
printf("Test BTree\n");
btree_t *btree = btree_create();
if (!btree)
return 1;
btree_free(btree);
printf("Done.\n");
return 0;
}
static void readini_tree_free( btree_element_t* root )
{
// Traverse every node and free the subtree
if ( root->left != NULL )
{
readini_tree_free( root->left );
}
if( root->right != NULL )
{
readini_tree_free( root->right );
}
// Free the subtree
btree_free( ( btree_element_t* )root->data );
}
void setcache(char *folder, char *searchstring, url_llist *urls)
{
long i, j;
urlinfo *url;
indexed_url *iurl;
url_node *node = urls->front;
btree indexed_urls;
btree_init(&indexed_urls, (void *)indexed_urlcompare);
// loop 1: index urls
for (i = 0; i < urls->size; i++)
{
indexed_url *iurl = malloc(sizeof(indexed_url));
iurl->url = node->url;
iurl->index = i;
btree_insert(&indexed_urls, iurl);
node = node->next;
}
// open file for write
char *modifiedsearch = tounderline(searchstring);
char *path = getpath(folder, modifiedsearch);
FILE *file = fopen(path, "w");
// write number of links
fprintf(file, "%d\n", urls->size);
// loop 2: write data
node = urls->front;
indexed_url urltofind;
for (i = 0; i < urls->size; i++)
{
url = node->url;
/*
* Write url data
* format: index url numlinks
* link1 link2 link3
*/
// write header
char *urlstring = url_tostring(url);
fprintf(file, "%s %d\n", urlstring, url->outlinks.size);
free(urlstring);
// write links
lnode *outlink_node = url->outlinks.front;
for (j = 0; j < url->outlinks.size; j++)
{
// find indexed url so its index can be recorded
urltofind.url = outlink_node->data;
indexed_url *iurl = btree_find(&indexed_urls, &urltofind);
// write it, followed by a space
fprintf(file, "%lu ", iurl->index);
outlink_node = outlink_node->next;
}
if (url->outlinks.size)
fprintf(file, "\n");
node = node->next;
}
btree_free(&indexed_urls, 1);
free(modifiedsearch);
free(path);
close(file);
}
/**
* Get function addr list from call search basic
* @param file target file
* @param addr address list
*/
int elfsh_addr_get_func_list(elfshobj_t *file, eresi_Addr **addr)
{
int ret;
int index;
asm_instr instr;
elfsh_SAddr foffset;
elfsh_Word len;
char *base;
asm_processor proc;
eresi_Addr base_vaddr, caddr;
u_char found = 0;
elfshsect_t *text;
eresi_Addr *vaddr;
const int astep = 20;
u_int apos = 0;
btree_t *broot = NULL;
u_int diff;
PROFILER_IN(__FILE__, __FUNCTION__, __LINE__);
if (!file || !addr)
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"Invalid parameters", -1);
/* Search entrypoint section, our address must be in this section */
text = elfsh_get_parent_section(file, elfsh_get_entrypoint(file->hdr), &foffset);
if (!text)
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"Cannot find parent section from entry point", -1);
if (!elfsh_get_anonymous_section(file, text))
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"Unable to get an anonymous section", -1);
base = elfsh_readmem(text);
len = text->shdr->sh_size;
/* Get the virtual address */
base_vaddr = (elfsh_is_runtime_mode() && !elfsh_section_is_runtime(text) ?
file->rhdr.base + elfsh_get_section_addr(text->shdr) :
elfsh_get_section_addr(text->shdr));
/* Setup asm_processor structure */
if (etrace_setup_proc(file, &proc) < 0)
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"Failed during proc structure setup", -1);
XALLOC(__FILE__, __FUNCTION__, __LINE__, vaddr, sizeof(eresi_Addr)*astep, -1);
/* Despite the fact that we choose the right architecture to init asm,
Our approach is totally architecture independant as we search using
global type ASM_TYPE_CALLPROC and we know that op[0].imm will contain a
relative value. */
for (index = 0; index < len; index += ret)
{
/* Read an instruction */
if ((ret = asm_read_instr(&instr, (u_char *) (base + index), len - index, &proc)))
{
/* Global assembler filter */
if ((instr.type & ASM_TYPE_CALLPROC)
&& instr.op[0].imm != 0)
{
caddr = base_vaddr + index + instr.op[0].imm + instr.len;
/* Found a call check its local */
if (INTERVAL(base_vaddr, caddr, base_vaddr + len))
{
found = 1;
diff = (u_int) caddr;
/* Avoid double entrie */
if (btree_get_elem(broot, diff) != NULL)
goto next;
btree_insert(&broot, diff, (void *)0x1);
/* Next will be the last of the current list
then realloc */
if ((apos+1) % astep == 0)
{
XREALLOC(__FILE__, __FUNCTION__, __LINE__, vaddr, vaddr,
sizeof(eresi_Addr)*(apos+1+astep), -1);
/* Blank new elements */
memset(&vaddr[apos], 0x00, astep*sizeof(eresi_Addr));
}
vaddr[apos++] = caddr;
}
}
}
next:
if (ret <= 0)
ret = 1;
}
/* If nothing found we free allocated buffer and
return an error */
if (!found)
{
XFREE(__FILE__, __FUNCTION__, __LINE__, vaddr);
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"No call internal found", -3);
}
btree_free(broot, 0);
*addr = vaddr;
PROFILER_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
}
int main(void)
{
btree_tree *tmp;
uint32_t data_idx;
char data[1024];
memset(data, 4, 1023);
memset(data+1023, 0, 1);
tmp = btree_create("test.mmap", 3, 400, 1024);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
btree_insert(tmp, 'A', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'L', &data_idx); printf("%u\n", data_idx);
memcpy(tmp->data + data_idx * 1024, data, 1024);
btree_insert(tmp, 'D', &data_idx); printf("%u\n", data_idx);
memcpy(tmp->data + data_idx * 1024, data, 1024);
btree_insert(tmp, 'F', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, '4', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, '2', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, '3', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, '5', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, '1', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'N', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'P', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'd', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'f', &data_idx); printf("%u\n", data_idx); /* */
btree_insert(tmp, 'n', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'p', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'H', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'C', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'B', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'E', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'G', &data_idx); printf("%u\n", data_idx); /* */
btree_insert(tmp, 'I', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'K', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'J', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'M', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'o', &data_idx); printf("%u\n", data_idx); /* */
btree_insert(tmp, 'q', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'r', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'i', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'j', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'k', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 's', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 't', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'm', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'O', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'Q', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'R', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'S', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'T', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'U', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'x', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'w', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'y', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'u', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'v', &data_idx); printf("%u\n", data_idx);
btree_dump_dot(tmp);
btree_free(tmp);
return 0;
}
int main(void)
{
btree_tree *tmp;
uint32_t data_idx;
char data[1024];
memset(data, 4, 1023);
memset(data+1023, 0, 1);
tmp = btree_create("test.mmap", 3, 400, 1024);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
/* Testing one node in the root only */
btree_insert(tmp, 'A', &data_idx); printf("%u\n", data_idx);
btree_dump(tmp);
btree_delete(tmp, 'A');
btree_dump(tmp);
/* Testing two node in the root only (1) */
btree_insert(tmp, 'G', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'Q', &data_idx); printf("%u\n", data_idx);
btree_dump(tmp);
btree_delete(tmp, 'G');
btree_dump(tmp);
/* - cleanup for next test */
btree_delete(tmp, 'Q');
/* Testing two node in the root only (2) */
btree_insert(tmp, 'G', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'Q', &data_idx); printf("%u\n", data_idx);
btree_dump(tmp);
btree_delete(tmp, 'Q');
btree_dump(tmp);
/* - cleanup for next test */
btree_delete(tmp, 'G');
/* Testing with full root node */
btree_insert(tmp, 'E', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'A', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'P', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'F', &data_idx); printf("%u\n", data_idx);
btree_insert(tmp, 'Q', &data_idx); printf("%u\n", data_idx);
btree_dump(tmp);
/* - remove last node */
btree_delete(tmp, 'Q');
btree_dump(tmp);
/* - remove middle node */
btree_delete(tmp, 'E');
btree_dump(tmp);
/* - remove first node */
btree_delete(tmp, 'A');
btree_dump(tmp);
btree_free(tmp);
return 0;
}
void btree_Free(btree_t *t)
{
if (!t) return;
btree_free(t);
free(t);
}
int main(void)
{
btree_tree *tmp;
uint32_t data_idx;
size_t size;
time_t ts;
char *data;
// testing too large data
tmp = btree_create("test.mmap", 3, 6, 10);
if (!tmp) {
printf("Couldn't create tree from disk image.\n");
exit(1);
}
if (btree_insert(tmp, 'X', &data_idx)) {
btree_set_data(tmp, data_idx, "HelloWorl1", 10, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
if (btree_insert(tmp, 'Q', &data_idx)) {
btree_set_data(tmp, data_idx, "HelloWorld2", 10, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
if (btree_insert(tmp, 'D', &data_idx)) {
btree_set_data(tmp, data_idx, "HelloWorld3", 11, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
if (btree_insert(tmp, 'Z', &data_idx)) {
btree_set_data(tmp, data_idx, "HelloWorl4", 11, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
if (btree_insert(tmp, 'A', &data_idx)) {
btree_set_data(tmp, data_idx, "HelloWorl5", -1, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
if (btree_insert(tmp, 'C', &data_idx)) {
btree_set_data(tmp, data_idx, "HelloWorl6", 0, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
if (btree_insert(tmp, 'G', &data_idx)) {
btree_set_data(tmp, data_idx, "TooMany1", 8, time(NULL));
data = (char*) btree_get_data(tmp, data_idx, &size, &ts);
printf("%s %zd\n", data, size);
}
btree_dump(tmp);
btree_free(tmp);
return 0;
}
int main(int argc, char **argv) {
struct btree *bt;
uint64_t ptr;
int j, count, op, arg;
if (argc != 4) {
fprintf(stderr,"Usage: btree_example <op> <size/ptr> <count>\n");
exit(1);
}
count = atoi(argv[3]);
arg = atoi(argv[2]);
if (!strcasecmp(argv[1],"alloc")) {
op = OP_ALLOC;
} else if (!strcasecmp(argv[1],"free")) {
op = OP_FREE;
} else if (!strcasecmp(argv[1],"allocfree")) {
op = OP_ALLOCFREE;
} else if (!strcasecmp(argv[1],"add")) {
op = OP_ADD;
} else if (!strcasecmp(argv[1],"walk")) {
op = OP_WALK;
} else if (!strcasecmp(argv[1],"fill")) {
op = OP_FILL;
} else if (!strcasecmp(argv[1],"find")) {
op = OP_FIND;
} else {
printf("not supported op %s\n", argv[1]);
exit(1);
}
bt = btree_open(NULL, "./btree.db", BTREE_CREAT);
btree_clear_flags(bt,BTREE_FLAG_USE_WRITE_BARRIER);
if (bt == NULL) {
perror("btree_open");
exit(1);
}
for (j = 0; j < count; j++) {
if (op == OP_ALLOC) {
ptr = btree_alloc(bt,arg);
printf("PTR: %llu\n", ptr);
} else if (op == OP_FREE) {
btree_free(bt,arg);
} else if (op == OP_ALLOCFREE) {
ptr = btree_alloc(bt,arg);
printf("PTR: %llu\n", ptr);
btree_free(bt,ptr);
}
}
if (op == OP_ADD) {
int retval;
char key[16];
memset(key,0,16);
strcpy(key,argv[2]);
retval = btree_add(bt,(unsigned char*)key,
(unsigned char*)argv[3],strlen(argv[3]),1);
printf("retval %d\n", retval);
if (retval == -1) {
printf("Error: %s\n", strerror(errno));
}
} else if (op == OP_WALK) {
btree_walk(bt,bt->rootptr);
} else if (op == OP_FILL) {
for (j = 0; j < count; j++) {
int r = random()%arg;
int retval;
char key[64];
char val[64];
memset(key,0,64);
snprintf(key,64,"k%d",r);
snprintf(val,64,"val:%d",r);
retval = btree_add(bt,(unsigned char*)key,
(unsigned char*)val, strlen(val), 1);
if (retval == -1) {
printf("Error: %s\n", strerror(errno));
goto err;
}
}
} else if (op == OP_FIND) {
int retval;
char key[16], *data;
memset(key,0,16);
strcpy(key,argv[2]);
uint64_t voff;
uint32_t datalen;
retval = btree_find(bt,(unsigned char*)key,&voff);
if (retval == -1) {
if (errno == ENOENT) {
printf("Key not found\n");
exit(0);
} else {
perror("Error searching for key");
exit(1);
}
}
printf("Key found at %llu\n", voff);
btree_alloc_size(bt,&datalen,voff);
data = malloc(datalen+1);
btree_pread(bt,(unsigned char*)data,datalen,voff);
data[datalen] = '\0';
printf("Value: %s\n", data);
free(data);
}
btree_close(bt);
return 0;
err:
btree_close(bt);
return 1;
}
