int load_config(char *config)
{
	char buffer[512];
	int ret;

	if ((ret = config_open(config)) < 0)
	{
		// failed to load
		printf("\x1B[31mFailed to read config %s [%d]\033[0m\n", config, ret);
		return -2;
	}

	// read Router id
	config_get_value("router-id", buffer);
	router_id = atoi(buffer);

	// read Input ports
	config_get_value("input-ports", input_ports);

	// read outputs
	config_get_value("outputs", output_dest);

	// close config file and destroy memory
	config_close();

	return 0;

}

void config_get_logfiles(serverConfig_t *config, const char * const service)
{
	field_t val;

	/* logfile */
	config_get_value("logfile", service, val);
	if (! strlen(val))
		g_strlcpy(config->log,DEFAULT_LOG_FILE, FIELDSIZE);
	else
		g_strlcpy(config->log, val, FIELDSIZE);
	assert(config->log);

	/* errorlog */
	config_get_value("errorlog", service, val);
	if (! strlen(val))
		g_strlcpy(config->error_log,DEFAULT_ERROR_LOG, FIELDSIZE);
	else
		g_strlcpy(config->error_log, val, FIELDSIZE);
	assert(config->error_log);

	/* pid directory */
	config_get_value("pid_directory", service, val);
	if (! strlen(val))
		g_strlcpy(config->pid_dir, DEFAULT_PID_DIR, FIELDSIZE);
	else
		g_strlcpy(config->pid_dir, val, FIELDSIZE);
	assert(config->pid_dir);
}

static void set_tab_miscellaneous_settings(GuPrefsGui* prefs)
{
  GtkTreeModel* combo_lang = 0;
  GtkTreeIter iter;
  const gchar* lang = 0;
  gint count = 0;
  gboolean valid = FALSE;

  combo_lang = gtk_combo_box_get_model(GTK_COMBO_BOX(prefs->combo_languages));
  lang = config_get_value("spell_language");
  valid = gtk_tree_model_get_iter_first(combo_lang, &iter);

  while (valid) {
    const gchar* str_value;
    gtk_tree_model_get(combo_lang, &iter, 0, &str_value, -1);
    if (STR_EQU(lang, str_value)) {
      gtk_combo_box_set_active(GTK_COMBO_BOX(prefs->combo_languages), count);
      break;
    }
    ++count;
    valid = gtk_tree_model_iter_next(combo_lang, &iter);
  }

  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs->autoexport),
                               TO_BOOL(config_get_value("autoexport")));

}

static void sort_sieve_get_config(struct sort_sieve_config *sieve_config)
{
	field_t val;

	assert(sieve_config != NULL);

	sieve_config->vacation = 0;
	sieve_config->notify = 0;
	sieve_config->debug = 0;

	config_get_value("SIEVE_VACATION", "DELIVERY", val);
	if (strcasecmp(val, "yes") == 0) {
		sieve_config->vacation = 1;
	}

	config_get_value("SIEVE_NOTIFY", "DELIVERY", val);
	if (strcasecmp(val, "yes") == 0) {
		sieve_config->notify= 1;
	}

	config_get_value("SIEVE_DEBUG", "DELIVERY", val);
	if (strcasecmp(val, "yes") == 0) {
		sieve_config->debug = 1;
	}
}

gboolean project_create_new(const gchar* filename)
{
  const gchar* version = g_strdup("0.6.0");
  const gchar* csetter = config_get_value("typesetter");
  const gchar* csteps = config_get_value("compile_steps");
  const gchar* rootfile = g_active_editor->filename;
  // TODO: do we need to encode this text?
  const gchar* content = g_strdup_printf("version=%s\n"
                                         "typesetter=%s\n"
                                         "steps=%s\n"
                                         "root=%s\n",
                                         version, csetter, csteps, rootfile);

  if (!STR_EQU(filename + strlen(filename) - 6, ".gummi")) {
    filename = g_strdup_printf("%s.gummi", filename);
  }

  statusbar_set_message(g_strdup_printf("Creating project file: %s",
                                        filename));
  utils_set_file_contents(filename, content, -1);

  gummi->project->projfile = g_strdup(filename);

  return TRUE;
}

