void removeUIManagerInterface(Renderer* pRenderer, UIManager* pUIManager)
{
	UNREF_PARAM(pRenderer);
	pUIManager->pUIRenderer->~UIRenderer();
	conf_free(pUIManager->pUIRenderer);

	conf_free(pUIManager);
}

void removeGui(UIManager* pUIManager, Gui* pGui)
{
	ASSERT(pUIManager);
	ASSERT(pGui);
	pGui->pGui->unload();
	pGui->pGui->~UIAppComponentGui();
	conf_free(pGui->pGui);
	pGui->pUI->~UI();
	conf_free(pGui->pUI);
	conf_free(pGui);
}

static void free_val(void *val) {
    conf_value_t *cv = (conf_value_t *)val;
    conf_entry_t *he, *next;
    if (cv->type == CONF_TYPE_ENTRY) {
        he = (conf_entry_t *)cv->value;
        while (he) {
            next = he->next;
            free(he->value);
            free(he);
            he = next;
        }
        free(cv);
    } else if (cv->type == CONF_TYPE_BLOCK) {
        conf_block_t *next_cb, *cb = (conf_block_t*)(cv->value);
        while (cb) {
            next_cb = cb->next;
            conf_free(&cb->block);
            free(cb);
            cb = next_cb;
        }
        free(cv);
    } else {
        /* never get here */
        exit (1);
    }
}

