int
db_select ()
{
    lyricDb = db_connect ("lyricDb", "error");
    mediaDb = db_connect ("mediaDb", "error");
    bibleDb = db_connect ("bibleDb", "error");
    return TRUE;
}

word db_row_count(void)
{
   // Returns number of rows affected by preceding DELETE or UPDATE.
   // Doesn't work after a SELECT.

   MYSQL_RES * result;
   MYSQL_ROW row;
   if(db_connect()) return 9;

   if (mysql_query(mysql_object, "SELECT row_count()"))
   {
      char zs[1024];
      sprintf(zs, "db_row_count():  mysql_query() Error %u: %s", mysql_errno(mysql_object), mysql_error(mysql_object));
      _log(CRITICAL, zs);
      
      db_disconnect();
      return 3;
   }

   result = mysql_store_result(mysql_object);
   row = mysql_fetch_row(result);

   mysql_free_result(result);

   return atoi(row[0]);
 
}

word db_query(const char * const query)
{
   char zs[2048];

   if(strlen(query) > 2000)
   {
      _log(MAJOR, "db_query() called with overlong query.");
      return 99;
   }

   sprintf(zs, "db_query(\"%s\")", query);
   _log(PROC, zs);

   if(db_connect()) return 9;
   
   if(mysql_query(mysql_object, query))
   {
      sprintf(zs, "db_query():  mysql_query() Error %u: %s    Query:", mysql_errno(mysql_object), mysql_error(mysql_object));
      _log(CRITICAL, zs);
      char report[128];
      strncpy(report, query, 96);
      report[96] = 0;
      if(strlen(query) > 96)
      {
         strcat(report, "...");
      }
      sprintf(zs,"\"%s\"", report);
      _log(CRITICAL, zs);

      db_disconnect();
      return 3;
   }
   return 0;
}

void connect_to_db(void)
{
  redisReply *reply;
  options *globaloptions;
  struct timeval timeout = { 1, 500000 };

  if (options_init_from_boxrc() < 0) {
      LOG_ERROR("Reading config failed--see warnings above. "
              "For usage, try -h.");
      return;
  }

  globaloptions = options_get();

  /* connect to database */
  assert_int_equal(0, db_connect(
      fmt_addr(&globaloptions->RedisDatabaseListenAddr),
      globaloptions->RedisDatabaseListenPort, timeout,
      globaloptions->RedisDatabaseAuth));

  reply = redisCommand(rc, "FLUSHALL");

  freeReplyObject(reply);

  options_free(globaloptions);
}

static void detect_dbs(void)
{
	const char *cstr = make_connstr(cf.initial_database);
	db_template = db_create(detect_handler, NULL);
	db_connect(db_template, cstr);
	free(cstr);
}

int main(void) {
    curmudgeon_t *      app = NULL;
    event_t *           event = NULL;
    char *              test = "/hello_world/arg1/arg2";
    if ( cur_init(&app,1) == CUR_OK) {
        app->schema_version_file = "schema.version"; 
        adapter_t * a = NULL;
        db_mysql(app,&a,"{ 'host': 'localhost', 'user': 'root', 'pass': 'root' }");
        db_connect( a );
        db_select_db( a ,"curmudgeon");
        printf("Schema version is: %d\n",_get_num_from_file(app->schema_version_file));
        _set_num_in_file(app->schema_version_file,1); 
        printf("Schema version is: %d\n",_get_num_from_file(app->schema_version_file));
        if ( schema_database(a,"test_table",NULL,NULL) == CUR_OK ) {
            printf("migrated\n");
        } else {
            printf("did not migrate\n");
        }
        _set_num_in_file(app->schema_version_file,0); 
        if ( schema_database( a ,"test_table",NULL,NULL) == CUR_OK ) {
            printf("migrated\n");
        } else {
            printf("did not migrate\n");
        }
        schema_database( a ,"test_table","latin1","latin1_general_ci");
        cur_done(&app);
    } else {
        Puts("Could not init");
    }
    return 0;
}