/*
 * Get current configuration parameters.
 */
static void fetch_config_values (void)
{
  db_host = config_get_value("db_host");
  db_name = config_get_value("db_name");
  db_user = config_get_value("db_user");
  db_passwd = config_get_value("db_passwd");
  ticker_home = config_get_value("ticker_home");
  pid_file = config_get_value("pid_file");
  ticker_state = config_get_value("ticker_state");
  debug_logfile = config_get_value("debug_logfile");
  error_logfile = config_get_value("error_logfile");
  msg_logfile = config_get_value("msg_logfile");
  tick_interval = config_get_long_value("tick_interval");
  sleep_time = config_get_long_value("sleep_time");
}

/**
 * This function will check if wee need to send refresh PUBLISH. 
 * If so, it will send refresh PUBLISH
 *
 * @param[in] none
 *
 * @return none
 */
void publish_handle_periodic_timer_expire (void)
{
    static const char fname[] = "publish_handle_periodic_timer_expire";
    int                 delta = 0;
    ccsip_publish_cb_t *pcb_p;
    pub_req_t           msg;

    config_get_value(CFGID_TIMER_SUBSCRIBE_DELTA, &delta,
                     sizeof(delta));
    pcb_p = (ccsip_publish_cb_t *)sll_next(s_PCB_list, NULL);
    while (pcb_p != NULL) {
        if (pcb_p->outstanding_trxn == FALSE) {
            if (pcb_p->hb.expires >= TMR_PERIODIC_PUBLISH_INTERVAL) {
                pcb_p->hb.expires -= TMR_PERIODIC_PUBLISH_INTERVAL;
            }
            if (pcb_p->hb.expires <= (delta + TMR_PERIODIC_PUBLISH_INTERVAL)) {
                CCSIP_DEBUG_TASK(DEB_F_PREFIX"sending REFRESH PUBLISH", DEB_F_PREFIX_ARGS(SIP_PUB, fname));
                memset (&msg, 0, sizeof(msg));
                /* refresh is triggered by NULL event data and non-zero expires value */
                msg.pub_handle = pcb_p->pub_handle;
                msg.expires = pcb_p->hb.orig_expiration;
                (void)publish_handle_ev_app_publish(&msg);               
            }
        }
        pcb_p = (ccsip_publish_cb_t *)sll_next(s_PCB_list, pcb_p);
    }
}

/*
 *  Function: dp_start_dialing()
 *
 *  Parameters: line - line number
 *                                call_id - call indentification
 *
 *  Description: Start dialing and initilize dialing data.
 *
 *  Returns: none
 */
static void
dp_init_dialing_data (line_t line, callid_t call_id)
{
    const char fname[] = "dp_init_dialing_data";

    DPINT_DEBUG(DEB_F_PREFIX"line=%d call_id=%d\n", DEB_F_PREFIX_ARGS(DIALPLAN, fname), line, call_id);

    g_dp_int.call_id = call_id;
    g_dp_int.line = line;
    g_dp_int.gDialplanDone = FALSE;
    g_dp_int.url_dialing = FALSE;
    g_dp_int.gTimerType = DP_NONE_TIMER;

    memset(g_dp_int.gDialed, 0, sizeof(g_dp_int.gDialed));

    /* get offhook timeout */
    g_dp_int.offhook_timeout = DIAL_TIMEOUT;

    config_get_value(CFGID_OFFHOOK_TO_FIRST_DIGIT_TIMER,
                     &g_dp_int.offhook_timeout,
                     sizeof(g_dp_int.offhook_timeout));

    /* Flush any collected KPML digits on this line */
    kpml_flush_quarantine_buffer(line, call_id);
}

