/**
* Knowing the user's home directory, TGDB can initialize the m_logger interface
*
* \param tgdb
* The tgdb context.
*
* \param config_dir
* The path to the user's config directory
*
* \return
* -1 on error, or 0 on success
*/
int Ctgdb::Initialize_logger_interface(char *config_dir)
{
/* Get the home directory */
const char *tgdb_log_file = "tgdb_log.txt";
char tgdb_log_path[FSUTIL_PATH_MAX];
fs_util_get_path (config_dir, tgdb_log_file, tgdb_log_path);
/* Initialize the logger */
if (num_loggers == 0)
{
m_logger = logger_create ();
if (!m_logger)
{
printf ("Error: Could not create log file\n");
return -1;
}
}
++num_loggers;
if (logger_set_file (m_logger, tgdb_log_path) == -1)
{
printf ("Error: Could not open log file\n");
return -1;
}
return 0;
}
int global_logger_init(const logger_config_t & conf){
if (G_LOGGER){
return -1;
}
G_LOGGER = logger_create(conf);
return G_LOGGER ? 0 : -1;
}
Reactor *reactor_create()
{
Reactor *u = (void *)malloc(sizeof(Reactor));
memset(u, 0, sizeof(Reactor));
u->logger = logger_create(stdout, LOG_INFO);
u->demux = demux_create(u->logger);
u->signal = signal_create(u->logger, u->demux);
return u;
}
static int
bl_create(char *logdir, int catalog_version)
{
if (restrict_logger)
return LOG_ERR;
restrict_logger = logger_create(0, "sql", logdir, catalog_version, NULL, NULL);
if (restrict_logger)
return LOG_OK;
return LOG_ERR;
}
str
logger_create_wrap( logger *L, int *debug, str *fn, str *dirname, int *version)
{
logger *l = logger_create(*debug, *fn, *dirname, *version, NULL, NULL);
if (l) {
*(logger**)L = l;
return MAL_SUCCEED;
}
throw(MAL, "logger.create", OPERATION_FAILED "database %s version %d" ,
*dirname, *version);
}
/*
* Worker thread: main event loop
*/
static void *worker_libevent(void *arg) {
LIBEVENT_THREAD *me = arg;
/* Any per-thread setup can happen here; memcached_thread_init() will block until
* all threads have finished initializing.
*/
me->l = logger_create();
if (me->l == NULL) {
abort();
}
register_thread_initialized();
event_base_loop(me->base, 0);
return NULL;
}
int main(void)
{
t_logger *logger;
t_queue *queue;
int a;
int *b;
a = 5;
queue = queue_create();
if (queue_enqueue(queue, &a) < 0)
return (-1);
b = (int *)queue_dequeue(queue);
queue_destroy(queue);
logger = logger_create();
logger_write("Ceci est une gestion d\'erreur.\n");
logger_destroy();
return (0);
}
/*
* Worker thread: main event loop
*/
static void *worker_libevent(void *arg) {
LIBEVENT_THREAD *me = arg;
/* Any per-thread setup can happen here; memcached_thread_init() will block until
* all threads have finished initializing.
*/
me->l = logger_create();
me->lru_bump_buf = item_lru_bump_buf_create();
if (me->l == NULL || me->lru_bump_buf == NULL) {
abort();
}
if (settings.drop_privileges) {
drop_worker_privileges();
}
register_thread_initialized();
event_base_loop(me->base, 0);
return NULL;
}
int
main(int argc, char *argv[]) {
int ret = EX_OK;
primwatch_t primwatch;
const char *log_type;
const char *log_facility;
const char *log_prefix;
char log_path[MAXPATHLEN];
const char *pid_file_path;
const char *cntrl_addr;
const char *cntrl_port;
int64_t verbose_level;
if (logger_create()) {
fprintf(stderr, "failed in create logger");
ret = EX_OSERR;
}
if (primwatch_initialize(&primwatch)) {
fprintf(stderr, "failed in initaizliae");
ret = EX_OSERR;
goto last;
}
parse_args(&primwatch, argc, argv);
if (logger_set_foreground(primwatch.foreground)) {
fprintf(stderr, "failed in create logger");
ret = EX_OSERR;
}
if (config_manager_load(primwatch.config_manager, primwatch.config_file)) {
LOG(LOG_LV_ERR, "failed in load config file %s", primwatch.config_file);
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &log_type , "logType", NULL)) {
LOG(LOG_LV_ERR, "failed in get log type from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &log_facility , "logFacility", NULL)) {
LOG(LOG_LV_ERR, "failed in get log facility from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &log_prefix , "logPath", NULL)) {
LOG(LOG_LV_ERR, "failed in get log path from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &pid_file_path , "pidFilePath", NULL)) {
LOG(LOG_LV_ERR, "failed in get pid file path from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &cntrl_addr , "controllerAddress", NULL)) {
LOG(LOG_LV_ERR, "failed in get controller address from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_string(primwatch.config_manager, &cntrl_port , "controllerPort", NULL)) {
LOG(LOG_LV_ERR, "failed in get controller port from config");
ret = EX_DATAERR;
goto last;
}
if (config_manager_get_long(primwatch.config_manager, &verbose_level , "verboseLevel", NULL)) {
LOG(LOG_LV_ERR, "failed in get verbose level from config");
ret = EX_DATAERR;
goto last;
}
snprintf(log_path, sizeof(log_path), "%s.daemon", log_prefix);
if (logger_open((log_level_t)verbose_level, log_type, PROGIDENT, LOG_PID, log_facility, log_path)) {
LOG(LOG_LV_ERR, "failed in open log");
ret = EX_OSERR;
goto last;
}
if (!primwatch.foreground) {
if (daemon(1,1)) {
LOG(LOG_LV_ERR, "failed in daemon");
ret = EX_OSERR;
goto last;
}
setsid();
}
if (primwatch_event_initialize(&primwatch)) {
fprintf(stderr, "failed in initaizliae");
ret = EX_OSERR;
goto last;
}
if (make_pidfile(pid_file_path)) {
LOG(LOG_LV_ERR, "failed in create file of process id");
ret = EX_OSERR;
goto last;
}
if (watcher_polling_start(primwatch.watcher)) {
LOG(LOG_LV_ERR, "failed in initial polling");
ret = EX_OSERR;
goto last;
}
if (controller_start(primwatch.controller, cntrl_addr, cntrl_port)) {
LOG(LOG_LV_ERR, "failed in start controller");
ret = EX_OSERR;
goto last;
}
signal_set(&primwatch.sig_int_event, SIGINT, primwatch_terminate, &primwatch);
event_priority_set(&primwatch.sig_int_event, DEFAULT_EVENT_PRIORITY + 30);
event_base_set(primwatch.event_base, &primwatch.sig_int_event);
signal_add(&primwatch.sig_int_event, NULL);
signal_set(&primwatch.sig_term_event, SIGTERM, primwatch_terminate, &primwatch);
event_priority_set(&primwatch.sig_term_event, DEFAULT_EVENT_PRIORITY + 30);
event_base_set(primwatch.event_base, &primwatch.sig_term_event);
signal_add(&primwatch.sig_term_event, NULL);
signal_set(&primwatch.sig_hup_event, SIGHUP, primwatch_reload, &primwatch);
event_priority_set(&primwatch.sig_hup_event, DEFAULT_EVENT_PRIORITY + 30);
event_base_set(primwatch.event_base, &primwatch.sig_hup_event);
signal_add(&primwatch.sig_hup_event, NULL);
signal_set(&primwatch.sig_chld_event, SIGCHLD, primwatch_sigchild, &primwatch);
event_priority_set(&primwatch.sig_chld_event, DEFAULT_EVENT_PRIORITY + 30);
event_base_set(primwatch.event_base, &primwatch.sig_chld_event);
signal_add(&primwatch.sig_chld_event, NULL);
if (event_base_dispatch(primwatch.event_base) == -1) {
LOG(LOG_LV_ERR, "failed in event base dispatch");
ret = EX_OSERR;
goto last;
}
last:
unlink(pid_file_path);
logger_close();
logger_destroy();
primwatch_finalize(&primwatch);
return ret;
}
// TODO: hoist the storage bits from lru_maintainer_thread in here.
// would be nice if they could avoid hammering the same locks though?
// I guess it's only COLD. that's probably fine.
static void *storage_compact_thread(void *arg) {
void *storage = arg;
useconds_t to_sleep = MAX_STORAGE_COMPACT_SLEEP;
bool compacting = false;
uint64_t page_version = 0;
uint64_t page_size = 0;
uint64_t page_offset = 0;
uint32_t page_id = 0;
bool drop_unread = false;
char *readback_buf = NULL;
struct storage_compact_wrap wrap;
logger *l = logger_create();
if (l == NULL) {
fprintf(stderr, "Failed to allocate logger for storage compaction thread\n");
abort();
}
readback_buf = malloc(settings.ext_wbuf_size);
if (readback_buf == NULL) {
fprintf(stderr, "Failed to allocate readback buffer for storage compaction thread\n");
abort();
}
pthread_mutex_init(&wrap.lock, NULL);
wrap.done = false;
wrap.submitted = false;
wrap.io.data = &wrap;
wrap.io.buf = (void *)readback_buf;
wrap.io.len = settings.ext_wbuf_size;
wrap.io.mode = OBJ_IO_READ;
wrap.io.cb = _storage_compact_cb;
pthread_mutex_lock(&storage_compact_plock);
while (1) {
pthread_mutex_unlock(&storage_compact_plock);
if (to_sleep) {
extstore_run_maint(storage);
usleep(to_sleep);
}
pthread_mutex_lock(&storage_compact_plock);
if (!compacting && storage_compact_check(storage, l,
&page_id, &page_version, &page_size, &drop_unread)) {
page_offset = 0;
compacting = true;
LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_START,
NULL, page_id, page_version);
}
if (compacting) {
pthread_mutex_lock(&wrap.lock);
if (page_offset < page_size && !wrap.done && !wrap.submitted) {
wrap.io.page_version = page_version;
wrap.io.page_id = page_id;
wrap.io.offset = page_offset;
// FIXME: should be smarter about io->next (unlink at use?)
wrap.io.next = NULL;
wrap.submitted = true;
wrap.miss = false;
extstore_submit(storage, &wrap.io);
} else if (wrap.miss) {
LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_ABORT,
NULL, page_id);
wrap.done = false;
wrap.submitted = false;
compacting = false;
} else if (wrap.submitted && wrap.done) {
LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_READ_START,
NULL, page_id, page_offset);
storage_compact_readback(storage, l, drop_unread,
readback_buf, page_id, page_version, settings.ext_wbuf_size);
page_offset += settings.ext_wbuf_size;
wrap.done = false;
wrap.submitted = false;
} else if (page_offset >= page_size) {
compacting = false;
wrap.done = false;
wrap.submitted = false;
extstore_close_page(storage, page_id, page_version);
LOGGER_LOG(l, LOG_SYSEVENTS, LOGGER_COMPACT_END,
NULL, page_id);
}
pthread_mutex_unlock(&wrap.lock);
if (to_sleep > MIN_STORAGE_COMPACT_SLEEP)
to_sleep /= 2;
} else {
if (to_sleep < MAX_STORAGE_COMPACT_SLEEP)
to_sleep += MIN_STORAGE_COMPACT_SLEEP;
}
}
free(readback_buf);
return NULL;
}
static void *storage_write_thread(void *arg) {
void *storage = arg;
// NOTE: ignoring overflow since that would take years of uptime in a
// specific load pattern of never going to sleep.
unsigned int backoff[MAX_NUMBER_OF_SLAB_CLASSES] = {0};
unsigned int counter = 0;
useconds_t to_sleep = WRITE_SLEEP_MIN;
logger *l = logger_create();
if (l == NULL) {
fprintf(stderr, "Failed to allocate logger for storage compaction thread\n");
abort();
}
pthread_mutex_lock(&storage_write_plock);
while (1) {
// cache per-loop to avoid calls to the slabs_clsid() search loop
int min_class = slabs_clsid(settings.ext_item_size);
bool do_sleep = true;
counter++;
if (to_sleep > WRITE_SLEEP_MAX)
to_sleep = WRITE_SLEEP_MAX;
for (int x = 0; x < MAX_NUMBER_OF_SLAB_CLASSES; x++) {
bool did_move = false;
bool mem_limit_reached = false;
unsigned int chunks_free;
int item_age;
int target = settings.ext_free_memchunks[x];
if (min_class > x || (backoff[x] && (counter % backoff[x] != 0))) {
// Long sleeps means we should retry classes sooner.
if (to_sleep > WRITE_SLEEP_MIN * 10)
backoff[x] /= 2;
continue;
}
// Avoid extra slab lock calls during heavy writing.
chunks_free = slabs_available_chunks(x, &mem_limit_reached,
NULL, NULL);
// storage_write() will fail and cut loop after filling write buffer.
while (1) {
// if we are low on chunks and no spare, push out early.
if (chunks_free < target && mem_limit_reached) {
item_age = 0;
} else {
item_age = settings.ext_item_age;
}
if (storage_write(storage, x, item_age)) {
chunks_free++; // Allow stopping if we've done enough this loop
did_move = true;
do_sleep = false;
if (to_sleep > WRITE_SLEEP_MIN)
to_sleep /= 2;
} else {
break;
}
}
if (!did_move) {
backoff[x]++;
} else if (backoff[x]) {
backoff[x] /= 2;
}
}
// flip lock so we can be paused or stopped
pthread_mutex_unlock(&storage_write_plock);
if (do_sleep) {
usleep(to_sleep);
to_sleep *= 2;
}
pthread_mutex_lock(&storage_write_plock);
}
return NULL;
}
int
main(int argc, char*argv[])
{
v4v6_addr_mask_t addr_mask;
revfmt_type_t type;
char str[128];
ASSERT(logger_create() == 0);
ASSERT(addrstr_to_addrmask(&addr_mask, "10.0.0.1") == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(addr_mask.mask == 32);
ASSERT(strcmp(str, "10.0.0.1") == 0);
ASSERT(addrstr_to_addrmask(&addr_mask, "2001::1") == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(addr_mask.mask == 128);
ASSERT(strcmp(str, "2001::1") == 0);
ASSERT(addrstr_to_addrmask(&addr_mask, "10.6.7.0/24") == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(addr_mask.mask == 24);
ASSERT(strcmp(str, "10.6.7.0") == 0);
ASSERT(addrstr_to_addrmask(&addr_mask, "2001:10::0/64") == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(addr_mask.mask == 64);
ASSERT(strcmp(str, "2001:10::") == 0);
ASSERT(addrstr_to_addrmask(&addr_mask, "10.0.5.4/16") == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(addr_mask.mask == 16);
ASSERT(strcmp(str, "10.0.0.0") == 0);
ASSERT(addrstr_to_addrmask(&addr_mask, "2001:10::10:5/32") == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(addr_mask.mask == 32);
ASSERT(strcmp(str, "2001:10::") == 0);
ASSERT(addrstr_to_addrmask(&addr_mask, "1.1.1.3/32") == 0);
ASSERT(addr_mask.mask == 32);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1.1.1.3") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 31);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1.1.1.2") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 30);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1.1.1.0") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 24);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1.1.1.0") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 16);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1.1.0.0") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 8);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1.0.0.0") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "0.0.0.0") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 1);
ASSERT(addrstr_to_addrmask(&addr_mask, "1:1:1:1:1:1:1:3/128") == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(addr_mask.mask == 128);
ASSERT(strcmp(str, "1:1:1:1:1:1:1:3") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 127);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1:1:1:1:1:1:1:2") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 126);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1:1:1:1:1:1:1:0") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 112);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1:1:1:1:1:1:1:0") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 96);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1:1:1:1:1:1::") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 80);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1:1:1:1:1::") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 64);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1:1:1:1::") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 48);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1:1:1::") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 32);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1:1::") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 16);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "1::") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(decrement_mask_b(&addr_mask) == 0);
ASSERT(addr_mask.mask == 0);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "::") == 0);
ASSERT(decrement_mask_b(&addr_mask) == 1);
ASSERT(revaddrstr_to_addrmask(&addr_mask, &type, "1.1.1.10.in-addr.arpa") == 0);
ASSERT(type == REVFMT_TYPE_INADDR_ARPA);
ASSERT(addr_mask.mask == 32);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "10.1.1.1") == 0);
ASSERT(addrmask_to_revaddrstr(str, sizeof(str), &addr_mask, type) == 0);
ASSERT(strcmp(str, "1.1.1.10.in-addr.arpa") == 0);
ASSERT(revaddrstr_to_addrmask(&addr_mask, &type, "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.0.2.ip6.arpa") == 0);
ASSERT(type == REVFMT_TYPE_IP6_ARPA);
ASSERT(addr_mask.mask == 128);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "2001::1") == 0);
ASSERT(addrmask_to_revaddrstr(str, sizeof(str), &addr_mask, type) == 0);
ASSERT(strcmp(str, "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.0.2.ip6.arpa") == 0);
ASSERT(revaddrstr_to_addrmask(&addr_mask, &type, "1.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.2.ip6.arpa") == 0);
ASSERT(type == REVFMT_TYPE_IP6_ARPA);
ASSERT(addr_mask.mask == 128);
ASSERT(inet_ntop(addr_mask.addr.family, &addr_mask.addr.in_addr, str, sizeof(str)) != NULL);
ASSERT(strcmp(str, "2002::11") == 0);
ASSERT(addrmask_to_revaddrstr(str, sizeof(str), &addr_mask, type) == 0);
ASSERT(strcmp(str, "1.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.2.ip6.arpa") == 0);
return 0;
}