/*
 * Check to see if the connection is still valid.  If not, attempt to
 * reconnect.
 */
static isc_result_t
maybe_reconnect(struct dbinfo *dbi) {
	if (PQstatus(dbi->conn) == CONNECTION_OK)
		return (ISC_R_SUCCESS);

	return (db_connect(dbi));
}

/*----------------------------------------------------------------

     main

-----------------------------------------------------------------*/
int main(int argc, char **argv)
{

	RETCODE retcode = -1;
	int rc;
	GET_LOGIN_VARS()
	    retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HENV, &EnvHandle);

	if (retcode != SQL_SUCCESS) {
		printf("Unable to allocate ODBC environment handle!\n");

		return -1;
	}

	retcode =
	    SQLSetEnvAttr(EnvHandle, SQL_ATTR_ODBC_VERSION,
			  (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_INTEGER);

	if (retcode != SQL_SUCCESS) {
		printf("Unable to set version of ODBC environment handle!\n");
		LogODBCError(retcode, SQL_HANDLE_ENV, EnvHandle);
		return -2;
	}

	rc = db_connect();
	if (rc >= 0) {
		rc = print_columns("SOME_NUMERIC_TYPES");
	}
	return rc;
}

int URL_put_data_mysql_url ( const URL *url, const PKI_MEM *data ) {

#ifdef HAVE_MYSQL
	MYSQL * sql = NULL;

	char * query = NULL;

	if( !url ) return (PKI_ERR);

	if((query = parse_url_put_query( url, data )) == NULL ) {
		return( PKI_ERR );
	}

	if((sql = db_connect ( url )) == NULL ) {
		PKI_Free( query );
		return(PKI_ERR);
	}

	if(mysql_query(sql, query ) != 0 ) {
		PKI_Free ( query );
		db_close( sql );

		return( PKI_ERR );
	}

	PKI_Free (query);
	db_close ( sql );

	return ( PKI_OK );

#else
	return ( PKI_ERR );
#endif
}

int main(int argc, char *argv[])
{
	int i, foreground, port;
	void (*timeseal_init)(const char * ) = chessd_function("timeseal_init");
	int (*net_init)(int ) = chessd_function("net_init");
	void (*initial_load)(void ) = chessd_function("initial_load");
	void (*db_connect)(void ) = chessd_function("db_connect");
	void (*db_disconnect)(void ) = chessd_function("db_disconnect");

	port = DEFAULT_PORT;
	foreground = 0;

	/* enable malloc checking in libc */
	setenv("MALLOC_CHECK_", "2", 1);
	
	while((i = getopt(argc, argv, "p:fR:T:")) != -1) {
		switch(i) {
		case 'p':
			port = atoi(optarg);
			break;
		case 'f':
			foreground = 1;
			break;
		case 'T':
			timeseal_init(optarg);
			break;
		case 'R':
			do_chroot(optarg);
			break;
		default:
			usage();
		}
	}
   
	if (!foreground && daemonize()){
		printf("Problem with Daemonization - Aborting\n");
		exit(1);
	}  

	signal(SIGTERM, TerminateServer);
	signal(SIGSEGV, segv_handler);
	signal(SIGBUS, segv_handler);
	signal(SIGINT, TerminateServer);
	signal(SIGPIPE, BrokenPipe);

	if (net_init(port)) {
		fprintf(stderr, "CHESSD: Network initialize failed on port %d.\n", port);
		exit(1);
	}
	fprintf(stderr,  "CHESSD: Initialized on port %d\n", port);

	initial_load();
	
	db_connect();
	main_event_loop();
	db_disconnect();
	/* will never get here - uses TerminateServer */
	
	return 0;
}

