예제 #1
0
static void
init_mtbl(int fd) {
	struct mtbl_writer_options *writer_options = mtbl_writer_options_init();
	assert(writer_options != NULL);

	mtbl_writer_options_set_block_size(writer_options, 1024);

	struct mtbl_writer *writer = mtbl_writer_init_fd(fd, writer_options);
	assert(writer != NULL);

	/* Populate the mtbl with hex(i)->i */
	for (uint32_t i = 0; i < NUM_KEYS; i++) {
		ubuf *key = ubuf_init(1);
		ubuf *value = ubuf_init(1);

		ubuf_add_fmt(key, KEY_FMT, i);
		ubuf_add_fmt(value, VAL_FMT, i);

		assert(mtbl_writer_add(writer, ubuf_data(key), ubuf_size(key), ubuf_data(value), ubuf_size(value)) == mtbl_res_success);

		ubuf_destroy(&key);
		ubuf_destroy(&value);
	}

	mtbl_writer_destroy(&writer);
	mtbl_writer_options_destroy(&writer_options);
}
예제 #2
0
파일: zonefile.c 프로젝트: hstern/libmy
struct zonefile *
zonefile_init_fname(const char *fname)
{
	struct zonefile *z = my_calloc(1, sizeof(struct zonefile));

	size_t len_fname = strlen(fname);
	if (len_fname >= 3 &&
	    fname[len_fname - 3] == '.' &&
	    fname[len_fname - 2] == 'g' &&
	    fname[len_fname - 1] == 'z')
	{
		ubuf *u = ubuf_new();
		ubuf_add_cstr(u, "zcat ");
		ubuf_add_cstr(u, fname);
		z->fp = popen(ubuf_cstr(u), "r");
		z->is_pipe = true;
		ubuf_destroy(&u);
	} else {
		z->fp = fopen(fname, "r");
	}

	if (z->fp == NULL)
		return (NULL);

	z->valid = true;
	if (read_soa(z) != LDNS_STATUS_OK)
		zonefile_destroy(&z);

	return (z);
}
예제 #3
0
파일: block.c 프로젝트: edmonds/mtbl
void
block_iter_destroy(struct block_iter **bi)
{
    if (*bi != NULL) {
        ubuf_destroy(&(*bi)->key);
        free(*bi);
        *bi = NULL;
    }
}
예제 #4
0
파일: test-vector.c 프로젝트: edmonds/mtbl
static int
test6(void)
{
	int ret = 0;
	ubuf *v = ubuf_init(16);
	ubuf_append(v, (uint8_t *) str_array, sizeof(str_array));
	ubuf_clip(v, 17);
	if (ubuf_size(v) != 17)
		ret |= 1;
	ubuf_destroy(&v);
	return (ret);
}
예제 #5
0
wdns_res
wdns_str_to_rdata(const char * str, uint16_t rrtype, uint16_t rrclass,
		   uint8_t **rdata, size_t *rdlen) {
	ubuf *u;
	wdns_res res;

	u = ubuf_new();
	res = _wdns_str_to_rdata_ubuf(u, str, rrtype, rrclass);
	if (res == wdns_res_success) {
		ubuf_detach(u, (uint8_t **) rdata, rdlen);
	}
	ubuf_destroy(&u);
	return (res);
}
예제 #6
0
char *
wdns_rdata_to_str(const uint8_t *rdata, uint16_t rdlen,
		  uint16_t rrtype, uint16_t rrclass)
{
	char *ret;
	size_t retsz;
	ubuf *u;

	u = ubuf_new();
	_wdns_rdata_to_ubuf(u, rdata, rdlen, rrtype, rrclass);
	ubuf_cterm(u);
	ubuf_detach(u, (uint8_t **) &ret, &retsz);
	ubuf_destroy(&u);
	return (ret);
}
예제 #7
0
파일: test-vector.c 프로젝트: edmonds/mtbl
static int
test3(void)
{
	int ret = 0;
	ubuf *v;

	v = ubuf_init(16);
	ubuf_append(v, (uint8_t *) str_array, sizeof(str_array));
	for (unsigned i = 0; i < ubuf_size(v); i++) {
		//fprintf(stderr, "v->v[%d] = '%c'\n", i, v->v[i]);
		if (ubuf_value(v, i) != str_array[i])
			ret |= 1;
	}
	ubuf_destroy(&v);

	return (ret);
}
예제 #8
0
static void *
thr_producer(void *arg)
{
	struct producer *p = (struct producer *) arg;

	memset(&p->pstat, 0, sizeof(p->pstat));

	for (unsigned i = 0; i < p->num_messages; i++) {
		fstrm_res res;
		size_t len = 0;
		uint8_t *message = NULL;
		ubuf *u = ubuf_init(512);

		unsigned ndups = (p->pstat.count_generated % 4) + 1;
		for (unsigned j = 0; j < ndups; j++)
			ubuf_add_cstr(u, test_string);

		ubuf_detach(u, &message, &len);
		ubuf_destroy(&u);

		res = fstrm_iothr_submit(p->iothr, p->ioq,
			message, len, fstrm_free_wrapper, NULL);
		if (res == fstrm_res_success) {
			p->pstat.count_submitted++;
			p->pstat.bytes_submitted += len;
		} else {
			free(message);
		}
		p->pstat.count_generated++;
		p->pstat.bytes_generated += len;

		if ((i % 1000) == 0)
			poll(NULL, 0, 1);
	}

	return NULL;
}
예제 #9
0
파일: test-vector.c 프로젝트: edmonds/mtbl
static int
test4(void)
{
	int ret = 0;
	ubuf *v;

	v = ubuf_init(0);
	for (unsigned i = 0; i < 1024; i++)
		ubuf_append(v, (uint8_t *) str_array, sizeof(str_array));

	for (unsigned i = 0; i < ubuf_size(v); i++) {
		unsigned j = i % sizeof(str_array);
		/*
		fprintf(stderr, "v->v[%d] = '%c', str_array[%d] = '%c'\n",
			i, v->v[i], j, str_array[j]);
		*/
		if (ubuf_value(v, i) != str_array[j])
			ret |= 1;
	}

	ubuf_destroy(&v);

	return (ret);
}
예제 #10
0
파일: mtbl_merge.c 프로젝트: edmonds/mtbl
static void
init_dso(void)
{
	merge_dso_path = getenv("MTBL_MERGE_DSO");
	merge_dso_prefix = getenv("MTBL_MERGE_FUNC_PREFIX");

	if (merge_dso_path == NULL) {
		fprintf(stderr, "Error: MTBL_MERGE_DSO environment variable not set.\n\n");
		usage();
	}
	if (merge_dso_prefix == NULL) {
		fprintf(stderr, "Error: MTBL_MERGE_FUNC_PREFIX environment variable not set.\n\n");
		usage();
	}

	dlerror();
	void *handle = dlopen(merge_dso_path, RTLD_NOW);
	if (handle == NULL) {
		fprintf(stderr, "Error: dlopen() failed: %s\n", dlerror());
		exit(EXIT_FAILURE);
	}

	/* merge func */
	ubuf *func_name = ubuf_init(0);
	ubuf_append(func_name,
		    (const uint8_t *) merge_dso_prefix,
		    strlen(merge_dso_prefix));
	ubuf_append(func_name,
		    (const uint8_t *) "_func",
		    sizeof("_func"));
	user_func_merge = dlsym(handle, (const char *) ubuf_data(func_name));
	if (user_func_merge == NULL) {
		fprintf(stderr, "Error: user merge function required but not found in DSO.\n\n");
		usage();
	}

	/* init func */
	ubuf_clip(func_name, 0);
	ubuf_append(func_name,
		    (const uint8_t *) merge_dso_prefix,
		    strlen(merge_dso_prefix));
	ubuf_append(func_name,
		    (const uint8_t *) "_init_func",
		    sizeof("_init_func"));
	user_func_init = dlsym(handle, (const char *) ubuf_data(func_name));
	if (user_func_init != NULL)
		user_clos = user_func_init();

	/* free func */
	ubuf_clip(func_name, 0);
	ubuf_append(func_name,
		    (const uint8_t *) merge_dso_prefix,
		    strlen(merge_dso_prefix));
	ubuf_append(func_name,
		    (const uint8_t *) "_free_func",
		    sizeof("_free_func"));
	user_func_free = dlsym(handle, (const char *) ubuf_data(func_name));

	/* cleanup */
	ubuf_destroy(&func_name);
}
예제 #11
0
static void
test_iter(struct mtbl_iter *iter)
{
	/* Iterate completely through the mtbl */
	for (uint32_t i = 0; i < NUM_KEYS; i++) {
		ubuf *expected_key = ubuf_init(1);
		ubuf_add_fmt(expected_key, KEY_FMT, i);

		const uint8_t *key, *value;
		size_t len_key, len_value;

		assert(mtbl_iter_next(iter, &key, &len_key, &value, &len_value) == mtbl_res_success);
		
		assert(bytes_compare(ubuf_data(expected_key), ubuf_size(expected_key), key, len_key) == 0);

		ubuf_destroy(&expected_key);
	}

	/* Ensure that we have completely iterated through the set. */
	{
		const uint8_t *key, *value;
		size_t len_key, len_value;

		assert(mtbl_iter_next(iter, &key, &len_key, &value, &len_value) == mtbl_res_failure);
	}

	/* Seek to a key, ensure that we get the one we want and that we go
	 * all the way to the end. */
	for (uint32_t i = NUM_KEYS; i-- > 0; ) {
		ubuf *seek_key = ubuf_init(1);
		ubuf_add_fmt(seek_key, KEY_FMT, i);

		const uint8_t *key, *value;
		size_t len_key, len_value;

		assert(mtbl_iter_seek(iter, ubuf_data(seek_key), ubuf_size(seek_key)) == mtbl_res_success);
		
		for (uint32_t j = i; j < NUM_KEYS; j++) {
			ubuf *expected_key = ubuf_init(1);
			ubuf_add_fmt(expected_key, KEY_FMT, j);

			assert(mtbl_iter_next(iter, &key, &len_key, &value, &len_value) == mtbl_res_success);
			
			assert(bytes_compare(ubuf_data(expected_key), ubuf_size(expected_key), key, len_key) == 0);

			ubuf_destroy(&expected_key);
		}

		assert(mtbl_iter_next(iter, &key, &len_key, &value, &len_value) == mtbl_res_failure);

		ubuf_destroy(&seek_key);
	}

	/* Attempt to seek past end of iterator */
	ubuf *seek_key = ubuf_init(1);
	const uint8_t *key, *value;
	size_t len_key, len_value;

	ubuf_add_fmt(seek_key, KEY_FMT, NUM_KEYS + 1);
	assert(mtbl_iter_seek(iter, ubuf_data(seek_key), ubuf_size(seek_key)) == mtbl_res_success);
	assert(mtbl_iter_next(iter, &key, &len_key, &value, &len_value) == mtbl_res_failure);
}
예제 #12
0
void
my_fileset_reload(struct my_fileset *fs)
{
	assert(fs != NULL);
	struct fileset_entry *ent, **entptr;
	entry_vec *new_entries;
	FILE *fp;
	char *fname, *line = NULL;
	size_t len = 0;
	ubuf *u;

	if (!setfile_updated(fs))
		return;

	fp = fopen(fs->setfile, "r");
	if (fp == NULL)
		return;

	u = ubuf_init(64);
	new_entries = entry_vec_init(1);

	while (getline(&line, &len, fp) != -1) {
		ubuf_clip(u, 0);
                if (line[0] != '/') { /* if not absolute path, prepend fileset file's path */
                        ubuf_add_cstr(u, fs->setdir);
                        ubuf_add(u, '/');
                }
		ubuf_add_cstr(u, line);
		ubuf_rstrip(u, '\n');
		fname = ubuf_cstr(u);
		if (path_exists(fname)) {
			entptr = fetch_entry(fs->entries, fname);
			if (entptr == NULL) {
				ent = my_calloc(1, sizeof(*ent));
				ent->fname = my_strdup(fname);
				if (fs->load)
					ent->ptr = fs->load(fs, fname);
				entry_vec_add(new_entries, ent);
			} else {
				ent = my_calloc(1, sizeof(*ent));
				ent->fname = my_strdup(fname);
				ent->ptr = (*entptr)->ptr;
				(*entptr)->keep = true;
				entry_vec_add(new_entries, ent);
			}
		}
	}
	free(line);
	fclose(fp);

	qsort(entry_vec_data(new_entries),
	      entry_vec_size(new_entries),
	      sizeof(void *),
	      cmp_fileset_entry);

	for (size_t i = 0; i < entry_vec_size(fs->entries); i++) {
		ent = entry_vec_value(fs->entries, i);
		assert(ent != NULL);
		if (ent->keep == false && fs->unload)
			fs->unload(fs, ent->fname, ent->ptr);
		free(ent->fname);
		free(ent);
	}
	entry_vec_destroy(&fs->entries);
	fs->entries = new_entries;
	ubuf_destroy(&u);
}