inline const char *
config_get_platform_file(void)
{
    const char *request = "/config/global/file[@type=\"platform\"]/text()";
    //const char *ko = "XPathError: /config/global/file[@type=\"platform\"]/text()";
    const char *platform_file = config_get_value(request);
    
#ifdef VERBOSE
    fprintf(stderr, "Platform file : ");
#endif
    if (!platform_file) {
#ifdef VERBOSE
        fprintf(stderr, "failed\n");
        //fprintf(stderr, ko);
#endif
        
        free(config);
        exit(2);
    } else {
#ifdef VERBOSE
        fprintf(stderr, "%s\n", platform_file);
#endif
        return platform_file;
    }    
}

inline const char *
config_get_deployment_file(void)
{
    const char *deployment_file;
    const char *request = "/config/global/file[@type=\"deployment\"]/text()";
    //char *ko = "XPathError: /config/global/file[@type=\"deployment\"]/text()";
#ifdef VERBOSE
    fprintf(stderr, "Deployment file : ");
#endif
    
    deployment_file = config_get_value(request);
    if (!deployment_file) {
#ifdef VERBOSE
        fprintf(stderr, "failed\n");
        //fprintf(stderr, ko);
#endif
        free(config);
        exit(2);
    } else {
#ifdef VERBOSE
        fprintf(stderr, "%s\n", deployment_file);
#endif
        return deployment_file;
    }    
}

int scan_start()
{
  pthread_mutex_lock(&scan_mutex);
  if (thread_running) {
    /* Signal the scan thread to restart scanning */
    musicd_log(LOG_VERBOSE, "scan", "signaling to restart scan");
    restart = 1;
    interrupted = 1;
    pthread_mutex_unlock(&scan_mutex);
    return 0;
  }
  pthread_mutex_unlock(&scan_mutex);

  if (!config_get_value("music-directory")) {
    musicd_log(LOG_WARNING, "scan", "music-directory not set, no scanning");
    return 0;
  }

  thread_running = true;

  if (pthread_create(&scan_thread, NULL, scan_thread_func, NULL)) {
    musicd_perror(LOG_ERROR, "scan", "could not create thread");
    return -1;
  }
  pthread_detach(scan_thread);
  
  return 0;
}

int send_alert(uint64_t user_idnr, char *subject, char *body)
{
	DbmailMessage *new_message;
	Field_T postmaster;
	char *from;
	int msgflags[IMAP_NFLAGS];

	// Only send each unique alert once a day.
	char *tmp = g_strconcat(subject, body, NULL);
	char *userchar = g_strdup_printf("%" PRIu64 "", user_idnr);
	char handle[FIELDSIZE];

	memset(handle, 0, sizeof(handle));
       	dm_md5(tmp, handle);
	if (db_replycache_validate(userchar, "send_alert", handle, 1) != DM_SUCCESS) {
		TRACE(TRACE_INFO, "Already sent alert [%s] to user [%" PRIu64 "] today", subject, user_idnr);
		g_free(userchar);
		g_free(tmp);
		return 0;
	} else {
		TRACE(TRACE_INFO, "Sending alert [%s] to user [%" PRIu64 "]", subject, user_idnr);
		db_replycache_register(userchar, "send_alert", handle);
		g_free(userchar);
		g_free(tmp);
	}

	// From the Postmaster.
	if (config_get_value("POSTMASTER", "DBMAIL", postmaster) < 0) {
		TRACE(TRACE_NOTICE, "no config value for POSTMASTER");
	}
	if (strlen(postmaster))
		from = postmaster;
	else
		from = DEFAULT_POSTMASTER;

	// Set the \Flagged flag.
	memset(msgflags, 0, sizeof(msgflags));
	msgflags[IMAP_FLAG_FLAGGED] = 1;

	// Get the user's login name.
	char *to = auth_get_userid(user_idnr);

	new_message = dbmail_message_new(NULL);
	new_message = dbmail_message_construct(new_message, to, from, subject, body);

	// Pre-insert the message and get a new_message->id
	dbmail_message_store(new_message);
	uint64_t tmpid = new_message->id;

	if (sort_deliver_to_mailbox(new_message, user_idnr,
			"INBOX", BOX_BRUTEFORCE, msgflags, NULL) != DSN_CLASS_OK) {
		TRACE(TRACE_ERR, "Unable to deliver alert [%s] to user [%" PRIu64 "]", subject, user_idnr);
	}

	g_free(to);
	db_delete_message(tmpid);
	dbmail_message_free(new_message);

	return 0;
}