static void main_event_loop(void) 
{
	void (*select_loop)(void ) = chessd_function("select_loop");

	while (1) {
		select_loop();

		/* check the reload flag */
		if (chessd_reload_flag) {
			void (*reload_close)(void ) = chessd_function("reload_close");
			void (*reload_open)(void );

			void (*db_disconnect)(void ) = chessd_function("db_disconnect");
			db_disconnect();

			chessd_reload_flag = 0;

			fprintf(stderr, "CHESSD: Reloading server code!\n");

			/* free up local vars */
			reload_close();

			/* close the handle to the shared lib */
			dlclose(chessd_so_handle);
			chessd_so_handle = NULL;

			/* re-initialise local variables */
			reload_open = chessd_function("reload_open");
			reload_open();
			select_loop = chessd_function("select_loop");
			void (*db_connect)(void ) = chessd_function("db_connect");
			db_connect();
		}
	}
}

/*
 * Create a connection to the database and save any necessary information
 * in dbdata.
 *
 * argv[0] is the name of the database file
 * argv[1] is the name of the table
 */
static isc_result_t
sqlitedb_create(const char *zone,
		int argc, char **argv,
		void *driverdata, void **dbdata)
{
    dbinfo_t *dbi;
    isc_result_t result;

    UNUSED(zone);
    UNUSED(driverdata);

    if (argc < 2)
	return (ISC_R_FAILURE);

    dbi = isc_mem_get(ns_g_mctx, sizeof(dbinfo_t));
    if (dbi == NULL)
	return (ISC_R_NOMEMORY);
    dbi->db       = NULL;
    dbi->filename = NULL;
    dbi->table    = NULL;

    STRDUP_OR_FAIL(dbi->filename, argv[0]);
    STRDUP_OR_FAIL(dbi->table, argv[1]);

    result = db_connect(dbi);
    if (result != ISC_R_SUCCESS)
	goto cleanup;

    *dbdata = dbi;
    return (ISC_R_SUCCESS);

cleanup:
    sqlitedb_destroy(zone, driverdata, (void **)&dbi);
    return (result);
}

static void chk_prog_stat(void) {
        sqlite *db_id;
        int x=0;
        db_id=db_connect(DB_NAME);
        db_query(db_id,"select service_dhcp.stat,service_ftp.stat,service_ssh.stat,auth_ad.stat,service_ddns.stat,pptp_vpn.stat,service_snmp.stat,service_https.stat from service_dhcp,service_ftp,service_ssh,auth_ad,service_ddns,pptp_vpn,service_snmp,service_https");
        if(SQL_NUMROWS!=0) {
                for(x=0;x<SQL_NUMROWS;x++) {
                        if(!strcmp(SQL_RESULT[x].name,"service_dhcp.stat") && atoi(SQL_RESULT[x].value)==1) dhcp_stat=1;
                        if(!strcmp(SQL_RESULT[x].name,"service_ftp.stat") && atoi(SQL_RESULT[x].value)==1) ftp_stat=1;
                        if(!strcmp(SQL_RESULT[x].name,"service_ssh.stat") && atoi(SQL_RESULT[x].value)==1) ssh_stat=1;
                        if(!strcmp(SQL_RESULT[x].name,"auth_ad.stat") && atoi(SQL_RESULT[x].value)==1) auth_ad=1;
                        if(!strcmp(SQL_RESULT[x].name,"service_ddns.stat") && atoi(SQL_RESULT[x].value)==1) ddns_stat=1;
                        if(!strcmp(SQL_RESULT[x].name,"pptp_vpn.stat") && atoi(SQL_RESULT[x].value)==1) pptp_stat=1;
                        if(!strcmp(SQL_RESULT[x].name,"service_snmp.stat") && atoi(SQL_RESULT[x].value)==1) snmp_stat=1;
                        if(!strcmp(SQL_RESULT[x].name,"service_https.stat") && atoi(SQL_RESULT[x].value)==1) https_stat=1;
                }
        }
	db_clean_buffer();
	db_query(db_id,"select * from htb_client");
	if(SQL_NUMROWS!=0) shaper_stat=1;
	db_clean_buffer();
	db_query(db_id,"select val from misc where name='ids_stat'");
	if(SQL_NUMROWS!=0) {
		ips_stat=atoi(SQL_RESULT[0].value);
	}
        db_close(db_id);
}

