Esempio n. 1
0
int			parse_exp_rredir(struct s_iterator *i,
					 struct s_btree *node)
{
  struct s_ast_node	*ast;
  struct s_ast_node_cmd	*cmd;
  struct s_token	*t;
  char			*copyfile;

  ast = btree_get(node);
  if (ast == NULL)
    return (-1);
  cmd = &(ast->value.cmd);
  if (cmd->rtype != RT_RUNKNOWN)
    return (fprintf(stderr, "error: multiple right redirections\n"), -1);
  (void) NEXT(i);
  if (!HAS_NEXT(i))
    return (fprintf(stderr,
		    "expected string token after redirection"
		    " but no token was found\n"), -1);
  t = NEXT(i);
  if (t->type != TT_STRING)
    return (fprintf(stderr, "expected string token after redirection\n"), -1);
  if ((copyfile = strdup(t->string._string)) == NULL)
    return (fprintf(stderr, "strdup failed\n"), -1);
  cmd->rtype = RT_RSIMPLE;
  cmd->rredir = copyfile;
  return (0);
}
Esempio n. 2
0
void get(SoupServer *server,
         SoupMessage *msg,
         const char *path)
{

	struct btval key, val;
	key.data = (void*)path+1;
	key.size = strlen(path)-1;
	key.free_data = FALSE;
	key.mp = NULL;
	g_debug ("GET\n Path=%s\n Fetching key %s", path, (char*)key.data);
	const struct btree_stat *stat = btree_stat(btree);
	show_dbstats("",stat);
	if (0 == btree_get(btree,&key,&val)) {
		g_debug ("hmm %s", (char*)val.data);
		GVariant *gv = g_variant_new_from_data(G_VARIANT_TYPE_VARIANT, val.data, val.size, TRUE, NULL, NULL);
		char *debug = g_variant_print (gv, TRUE);
		g_debug ("converted to %s", debug);
		g_free (debug);
		g_variant_unref(gv);
		soup_message_set_status (msg, SOUP_STATUS_OK);
	} else {
		soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
	}
//	soup_message_set_response (msg, "application/json", SOUP_MEMORY_STATIC,
//				   );
}
Esempio n. 3
0
static void *dmd_realloc(void *old, int size, const char *file, int line)
{
	struct dmd_memblock *mb, sb;
	void *p;

	// debug4("realloc %s:%d (%ul -> %i)", file, line,  (unsigned long) old, size);
	sb.ptr = old;
	mb = btree_get(&dmd_tree, &sb);
	if (!mb) {
		putlog(LOG_MISC, "*", "*** DMD: FAILED REALLOC %s:%d (%d). Old pointer not found. This is probably fatal!", file, line, size);
		return NULL;
	}
	p = mb->ptr;
	p = realloc(p, size);
	if (!p) {
		putlog(LOG_MISC, "*", "*** DMD: FAILED REALLOC %s:%d (%d). realloc() returned NULL", file, line, size);
//		fatal("Memory re-allocation failed", 0);
	}
	if (((unsigned long) p) != ((unsigned long) old)) {
//		debug0("newpointer");
		btree_remove(&dmd_tree, mb);
		mb = dmd_create(p, size, line, file);
		btree_add(&dmd_tree, (void *) mb);
	} else {
//		debug0("oldpointer");
		mb->size = size;
/*		p = strrchr(file, '/');
		strncpy(mb->file, p ? p + 1 : file, DMD_FILE_SIZE);
		mb->file[DMD_FILE_SIZE] = 0;
		mb->line = line;*/
	}
	return p;
}
Esempio n. 4
0
File: btree.c Progetto: 111X/radare
int main()
{
	struct btree_node *n, *bt = NULL;
	//btree_init(&bt);

	struct mydata foo = { 10, "hello" };
	struct mydata bar = { 20, "world" };

	printf("EMPTY TREE: %d\n", btree_empty(&bt));
	btree_add(&bt, &foo, mycmp);
	btree_add(&bt, &bar, mycmp);
	printf("EMPTY TREE: %d\n", btree_empty(&bt));

printf("==== go search ====\n");
	/* find existent data */
	struct mydata *p = btree_get(bt, &bar, mycmp);
	shownode("result for 20: ", p);

printf("==== go search ====\n");
	/* find unexistent data */
	struct mydata nop = { 15, NULL };
	p = btree_get(bt, &nop, mycmp);
	shownode("result for 15: ", p);

printf("==== go get hittest ====\n");
	n = btree_hittest(bt, NULL);
	shownode("hitest is: ", p);

printf("==== go remove 20 ====\n");
	if (btree_del(bt, &bar, mycmp, NULL))
		printf("node found and removed\n");
	else printf("oops\n");

printf("==== go search ====\n");
	/* find existent data */
	p = btree_get(bt, &bar, mycmp);
	shownode("result for 20: ", p);

printf("==== go search ====\n");
	/* find existent data */
	p = btree_get(bt, &foo, mycmp);
	shownode("result for 10: ", p);

	btree_cleartree(bt, NULL);
	return 0;
}
Esempio n. 5
0
File: db.cpp Progetto: nyaxt/ptnk
ssize_t
DB::Tx::get(TableOffCache* table, BufferCRef key, BufferRef value)
{
	OverviewPage pgOvv(m_pio->readPage(m_pio->pgidStartPage()));
	page_id_t pgidRoot = pgOvv.getTableRoot(table);
	if(pgidRoot == PGID_INVALID) PTNK_THROW_RUNTIME_ERR("table not found");

	return btree_get(pgidRoot, key, value, m_pio.get());
}
Esempio n. 6
0
static void dmd_free(void *p, const char *file, int line)
{
	struct dmd_memblock *mb, sb;

//	debug2("free %s:%d", file, line);
	sb.ptr = p;
	mb = btree_get(&dmd_tree, &sb);
	if (!mb) {
		putlog(LOG_MISC, "*", "*** DMD: ATTEMPTING TO FREE NON-MALLOC'D PTR: %s:%d",
				file, line);
		return;
	}
	btree_remove(&dmd_tree, mb);
	free(p);
}
Esempio n. 7
0
File: main.c Progetto: wdalmut/tree
static char *test_get_an_existing_node() {
    leaf *root = (leaf *)malloc(sizeof(leaf));
    root->value = 100;

    btree_put(root, 110);
    btree_put(root, 87);
    btree_put(root, 90);
    btree_put(root, 153);
    btree_put(root, 120);
    btree_put(root, 124);

    leaf *node = btree_get(root, 153);

    mu_assert("The value must be present in the tree", node != NULL);
    mu_assert("The value recorded is not '153'", node->value == 153);

    return 0;
}
Esempio n. 8
0
static void *dmd_malloc(int size, const char *file, int line)
{
	struct dmd_memblock *mb;
	void *ptr;

//	debug2("malloc %s:%d", file, line);
	ptr = malloc(size);
//	debug1("ptr: %u", (unsigned long) ptr);
	if (!ptr) {
		putlog(LOG_MISC, "*", "*** DMD: FAILED MALLOC %s (%d) (%d): %s", file, line, size, strerror(errno));
		fatal("Memory allocation failed", 0);
	}
	mb = dmd_create(ptr, size, line, file);
	if (btree_get(&dmd_tree, mb))
		putlog(LOG_MISC, "*", "*** DMD: DOUBLED POINTER?!?!?");
	btree_add(&dmd_tree, (void *) mb);
	return mb->ptr;
}
Esempio n. 9
0
void get(SoupServer *server,
         SoupMessage *msg,
         const char *path)
{

	struct btval key, val;
	key.data = (void*)path+1;
	key.size = strlen(path)-1;
	key.free_data = FALSE;
	key.mp = NULL;
	g_debug ("GET\n Path=%s\n Fetching key %s", path, (char*)key.data);
	const struct btree_stat *stat = btree_stat(btree);
	show_dbstats("",stat);
	if (0 == btree_get(btree,&key,&val)) {
		g_debug ("data checksum is %s", g_compute_checksum_for_data(G_CHECKSUM_MD5, val.data, val.size)); 
		/* we need to make the data 64 bits aligned for gvariant.
		   Best plan is to make all data aligned in the store, but 
		   for now, lets just copy it to somewhere aligned. 
		   TODO: think about fragmentation. it may just be ok, as so far
		   we delete everything we malloc in this function, despite the
		   lifetimes being interleaved.
		*/
		char *buf = g_slice_alloc(val.size + 8);
		char *data = ALIGN_64(buf);
		memcpy (data, val.data, val.size);
		g_debug ("aligned data checksum is %s", g_compute_checksum_for_data(G_CHECKSUM_MD5, data, val.size)); 
		GVariant *gv = g_variant_new_from_data(G_VARIANT_TYPE_VARIANT, data, val.size, TRUE, NULL, NULL);
	
		char *debug = g_variant_print (gv, TRUE);
		g_debug ("converted to %s", debug);
		g_free (debug);

		int length;			
		char* ret = json_gvariant_serialize_data(gv, &length);
		g_variant_unref(gv);
		g_slice_free1 (val.size + 8, buf);
		soup_message_set_status (msg, SOUP_STATUS_OK);
		/*TODO: does soup do anything sensible with it's memory management of responses to reduce the risk of fragmentation?  probably not..*/
		soup_message_set_response (msg, "application/json", SOUP_MEMORY_TAKE, ret, length);
	} else {
		soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
	}
}
Esempio n. 10
0
void db_read_random_test()
{
	uint8_t key[KEYSIZE];
	int all=0,i;
	int start=NUM/2;
	int end=start+R_NUM;
	start_timer();
	for (i = start; i <end ; ++i) 
	{
		memset(key,0,sizeof(key));
		sprintf(key, "%dkey", rand()%(i+1));

		size_t len;
		void *data = btree_get(&btree,key, &len);
		if(data!=NULL)
			all++;
		else
			printf("not found:%s\n",key);

		free(data);

		 if((i%10000)==0)
		{
			fprintf(stderr,"finished %d ops%30s\r",i,"");
			fflush(stderr);
		}     
	}
	printf(LINE);
	double cost=get_timer();
	printf("|readrandom	(found:%ld): %.6f sec/op; %.1f reads /sec(estimated); %.1f MB/sec; cost:%.6f(sec)\n"
	,R_NUM
	,(double)(cost/R_NUM)
	,(double)(R_NUM/cost)
	,(_query_size/cost)
	,cost);
}
Esempio n. 11
0
int main(int argc, char **argv)
{
	const char *fname = "test.dat";

	if (argc < 2)
		return 0;

	srand(time(NULL));

	struct btree btree;
	uint8_t sha1[SHA1_LENGTH];
	char val[100];
	size_t i;

	if (file_exists(fname)) {
		if (btree_open(&btree, fname)) {
			warning("Unable to open database\n");
			return 1;
		}
	} else {
		if (btree_creat(&btree, fname)) {
			warning("Unable to create database\n");
			return 1;
		}
	}

	if (strcmp(argv[1], "insert") == 0) {
		memset(sha1, 0, sizeof sha1);

		start_timer();
		for (i = 0; i < COUNT; ++i) {
			sprintf((char *) sha1, "foobar %zd", i);
			sprintf(val, "value %zd", i*i);
			btree_insert(&btree, sha1, val, strlen(val));
		}
		printf("insert: %.6f\n", get_timer());
	}

	if (strcmp(argv[1], "get") == 0) {
		memset(sha1, 0, sizeof sha1);
		strcpy((char *) sha1, "foobar ");
		strcpy(val, "value ");

		start_timer();
		for (i = 0; i < COUNT; ++i) {
			/* optimize a bit */
			sprintf((char *) sha1 + 7, "%zd", i);
			sprintf(val + 6, "%zd", i*i);

			size_t len;
			void *data = btree_get(&btree, sha1, &len);
			if (data == NULL) {
				warning("not found: %zd\n", i);
				continue;
			}
			if (len != strlen(val) || memcmp(val, data, len)) {
				warning("data mismatch: %zd\n", i);
			}
			free(data);
		}
		printf("get: %.6f\n", get_timer());

	} else if (strcmp(argv[1], "refill") == 0) {
		/* delete half of the data, then add it back */

		memset(sha1, 0, sizeof sha1);
		for (i = 0; i < COUNT/2; i++) {
			sprintf((char *) sha1, "foobar %zd", i);
			if (btree_delete(&btree, sha1))
				warning("not found: %zd\n", i);
		}

		memset(sha1, 0, sizeof sha1);
		for (i = 0; i < COUNT/2; i++) {
			sprintf((char *) sha1, "foobar %zd", i);
			sprintf(val, "value %zd", i*i);
			btree_insert(&btree, sha1, val, strlen(val));
		}

	} else if (strcmp(argv[1], "delete") == 0) {
		memset(sha1, 0, sizeof sha1);

		start_timer();
		for (i = 0; i < COUNT; i++) {
			sprintf((char *) sha1, "foobar %zd", i);
			if (btree_delete(&btree, sha1))
				warning("not found: %zd\n", i);
		}
		printf("delete: %.6f\n", get_timer());

	} else
		warning("unknown command\n");

	btree_close(&btree);

	return 0;
}
Esempio n. 12
0
int
main(int argc, char **argv)
{
	int		 c, rc = BT_FAIL;
	unsigned int	 flags = 0;
	struct btree	*bt;
	struct cursor	*cursor;
	const char	*filename = "test.db";
	struct btval	 key, data, maxkey;

	while ((c = getopt(argc, argv, "rf:")) != -1) {
		switch (c) {
		case 'r':
			flags |= BT_REVERSEKEY;
			break;
		case 'f':
			filename = optarg;
			break;
		}
	}

	argc -= optind;
	argv += optind;

	if (argc == 0)
		errx(1, "missing command");

	bt = btree_open(filename, flags | BT_NOSYNC, 0644);
	if (bt == NULL)
		err(1, filename);

	bzero(&key, sizeof(key));
	bzero(&data, sizeof(data));
	bzero(&maxkey, sizeof(maxkey));

	if (strcmp(argv[0], "put") == 0) {
		if (argc < 3)
			errx(1, "missing arguments");
		key.data = argv[1];
		key.size = strlen(key.data);
		data.data = argv[2];
		data.size = strlen(data.data);
		rc = btree_put(bt, &key, &data, 0);
		if (rc == BT_SUCCESS)
			printf("OK\n");
		else
			printf("FAIL\n");
	} else if (strcmp(argv[0], "del") == 0) {
		if (argc < 1)
			errx(1, "missing argument");
		key.data = argv[1];
		key.size = strlen(key.data);
		rc = btree_del(bt, &key, NULL);
		if (rc == BT_SUCCESS)
			printf("OK\n");
		else
			printf("FAIL\n");
	} else if (strcmp(argv[0], "get") == 0) {
		if (argc < 2)
			errx(1, "missing arguments");
		key.data = argv[1];
		key.size = strlen(key.data);
		rc = btree_get(bt, &key, &data);
		if (rc == BT_SUCCESS) {
			printf("OK %.*s\n", (int)data.size, (char *)data.data);
		} else {
			printf("FAIL\n");
		}
	} else if (strcmp(argv[0], "scan") == 0) {
		if (argc > 1) {
			key.data = argv[1];
			key.size = strlen(key.data);
			flags = BT_CURSOR;
		}
		else
			flags = BT_FIRST;
		if (argc > 2) {
			maxkey.data = argv[2];
			maxkey.size = strlen(key.data);
		}

		cursor = btree_cursor_open(bt);
		while ((rc = btree_cursor_get(cursor, &key, &data,
		    flags)) == BT_SUCCESS) {
			if (argc > 2 && btree_cmp(bt, &key, &maxkey) > 0)
				break;
			printf("OK %zi %.*s\n",
			    key.size, (int)key.size, (char *)key.data);
			flags = BT_NEXT;
		}
		btree_cursor_close(cursor);
	} else if (strcmp(argv[0], "compact") == 0) {
		if ((rc = btree_compact(bt)) != BT_SUCCESS)
			warn("compact");
	} else if (strcmp(argv[0], "revert") == 0) {
		if ((rc = btree_revert(bt)) != BT_SUCCESS)
			warn("revert");
	} else
		errx(1, "%s: invalid command", argv[0]);

	btree_close(bt);

	return rc;
}
Esempio n. 13
0
File: db.cpp Progetto: nyaxt/ptnk
ssize_t
DB::Tx::get(BufferCRef key, BufferRef value)
{
	OverviewPage pgOvv(m_pio->readPage(m_pio->pgidStartPage()));
	return btree_get(pgOvv.getDefaultTableRoot(), key, value, m_pio.get());
}