bool HasGSSAPI(const UnicodeString & CustomPath)
{
  static int has = -1;
  if (has < 0)
  {
    Conf * conf = conf_new();
    ssh_gss_liblist * List = nullptr;
    {
      SCOPE_EXIT
      {
        ssh_gss_cleanup(List);
        conf_free(conf);
      };
      Filename * filename = filename_from_str(UTF8String(CustomPath).c_str());
      conf_set_filename(conf, CONF_ssh_gss_custom, filename);
      filename_free(filename);
      List = ssh_gss_setup(conf);
      for (intptr_t Index = 0; (has <= 0) && (Index < List->nlibraries); ++Index)
      {
        ssh_gss_library * library = &List->libraries[Index];
        Ssh_gss_ctx ctx;
        ::ZeroMemory(&ctx, sizeof(ctx));
        has =
          ((library->acquire_cred(library, &ctx) == SSH_GSS_OK) &&
           (library->release_cred(library, &ctx) == SSH_GSS_OK)) ? 1 : 0;
      }
    }

    if (has < 0)
    {
      has = 0;
    }
  }

void test2() {
	struct aug_conf c;
	int argc = 1;
	char *argv[] = {g_argv[0], NULL};
	const char *path = "/tmp/augrc";
	dictionary *ini;
	FILE *f = fopen(path, "w");
	if(f == NULL)
		err(1, "file: %s", path);
	fclose(f);

	diag("blank ini file and no args");
	ini = ciniparser_load(path);
	ok1(ini != NULL);

	conf_init(&c);
	ok1(opt_parse(argc, argv, &c) == 0);
	ok1(opt_set_amt(&c) == 0);
	conf_merge_ini(&c, ini);	
	ok1( compare_conf_vals(&c, &g_default_conf) == 0);

	conf_free(&c);
#define TEST2AMT 4
	
	ciniparser_freedict(ini);
	unlink(path);
}

//---------------------------------------------------------------------------
bool __fastcall HasGSSAPI(UnicodeString CustomPath)
{
  static int has = -1;
  if (has < 0)
  {
    Conf * conf = conf_new();
    ssh_gss_liblist * List = NULL;
    try
    {
      Filename * filename = filename_from_str(UTF8String(CustomPath).c_str());
      conf_set_filename(conf, CONF_ssh_gss_custom, filename);
      filename_free(filename);
      List = ssh_gss_setup(conf);
      for (int Index = 0; (has <= 0) && (Index < List->nlibraries); Index++)
      {
        ssh_gss_library * library = &List->libraries[Index];
        Ssh_gss_ctx ctx;
        memset(&ctx, 0, sizeof(ctx));
        has =
          ((library->acquire_cred(library, &ctx) == SSH_GSS_OK) &&
           (library->release_cred(library, &ctx) == SSH_GSS_OK)) ? 1 : 0;
      }
    }
    __finally
    {
      ssh_gss_cleanup(List);
      conf_free(conf);
    }

    if (has < 0)
    {
      has = 0;
    }
  }

int mwConference_destroy(struct mwConference *conf,
			 guint32 reason, const char *text) {

  struct mwServiceConference *srvc;
  struct mwOpaque info = { 0, 0 };
  int ret = 0;

  g_return_val_if_fail(conf != NULL, -1);

  srvc = conf->service;
  g_return_val_if_fail(srvc != NULL, -1);

  /* remove conference from the service */
  srvc->confs = g_list_remove_all(srvc->confs, conf);

  /* close the channel if applicable */
  if(conf->channel) {
    if(text && *text) {
      info.len = strlen(text);
      info.data = (guchar *) text;
    }

    ret = mwChannel_destroy(conf->channel, reason, &info);
  }
  
  /* free the conference */
  conf_free(conf);

  return ret;
}

int main(int argc, char *argv[])
{
	plan(TESTS_COUNT + 1);

	mm_ctx_t mm;
	mm_ctx_mempool(&mm, MM_DEFAULT_BLKSIZE);

	conf_remote_t remote;
	memset(&remote, 0, sizeof(conf_remote_t));
	sockaddr_set(&remote.addr, AF_INET, "127.0.0.1", 0);
	sockaddr_set(&remote.via, AF_INET, "127.0.0.1", 0);

	/* Create fake server environment. */
	server_t server;
	int ret = create_fake_server(&server, &mm);
	ok(ret == KNOT_EOK, "requestor: initialize fake server");

	/* Initialize requestor. */
	struct knot_requestor requestor;
	knot_requestor_init(&requestor, &mm);
	knot_requestor_overlay(&requestor, &dummy_module, NULL);

	/* Test requestor in disconnected environment. */
	test_disconnected(&requestor, &remote);

	/* Bind to random port. */
	int origin_fd = net_bound_socket(SOCK_STREAM, &remote.addr, 0);
	assert(origin_fd > 0);
	socklen_t addr_len = sockaddr_len((struct sockaddr *)&remote.addr);
	getsockname(origin_fd, (struct sockaddr *)&remote.addr, &addr_len);
	ret = listen(origin_fd, 10);
	assert(ret == 0);

	/* Responder thread. */
	pthread_t thread;
	pthread_create(&thread, 0, responder_thread, &origin_fd);

	/* Test requestor in connected environment. */
	test_connected(&requestor, &remote);

	/*! \todo #243 TSIG secured requests test should be implemented. */

	/* Terminate responder. */
	int responder = net_connected_socket(SOCK_STREAM, &remote.addr, NULL, 0);
	assert(responder > 0);
	tcp_send_msg(responder, (const uint8_t *)"", 1, NULL);
	(void) pthread_join(thread, 0);
	close(responder);

	/* Close requestor. */
	knot_requestor_clear(&requestor);
	close(origin_fd);

	/* Cleanup. */
	mp_delete((struct mempool *)mm.ctx);
	server_deinit(&server);
	conf_free(conf(), false);

	return 0;
}

static void raw_free(void *handle)
{
    Raw raw = (Raw) handle;

    if (raw->s)
	sk_close(raw->s);
    conf_free(raw->conf);
    sfree(raw);
}

int main(int argc, char **argv)
{
	struct sigaction sig_stop;
	struct sigaction sig_time;

	_main = main_init(argc, argv);
	_log = log_init();
	_main->conf = conf_init(argc, argv);
	_main->work = work_init();

	_main->tcp = tcp_init();
	_main->node = node_init();
	_main->mime = mime_init();

	/* Check configuration */
	conf_print();

	/* Catch SIG INT */
	unix_signal(&sig_stop, &sig_time);

	/* Fork daemon */
	unix_fork(log_console(_log));

	/* Increase limits */
	unix_limits(_main->conf->cores, CONF_EPOLL_MAX_EVENTS);

	/* Load mime types */
	mime_load();
	mime_hash();

	/* Prepare TCP daemon */
	tcp_start();

	/* Drop privileges */
	unix_dropuid0();

	/* Start worker threads */
	work_start();

	/* Stop worker threads */
	work_stop();

	/* Stop TCP daemon */
	tcp_stop();

	mime_free();
	node_free();
	tcp_free();

	work_free();
	conf_free();
	log_free(_log);
	main_free();

	return 0;
}

void log_free(void *handle)
{
    struct LogContext *ctx = (struct LogContext *)handle;

    logfclose(ctx);
    bufchain_clear(&ctx->queue);
    if (ctx->currlogfilename)
        filename_free(ctx->currlogfilename);
    conf_free(ctx->conf);
    sfree(ctx);
}

static void clear(struct mwServiceConference *srvc) {
  struct mwConferenceHandler *h;

  while(srvc->confs)
    conf_free(srvc->confs->data);

  h = srvc->handler;
  if(h && h->clear)
    h->clear(srvc);
  srvc->handler = NULL;
}

static void rlogin_free(void *handle)
{
    Rlogin rlogin = (Rlogin) handle;

    if (rlogin->prompt)
        free_prompts(rlogin->prompt);
    if (rlogin->s)
	sk_close(rlogin->s);
    conf_free(rlogin->conf);
    sfree(rlogin);
}

END_TEST

START_TEST (test_conf_add_group)
{
  configuration *conf;
  int ret;

  conf = conf_create ();
  fail_unless (conf != 0);

  ret = conf_add_group (conf, NULL, head_group);
  fail_unless (ret == 0);
  conf_free (conf);

  conf = conf_create ();
  fail_unless (conf != 0);
  ret = conf_add_group (conf, "agroup", head_group);
  fail_unless (ret == 0);

  conf_free (conf);
}

void test5() {
	struct aug_conf c;
	char *argv[] = {g_argv[0], "--no-color", NULL};
	int argc = AUG_ARRAY_SIZE(argv) - 1;

	diag("does the no color flag work?");
	conf_init(&c);
	ok1(opt_parse(argc, argv, &c) == 0);
	ok1(c.nocolor != false);
	ok1(opt_set_amt(&c) == 1);
	
#define TEST5AMT 3
	conf_free(&c);
}

void test1() {
	struct aug_conf c;
	int argc = 1;
	char *argv[] = {g_argv[0], NULL};

	conf_init(&c);
	diag("no ini file and no args");
	ok1(opt_parse(argc, argv, &c) == 0);
	ok1(opt_set_amt(&c) == 0);
	ok1( compare_conf_vals(&c, &g_default_conf) == 0);

	conf_free(&c);
#define TEST1AMT 3
}

static int reload_from_client_confs(struct cstat **clist, struct conf *conf)
{
	struct cstat *c;
	static struct conf *cconf=NULL;

	if(!cconf && !(cconf=conf_alloc())) goto error;

	for(c=*clist; c; c=c->next)
	{
		// Look at the client conf files to see if they have changed,
		// and reload bits and pieces if they have.
		struct stat statp;

		if(!c->conffile) continue;

		if(stat(c->conffile, &statp)
		  || !S_ISREG(statp.st_mode))
		{
			cstat_remove(clist, &c);
			continue;
		}
		if(statp.st_mtime==c->conf_mtime)
		{
			// conf file has not changed - no need to do anything.
			continue;
		}
		c->conf_mtime=statp.st_mtime;

		conf_free_content(cconf);
		if(!(cconf->cname=strdup_w(c->name, __func__)))
			goto error;
		if(conf_set_client_global(conf, cconf)
		  || conf_load(c->conffile, cconf, 0))
		{
			cstat_remove(clist, &c);
			continue;
		}

		if(set_cstat_from_conf(c, cconf))
			goto error;
	}
	return 0;
error:
	conf_free(cconf);
	cconf=NULL;
	return -1;
}

struct conf_entry *conf_parse(FILE *f)
{
  struct conf_entry *head = NULL;
  struct conf_entry *tail = NULL;
  char buf[CONF_MAX_LINE];

  while (fgets(buf, sizeof(buf), f)) {
    struct conf_entry *e;
    char *start = buf;
    char *key;
    char *val;

    strip_newlines(start);
    start = eat_whitespace(start);
    if (is_ignored_line(start))
      continue;

    key = strtok(start, " \t");
    val = strtok(NULL, "");
    if (val)
      val = eat_whitespace(val);
    e = (struct conf_entry *) malloc(sizeof *e);
    if (!e)
      goto fail;
    e->next = NULL;
    e->key = strdup(key);
    e->value = val ? strdup(val) : NULL;
    if (!e->key || (val && !e->value)) {
      free(e->key);
      free(e->value);
      free(e);
      goto fail;
    }
    if (!head) {
      head = e;
      tail = e;
    } else {
      tail->next = e;
      tail = e;
    }
  }

  return head;
fail:
  conf_free(head);
  return NULL;
}

void kadnode_loop(void)
{
	if (gconf && gconf->is_running == 0) {
		conf_check();

		main_setup();

		// Loop over all sockets and file descriptors
		net_loop();

		// Export peers if a file is provided
		peerfile_export();

		main_free();

		conf_free();
	}
}

void test3() {
	struct aug_conf c;
	int argc = 1;
	char *argv[] = {g_argv[0], NULL};
	const char *path = "/tmp/augrc";
	dictionary *ini;
	const char *ncterm;
	FILE *f = fopen(path, "w");
	if(f == NULL)
		err(1, "file: %s", path);

	fprintf(f, "[" CONF_CONFIG_SECTION_CORE "]\n\n");
	fprintf(f, "ncterm = screen ;\n");
	fclose(f);
	diag("ini file overrides default");
	ini = ciniparser_load(path);
	ok1(ini != NULL);

	conf_init(&c);
	ok1(opt_parse(argc, argv, &c) == 0);
	ok1(opt_set_amt(&c) == 0);
	ok1( compare_conf_vals(&c, &g_default_conf) == 0);
	ncterm = NULL;
	ncterm = ciniparser_getstring(ini, CONF_CONFIG_SECTION_CORE ":ncterm", NULL);
	ok1( ncterm != NULL);
	if(ncterm == NULL)
		return;
	ok1( strcmp(ncterm, "screen") == 0 );

	conf_merge_ini(&c, ini);
	ok1( c.ncterm != NULL );
	if(c.ncterm == NULL)
		return;
	ok1( strcmp(c.ncterm, "screen") == 0 );
	c.ncterm = CONF_NCTERM_DEFAULT;
	ok1( compare_conf_vals(&c, &g_default_conf) == 0);
	
	conf_free(&c);
#define TEST3AMT 9

	ciniparser_freedict(ini);
	unlink(path);
}