downloader *easy_downloader_init()
{
	int ret;

	sqlite3 *db_key;	
	snprintf(download_tmp_path, PATH_MAX, "%s/%s/", getenv("HOME"), TMP_DIR);

	ret = mkdir(download_tmp_path, S_IRWXU);
	if (ret != 0 && errno != EEXIST)
		return NULL;
	chdir(download_tmp_path);

	if ((ret = db_connect(DB_FILE_NAME, &db_key, SQL_CREATE_TABLE)) != 0)
		return NULL;

	d_manager_t *manager = (d_manager_t *)malloc(sizeof(d_manager_t));
	manager->tp = easy_thread_pool_init(5, 60);
	manager->db_key = db_key;

	if (file_saved_def_path[0] == '\0')
	{
		strcpy(file_saved_def_path, getenv("HOME"));
		strcat(file_saved_def_path, "/");
	}
		
	return (downloader *)manager;
}

extern unsigned int db_d2char_delete(char const * db_table,char const * account, char const * charname, char const * realmname)
{
	MYSQL	mysql = {0};    /* MySQL headers aren't correct initialized */
	char 	* sql;

	/* This shall allow us to reconnect, after a disconnected MySQL link */
	if (!db_connect(&mysql)) return 0;

	if (!strlen(realmname)) {
		eventlog(eventlog_level_error, __FUNCTION__, "got no realm name ");
		return 0;
	}

	if (!(sql = malloc(strlen("DELETE FROM  WHERE accname=\'\' AND charname=\'\' AND realm=\'\' AND recage=0")+strlen(db_table)+strlen(account)+strlen(charname)+strlen(realmname)+1)))
	{
		eventlog(eventlog_level_error, __FUNCTION__, "unable to allocate memory for query");
		free(sql);
		return 0;
	}
	sprintf(sql, "DELETE FROM %s WHERE accname=\'%s\' AND charname=\'%s\' AND realm=\'%s\' AND recage=0",db_table,account,charname,realmname);
	if(mysql_query(&mysql,sql))
	{
		eventlog(eventlog_level_error, __FUNCTION__, "error deleting character \"%s(*%s)@%s\" (%d:%s)",charname,account,realmname,mysql_errno(&mysql),mysql_error(&mysql));
		free(sql);
		return 0;
	}
	free(sql);
    if(mysql_affected_rows(&mysql)!=0)
	{
		eventlog(eventlog_level_error, __FUNCTION__,"zero data records for \"%s(*%s)@%s\" deleted (%d:%s)",charname,account,realmname,mysql_errno(&mysql),mysql_error(&mysql));
		return 0;
	}
	eventlog(eventlog_level_trace, __FUNCTION__, "successfully deleted record \"%s(*%s)@%s\"",charname,account,realmname);
	return 1;
}

int db_list_contains(brain_t brain, enum list type, word_t word) {
	PGresult *res;
	const char *param[3];
	char tmp[3][32];

	if (brain == 0 || word == 0) return -EINVAL;
	if (db_connect())
		return -EDB;

	SET_PARAM(param, tmp, 0, brain);
	SET_PARAM(param, tmp, 1, type);
	SET_PARAM(param, tmp, 2, word);

	res = PQexecPrepared(conn, "list_get", 3, param, NULL, NULL, 0);
	if (PQresultStatus(res) != PGRES_TUPLES_OK) goto fail;
	if (PQntuples(res) == 0) goto not_found;

	PQclear(res);

	return OK;

fail:
	log_error("db_list_contains", PQresultStatus(res), PQresultErrorMessage(res));
	PQclear(res);
	return -EDB;

not_found:
	PQclear(res);
	return -ENOTFOUND;
}