gboolean latex_method_active(gchar* method)
{
  if (STR_EQU(config_get_value("compile_steps"), method)) {
    return TRUE;
  }
  return FALSE;
}

/**
 * give the platform IPV4 IP address.
 *
 * @param[in/out] ip_addr - pointer to the cpr_ip_addr_t. The
 *                          result IP address will be populated in this
 *                          structure.
 *
 * @return  None.
 */
void
platform_get_ipv4_address (cpr_ip_addr_t *ip_addr)
{
    config_get_value(CFGID_MY_IP_ADDR, ip_addr, sizeof(cpr_ip_addr_t));
    ip_addr->type = CPR_IP_ADDR_IPV4;

    return;
}

WFTK_ADAPTORLIST * config_get_adaptorlist (void * session, int adaptor_class)
{
   const char * spec = "";
   int adaptors = 1;
   int i;
   const char * mark;
   char * mark2;
   char adaptorbuffer[256]; /* TODO: another dang static buffer.  Fix it. */
   WFTK_ADAPTORLIST * list;

   switch (adaptor_class) {
      case TASKINDEX:
         spec = config_get_value (session, "taskindex.always");
         break;
      case NOTIFY:
         spec = config_get_value (session, "notify.always");
         break;
      default:
         return (WFTK_ADAPTORLIST *) 0;
   }

   if (!*spec) return (WFTK_ADAPTORLIST *) 0;

   /* First pass: count semicolons, so we know how large a list structure to allocate. */
   mark = spec;
   do {
      mark = strchr (mark, ';');
      if (!mark) break;
      adaptors++; mark++;
   } while (mark);

   list = (WFTK_ADAPTORLIST *) malloc (sizeof (WFTK_ADAPTOR_LIST) + adaptors * sizeof (WFTK_ADAPTOR *));
   list->count = adaptors;

   for (i=0, mark = spec; i < adaptors; i++) {
      strcpy (adaptorbuffer, mark);
      mark = strchr(mark, ';');
      if (mark) { mark++; while (*mark == ' ') mark++; }
      mark2 = strchr (adaptorbuffer, ';');
      if (mark2) *mark2 = '\0';

      list->ads[i] = wftk_get_adaptor (session, adaptor_class, adaptorbuffer);
   }

   return (list);
}

static void set_tab_preview_settings(GuPrefsGui* prefs)
{

  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs->compile_status),
                               TO_BOOL(config_get_value("compile_status")));

  if (!config_get_value("compile_status"))
    gtk_widget_set_sensitive(GTK_WIDGET(prefs->compile_timer), FALSE);

  gtk_spin_button_set_value(prefs->compile_timer,
                            atoi(config_get_value("compile_timer")));
  /* compile scheme */
  if (STR_EQU(config_get_value("compile_scheme"), "real_time"))
    gtk_combo_box_set_active(prefs->compile_scheme, 1);

  if (STR_EQU(config_get_value("animated_scroll"), "always")) {
    gtk_combo_box_set_active(prefs->combo_animated_scroll, 0);
  } else if (STR_EQU(config_get_value("animated_scroll"), "never")) {
    gtk_combo_box_set_active(prefs->combo_animated_scroll, 2);
  } else {
    gtk_combo_box_set_active(prefs->combo_animated_scroll, 1);
  }

  gtk_spin_button_set_value(prefs->spin_cache_size,
                            atoi(config_get_value("cache_size")));
}