void setup(void)
{
	configure_debug(255,0);
	config_read(configFile);
	GetDBParams();
	db_connect();
}

void db_remove_file(int file_id) {
	char *query = NULL;
	char query_outline[] = "DELETE FROM files WHERE file_id = ";
	int query_length = 0;
	int rc = SQLITE_ERROR; /* return code of sqlite operation */
	int written = 0; /* number of characters written */
	sqlite3 *conn = NULL;
	sqlite3_stmt *res = NULL;

	DEBUG(ENTRY);

	assert(file_id > 0);

	DEBUG("Removing file ID %d", file_id);

	/* prepare query */
	query_length = strlen(query_outline) + num_digits(file_id);
	query = malloc(query_length * sizeof(*query) + 1);
	assert(query != NULL);
	written = snprintf(query, query_length + 1, "DELETE FROM files WHERE file_id = %d", file_id);
	assert(written == query_length);

	/* connect to database */
	conn = db_connect();
	assert(conn != NULL);

	rc = db_execute_statement(conn, query, &res);

	db_finalize_statement(conn, query, res);
	db_disconnect(conn);
	free_single_ptr((void **)&query);

	DEBUG("Removing file ID %d was %ssuccessful", file_id, rc == SQLITE_DONE ? "" : "not ");
	DEBUG(EXIT);
} /* db_remove_file */

void db_delete_tag(int tag_id) {
	char *query = NULL;
	char query_outline[] = "DELETE FROM tags WHERE tag_id = \"\"";
	int query_length = 0;
	int rc = SQLITE_ERROR; /* return code of sqlite operation */
	int written = 0; /* number of characters written */
	sqlite3 *conn = NULL;
	sqlite3_stmt *res = NULL;

	DEBUG(ENTRY);

	assert(tag_id > 0);

	DEBUG("Deleting tag with tag ID %d", tag_id);

	/* prepare query */
	query_length = strlen(query_outline) + num_digits(tag_id);
	query = malloc(query_length * sizeof(*query) + 1);
	assert(query != NULL);
	written = snprintf(query, query_length + 1, "DELETE FROM tags WHERE tag_id = \"%d\"", tag_id);
	assert(written == query_length);

	/* connect to database */
	conn = db_connect();
	assert(conn != NULL);

	rc = db_execute_statement(conn, query, &res);

	db_finalize_statement(conn, query, res);
	db_disconnect(conn);
	free_single_ptr((void **)&query);

	DEBUG("File with ID %d was %sdeleted successfully.", tag_id, rc == 0 ? "" : "not ")
	DEBUG(EXIT);
} /* db_delete_tag */

void db_add_tag_to_file(int tag_id, int file_id) {
	char *query = NULL;
	char query_outline[] = "INSERT INTO file_has_tag VALUES(, )";
	int query_length = 0;
	int rc = SQLITE_ERROR; /* return code of sqlite operation */
	int written = 0; /* number of characters written */
	sqlite3 *conn = NULL;
	sqlite3_stmt *res = NULL;

	DEBUG(ENTRY);

	assert(tag_id >= 0);
	assert(file_id > 0);

	/* prepare query */
	query_length = strlen(query_outline) + num_digits(tag_id) + num_digits(file_id);
	query = malloc(query_length * sizeof(*query) + 1);
	assert(query != NULL);
	written = snprintf(query, query_length + 1, "INSERT INTO file_has_tag VALUES(%d, %d)", file_id, tag_id);
	assert(written == query_length);

	/* connect to database */
	conn = db_connect();
	assert(conn != NULL);

	rc = db_execute_statement(conn, query, &res);

	db_finalize_statement(conn, query, res);
	db_disconnect(conn);
	free_single_ptr((void **)&query);

	DEBUG("Adding tag ID %d to file ID %d was %ssuccessful", tag_id, file_id, rc == SQLITE_DONE ? "" : "not ");
	DEBUG(EXIT);
} /* db_add_tag_to_file */