GuLatex* latex_init(void)
{
  GuLatex* l = g_new0(GuLatex, 1);
  l->compilelog = NULL;
  l->modified_since_compile = FALSE;

  l->tex_version = texlive_init();
  rubber_init();
  latexmk_init();

  /* TODO: Temp hard set of compilation options for migrating configs */
  if (strlen(config_get_value("typesetter")) == 0)
    config_set_value("typesetter", "pdflatex");
  if (strlen(config_get_value("compile_steps")) == 0)
    config_set_value("compile_steps", "texpdf");

  return l;
}

/**
 * Get active mac address if required
 *
 * @param addr - mac address string (OUTPUT)
 *
 * @return none
 */
void
platform_get_active_mac_address (unsigned char *addr)
{
    config_get_value(CFGID_MY_ACTIVE_MAC_ADDR, addr, 6);
    TNP_DEBUG(DEB_F_PREFIX"ActiveMacAddr:from Get Val: %04x:%04x:%04x",
            DEB_F_PREFIX_ARGS(PLAT_API, "platform_get_mac_address"),
              addr[0] * 256 + addr[1], addr[2] * 256 + addr[3],
              addr[4] * 256 + addr[5]);
}

void qc_module_init( qc_module_type * qc_module , const config_type * config) {
  if (config_item_set( config , QC_PATH_KEY )) 
    qc_module_set_path( qc_module , config_get_value( config , QC_PATH_KEY ));
  
  if (config_item_set( config , QC_WORKFLOW_KEY)) {
    const char * qc_workflow = config_get_value_as_path(config , QC_WORKFLOW_KEY);
    qc_module_set_workflow( qc_module , qc_workflow );
  }
}

static void set_tab_compilation_settings(GuPrefsGui* prefs)
{
  /* Setting available typesetters and the active one */
  /* TODO: iterate the available typesetter list and gtk_builder the objects
   * maybe.. or not.. */


  if (pdflatex_detected()) {
    if (pdflatex_active())
      gtk_toggle_button_set_active(prefs->typ_pdflatex, TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(prefs->typ_pdflatex), TRUE);
    gtk_widget_set_tooltip_text(GTK_WIDGET(prefs->typ_pdflatex), "");
  }

  if (xelatex_detected()) {
    if (xelatex_active())
      gtk_toggle_button_set_active(prefs->typ_xelatex, TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(prefs->typ_xelatex), TRUE);
    gtk_widget_set_tooltip_text(GTK_WIDGET(prefs->typ_xelatex), "");
  }

  if (rubber_detected()) {
    if (rubber_active())
      gtk_toggle_button_set_active(prefs->typ_rubber, TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(prefs->typ_rubber), TRUE);
    gtk_widget_set_tooltip_text(GTK_WIDGET(prefs->typ_rubber), "");
  }

  if (latexmk_detected()) {
    if (latexmk_active())
      gtk_toggle_button_set_active(prefs->typ_latexmk, TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(prefs->typ_latexmk), TRUE);
    gtk_widget_set_tooltip_text(GTK_WIDGET(prefs->typ_latexmk), "");
  }

  if (latex_method_active("texpdf")) {
    gtk_toggle_button_set_active(prefs->method_texpdf, TRUE);
  } else if (latex_method_active("texdvipdf")) {
    gtk_toggle_button_set_active(prefs->method_texdvipdf, TRUE);
  } else if (latex_method_active("texdvipspdf")) {
    gtk_toggle_button_set_active(prefs->method_texdvipspdf, TRUE);
  }

  if (!latex_use_shellescaping())
    gtk_toggle_button_set_active(prefs->opt_shellescape, FALSE);
  else {
    gtk_toggle_button_set_active(prefs->opt_shellescape, TRUE);
  }

  if (latex_can_synctex()) {
    if (config_get_value("synctex")) {
      gtk_toggle_button_set_active(prefs->opt_synctex, TRUE);
    } else {
      gtk_toggle_button_set_active(prefs->opt_synctex, FALSE);
    }
  }
}