/**
* Builds a directory of the object names.
*
* Allocate and initialize information for this instance of an RT
* model database.
*
* Returns -
* (struct rt_i *) Success
* RTI_NULL Fatal Error
*/
struct rt_i *
rt_dirbuild(const char *filename, char *buf, int len)
{
register struct rt_i *rtip;
register struct db_i *dbip; /* Database instance ptr */
if (rt_uniresource.re_magic == 0)
rt_init_resource(&rt_uniresource, 0, NULL);
if ((dbip = db_open(filename, DB_OPEN_READONLY)) == DBI_NULL)
return RTI_NULL; /* FAIL */
RT_CK_DBI(dbip);
if (db_dirbuild(dbip) < 0) {
db_close(dbip);
return RTI_NULL; /* FAIL */
}
rtip = rt_new_rti(dbip); /* clones dbip */
db_close(dbip); /* releases original dbip */
if (buf != (char *)NULL)
bu_strlcpy(buf, dbip->dbi_title, len);
return rtip; /* OK */
}
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
}
static gboolean
backend_get_details_thread (PkBackend *backend)
{
PackageSearch *ps;
GList *list;
sqlite3 *db;
gchar **package_ids;
gchar **package_id_data;
package_ids = pk_backend_get_strv (backend, "package_ids");
/* FIXME: support multiple packages */
package_id_data = pk_package_id_split (package_ids[0]);
db = db_open ();
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
/* only one element is returned */
list = box_db_repos_packages_search_by_data (db, package_id_data[PK_PACKAGE_ID_NAME], package_id_data[PK_PACKAGE_ID_VERSION]);
if (list == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "cannot find package by id");
db_close (db);
return FALSE;
}
ps = (PackageSearch*) list->data;
pk_backend_details (backend, package_ids[0], "unknown", PK_GROUP_ENUM_OTHER, ps->description, "", 0);
box_db_repos_package_list_free (list);
db_close (db);
pk_backend_finished (backend);
return TRUE;
}
int main(int argc, char **argv)
{
int dev_cnt;
if(argc>1 && (strcmp(argv[1], "-d")==0) )
demonize(argv[0]);
while(1)
{
db_open();
dev_cnt = 0;
receive_history = true;
frame_id = 0;
printf("Wait for cm160 device to be connected\n");
while((dev_cnt = scan_usb()) == 0)
sleep(2);
printf("Found %d compatible device%s\n", dev_cnt, dev_cnt>1?"s":"");
// Only 1 device supported
if(!(g_devices[0].hdev = usb_open(g_devices[0].usb_dev)))
{
fprintf(stderr, "failed to open device\n");
db_close();
break;
}
handle_device(0);
usb_close(g_devices[0].hdev);
db_close();
}
return 0;
}
int
main (int argc, char * argv [])
{ const char *db_name = "./.sndfile-regtest.db" ;
REG_DB *reg_db ;
int k, retval ;
if (argc < 2)
{ printf ("\nUsage message goes here.\n\n") ;
exit (0) ;
} ;
if (argc == 2 && strcmp (argv [1], "--create-db") == 0)
return db_create (db_name) ;
reg_db = db_open (db_name) ;
if (argc == 2)
{ if (strcmp (argv [1], "--list-all") == 0)
return db_list_all (reg_db) ;
if (strcmp (argv [1], "--check-all") == 0)
{ print_libsndfile_version () ;
retval = db_check_all (reg_db) ;
puts ("\nDone.\n") ;
return retval ;
} ;
} ;
if (argc == 3 && strcmp (argv [1], "--del-entry") == 0)
{ db_del_entry (reg_db, argv [2]) ;
db_close (reg_db) ;
return 0 ;
} ;
if (strcmp (argv [1], "--check-file") == 0)
{ print_libsndfile_version () ;
for (k = 2 ; k < argc ; k++)
db_check_file (reg_db, argv [k]) ;
db_close (reg_db) ;
return 0 ;
} ;
if (strcmp (argv [1], "--add-file") == 0)
{ print_libsndfile_version () ;
for (k = 2 ; k < argc ; k++)
db_add_file (reg_db, argv [k]) ;
db_close (reg_db) ;
return 0 ;
} ;
printf ("\nError : unhandled command line args :") ;
for (k = 1 ; k < argc ; k++)
printf (" %s", argv [k]) ;
puts ("\n") ;
return 1 ;
} /* main */
int
db_resume_state (struct db_info *entry, struct block_game *pgame)
{
sqlite3_stmt *stmt;
log_info ("Trying to restore saved game");
if (db_open (entry) < 0)
return -1;
/* Get freshest entry in table */
const char select[] = "SELECT * FROM State ORDER BY date DESC;";
sqlite3_prepare_v2 (entry->db, select, sizeof select, &stmt, NULL);
/* Quit if old game-save doesn't exist */
if (sqlite3_step (stmt) != SQLITE_ROW) {
log_info ("Old game saves not found");
sqlite3_finalize (stmt);
db_close (entry);
return 0;
}
strncpy (entry->id, (const char *)
sqlite3_column_text (stmt, 0), sizeof entry->id);
pgame->score = sqlite3_column_int (stmt, 1);
pgame->lines_destroyed = sqlite3_column_int (stmt, 2);
pgame->level = sqlite3_column_int (stmt, 3);
pgame->mod = sqlite3_column_int (stmt, 4);
debug ("Restoring game spaces");
const char *blob = sqlite3_column_blob (stmt, 6);
for (int i = 0; i < BLOCKS_COLUMNS * BLOCKS_ROWS; i++)
pgame->spaces[i/BLOCKS_COLUMNS][i%BLOCKS_COLUMNS] = blob[i];
debug ("Restoring game colors");
blob = sqlite3_column_blob (stmt, 7);
for (int i = 0; i < BLOCKS_COLUMNS * BLOCKS_ROWS; i++)
pgame->colors[i/BLOCKS_COLUMNS][i%BLOCKS_COLUMNS] = blob[i];
sqlite3_finalize (stmt);
/* Remove old entries to DB */
const char drop[] = "DROP TABLE State;";
sqlite3_prepare_v2 (entry->db, drop, sizeof drop, &stmt, NULL);
sqlite3_step (stmt);
sqlite3_finalize (stmt);
db_close (entry);
return 1;
}
int main(int argc,char **argv)
{
static GDBM_FILE gdbm_stotest = NULL;
datum key,data;
int i;
for(i = 1;i<argc;i++)
{
key.dptr = "store test1!";
key.dsize = strlen("store test1")+1;
data = key;
gdbm_stotest = db_open(argv[i]);
printf("\n--------open dbm id:%d-----------\n",gdbm_stotest);
if(db_store(gdbm_stotest,key,data) < 0) {
printf("\n---------store err-----------\n");
db_close(gdbm_stotest);
break;
}
else {
printf("\n---------store successfully!-----------\n");
db_close(gdbm_stotest);
}
printf("\n--------close dbm id:%d-----------\n",gdbm_stotest);
key.dptr = "store test2!";
key.dsize = strlen("store test1")+1;
data = key;
gdbm_stotest = db_open(argv[i]);
printf("\n--------open dbm id:%d-----------\n",gdbm_stotest);
if(db_store(gdbm_stotest,key,data) < 0) {
printf("\n---------store err-----------\n");
db_close(gdbm_stotest);
break;
}
else {
printf("\n---------store successfully!-----------\n");
db_close(gdbm_stotest);
}
printf("\n--------close dbm id:%d-----------\n",gdbm_stotest);
gdbm_stotest = db_open(argv[i]);
key.dptr = "store test1!";
key.dsize = strlen("store test1!")+1;
data = key;
if(gdbm_exists(gdbm_stotest,key) != 0){
printf("-------really exist here!-----");
}
else {
printf("-------not exist here!-------");
}
}
}
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);
}
/* Match pattern against files in locate.db file */
static int
db_locate(
const wchar_t *pattern)
{
int count = 0;
#ifdef WIN32
wchar_t buffer[PATH_MAX + 1];
/* Open locate.db for read */
db_open ();
/* Read one directory and file name at a time from database file */
while (db_read (buffer, PATH_MAX)) {
/* See if file name in buffer matches the search pattern */
if (db_match (buffer, pattern)) {
/* Match found => output file name and path */
wprintf (L"%s\n", buffer);
count++;
}
}
db_close ();
#endif
return count;
}
void easy_downloader_destroy(downloader *inst)
{
d_manager_t *manager = (d_manager_t *)inst;
easy_thread_pool_free(manager->tp);
db_close(manager->db_key);
free(manager);
}
int sb_lua_db_close(lua_State *L)
{
sb_lua_ctxt_t *ctxt;
sb_lua_db_stmt_t *stmt;
unsigned int i;
ctxt = sb_lua_get_context(L);
CHECK_CONNECTION(L, ctxt);
stmt = (sb_lua_db_stmt_t *)luaL_checkudata(L, 1, "sysbench.stmt");
luaL_argcheck(L, stmt != NULL, 1, "prepared statement expected");
for (i = 0; i < stmt->nparams; i++)
{
if (stmt->params[i].buf != NULL)
free(stmt->params[i].buf);
}
free(stmt->params);
stmt->params = NULL;
luaL_unref(L, LUA_REGISTRYINDEX, stmt->param_ref);
luaL_unref(L, LUA_REGISTRYINDEX, stmt->result_ref);
db_close(stmt->ptr);
return 0;
}
/*
* The function performs cleanup on exit
*/
void
close_everything ()
{
if (result_file != NULL)
fclose (result_file);
result_file = NULL;
if (trace_dir == NULL)
db_close ();
else
trace_dir_close ();
if (fifo_mode)
{
/*
* Close and remove FIFOs
*/
close (child_stdin_fd);
close (child_stdout_fd);
unlink (fifo_to_wrapper_filename);
unlink (fifo_from_wrapper_filename);
printf ("II - FIFO removed\n");
}
}
void thread(void *arg)
{
char * ptr=(char *)arg;
sleep(1);
FILE *datafp = NULL;;
datafp=fopen("student.txt", "w+");
fwrite(ptr,1,20,datafp);
fclose(datafp);
DBHANDLE db;
if ((db = db_open("db4", O_RDWR | O_CREAT | O_TRUNC,
FILE_MODE)) == NULL)
err_sys("db_open error");
if (db_store(db, "Alpha", "data1", DB_INSERT) != 0)
err_quit("db_store error for alpha");
if (db_store(db, "beta", "Data for beta", DB_INSERT) != 0)
err_quit("db_store error for beta");
if (db_store(db, "gamma", "record3", DB_INSERT) != 0)
err_quit("db_store error for gamma");
db_close(db);
exit(0);
//printf("hello world! %s\n",ptr);
}
static int
list_geometry(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
{
static struct db_i *dbip;
struct directory *dp;
int i;
struct bu_vls tclstr = BU_VLS_INIT_ZERO;
if (objc < 3) {
Tcl_WrongNumArgs(interp, 1, objv, "file varname");
return TCL_ERROR;
}
if ((dbip = db_open(Tcl_GetString(objv[1]), "r")) == DBI_NULL) {
bu_log("Unable to open geometry file (%s)\n", Tcl_GetString(objv[1]));
return TCL_ERROR;
}
db_dirbuild(dbip);
for (i = 0; i < RT_DBNHASH; i++) {
for (dp = dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) {
if (dp->d_flags & RT_DIR_HIDDEN) continue;
bu_vls_sprintf(&tclstr, "set %s [concat $%s [list %s]]", Tcl_GetString(objv[2]), Tcl_GetString(objv[2]), dp->d_namep);
Tcl_Eval(interp, bu_vls_addr(&tclstr));
}
}
db_close(dbip);
bu_vls_free(&tclstr);
return TCL_OK;
}
int db_open()
{
int err;
const char *tail;
static const char query_share_upd[] =
"UPDATE files SET name=?,ext=?,size=?,type=?,mlength=?,mbitrate=?,mcodec=? WHERE fid=?";
static const char query_share_ins[] =
"INSERT OR REPLACE INTO files(fid,hash,name,ext,size,type,mlength,mbitrate,mcodec) "
" VALUES(?,?,?,?,?,?,?,?,?)";
static const char query_share_src[] =
"INSERT INTO sources(fid,sid,complete,rating) VALUES(?,?,?,?)";
static const char query_remove_src[] =
"DELETE FROM sources WHERE sid=?";
static const char query_get_src[] =
"SELECT sid FROM sources WHERE fid=? LIMIT ?";
err = sqlite3_open_v2(DB_NAME, &s_db, DB_OPEN_FLAGS, NULL);
if ( SQLITE_OK != err ) {
ED2KD_LOGERR("failed to open DB (%s)", sqlite3_errmsg(s_db));
return 0;
}
DB_CHECK( SQLITE_OK == sqlite3_prepare_v2(s_db, query_share_upd, sizeof(query_share_upd), &s_stmt[SHARE_UPD], &tail) );
DB_CHECK( SQLITE_OK == sqlite3_prepare_v2(s_db, query_share_ins, sizeof(query_share_ins), &s_stmt[SHARE_INS], &tail) );
DB_CHECK( SQLITE_OK == sqlite3_prepare_v2(s_db, query_share_src, sizeof(query_share_src), &s_stmt[SHARE_SRC], &tail) );
DB_CHECK( SQLITE_OK == sqlite3_prepare_v2(s_db, query_remove_src, sizeof(query_remove_src), &s_stmt[REMOVE_SRC], &tail) );
DB_CHECK( SQLITE_OK == sqlite3_prepare_v2(s_db, query_get_src, sizeof(query_get_src), &s_stmt[GET_SRC], &tail) );
return 1;
failed:
db_close();
return 0;
}
/*
** COMMAND: sqlite3
**
** Usage: %fossil sqlite3 ?DATABASE? ?OPTIONS?
**
** Run the standalone sqlite3 command-line shell on DATABASE with OPTIONS.
** If DATABASE is omitted, then the repository that serves the working
** directory is opened.
**
** WARNING: Careless use of this command can corrupt a Fossil repository
** in ways that are unrecoverable. Be sure you know what you are doing before
** running any SQL commands that modifies the repository database.
*/
void sqlite3_cmd(void){
extern int sqlite3_shell(int, char**);
db_find_and_open_repository(OPEN_ANY_SCHEMA, 0);
db_close(1);
sqlite3_shutdown();
sqlite3_shell(g.argc-1, g.argv+1);
}
MYSQL *db_connect ( const URL *url ) {
MYSQL *sql = NULL;
char * table = NULL;
char * dbname = NULL;
if( (sql = mysql_init( NULL )) == NULL ) {
return NULL;
}
dbname = parse_url_dbname ( url );
table = parse_url_table ( url );
/* The old mysql_connect is no more supported, it seems! */
/* mysql_connect( sql, url->addr, url->usr, url->pwd ); */
if((mysql_real_connect(sql, url->addr, url->usr, url->pwd,
dbname, (unsigned int) url->port, NULL, 0 )) == NULL ) {
if( dbname ) PKI_Free ( dbname );
db_close( sql );
return( NULL );
}
if( dbname ) PKI_Free (dbname);
if( table ) PKI_Free (table);
return( sql );
}
int main() {
table *tab;
field **defs;
if(db_open("db")) {
g_error("db_open");
return 1;
}
tab = table_open("test");
if(!tab) {
g_error("table_open");
return 1;
}
defs = table_get_field_defs(tab);
while(!table_end(tab)) {
}
if(db_close()) {
g_error("db_clos ");
return 1;
}
return 0;
}
static gboolean
backend_get_depends_requires_thread (PkBackend *backend)
{
GList *list = NULL;
sqlite3 *db;
gchar **package_ids;
int deps_type;
gchar **package_id_data;
db = db_open ();
package_ids = pk_backend_get_strv (backend, "package_ids");
deps_type = pk_backend_get_uint (backend, "type");
/* FIXME: support multiple packages */
package_id_data = pk_package_id_split (package_ids[0]);
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
if (deps_type == DEPS_TYPE_DEPENDS)
list = box_db_repos_get_depends (db, package_id_data[PK_PACKAGE_ID_NAME]);
else if (deps_type == DEPS_TYPE_REQUIRES)
list = box_db_repos_get_requires (db, package_id_data[PK_PACKAGE_ID_NAME]);
add_packages_from_list (backend, list, FALSE);
box_db_repos_package_list_free (list);
db_close (db);
pk_backend_finished (backend);
return TRUE;
}
static gboolean
backend_get_packages_thread (PkBackend *backend)
{
PkBitfield filters;
GList *list = NULL;
sqlite3 *db = NULL;
filters = pk_backend_get_uint (backend, "filters");
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
db = db_open();
if ((pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) &&
pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) ||
(!pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) &&
!pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED))) {
list = box_db_repos_packages_search_all (db, NULL, 0);
} else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
list = box_db_repos_packages_search_installed (db, NULL, 0);
} else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) {
list = box_db_repos_packages_search_available (db, NULL, 0);
}
add_packages_from_list (backend, list, FALSE);
box_db_repos_package_list_free (list);
db_close(db);
pk_backend_finished (backend);
return TRUE;
}
/**
* destroy function of module
*/
void destroy(void)
{
int i;
#ifdef XJ_EXTRA_DEBUG
DBG("XJAB: Unloading module ...\n");
#endif
if(pipes)
{ // close the pipes
for(i = 0; i < nrw; i++)
{
if(pipes[i])
{
close(pipes[i][0]);
close(pipes[i][1]);
}
pkg_free(pipes[i]);
}
pkg_free(pipes);
}
// cleaning MySQL connections
if(db_con != NULL)
{
for(i = 0; i<nrw; i++)
db_close(db_con[i]);
shm_free(db_con);
}
xj_wlist_free(jwl);
DBG("XJAB: Unloaded ...\n");
}
void ydb_close(YDB ydb) {
struct db *db = (struct db *) ydb;
assert(db->magic == YDB_STRUCT_MAGIC);
db_close(db);
log_info(" **** ");
}
/**
* destroy function
*/
void destroy(void)
{
DBG("MSILO: destroy module ...\n");
msg_list_free(ml);
if(db_con)
db_close(db_con);
}
void ddfs_index_destroy() {
index_memory_overhead = db_close(); // one byte for each chunk
ddfs_index_flush();
container_cache_free(fingers_cache);
free(filter);
}
/*
* msg_close --
* Close the message catalogs.
*
* PUBLIC: void msg_close __P((GS *));
*/
void
msg_close(GS *gp)
{
if (gp->msg != NULL) {
(void)db_close(gp->msg);
gp->msg = NULL;
}
}
void test_db_teardown()
{
db_close();
if (system("rm -rf muddytest.db") == -1)
{
perror("system rm");
}
}
static int db_nessdb_instance_free()
{
db_close(instance.db);
instance.db = NULL;
printf("nessDB free\n");
return 0;
}
int main (int argc, char *argv[])
{
gchar *path;
guint hndl_id0, hndl_id1;
// char *lang;
int opt;
int longopt_index;
setlocale (LC_ALL, "");//lang);
static struct option long_options[] = {
{"help", 0, NULL, 'h'},
{"version", 0, NULL, 'v'},
{NULL, 0, NULL, 0}
};
while ((opt = getopt_long(argc, argv, "h:v", long_options, &longopt_index)) > 0)
{
switch (opt)
{
case 'v':
printf ("%s %s\n%s\n", g_ascii_strdown(APPNAME,strlen(APPNAME)),
VERSION,
"Copyright 2016 Roman Borisov");
goto cleanup;
break;
case 'h':
default:
fprintf(stderr, "usage: %s [options]\n", basename(argv[0]));
fprintf(stderr, " -h, --help display this help\n");
fprintf(stderr, " -v, --version version information\n");
return 1;
}
}
gdk_threads_init ();
gtk_init (&argc, &argv);
gtk_app_init();
// gtk_window_fullscreen(GDK_WINDOW(gtk.main_window));
gtk_widget_show (gtk.main_window);
db_init();
gdk_threads_enter ();
hndl_id0 = g_idle_add((GtkFunction)mpd_idle, NULL);
hndl_id1 = g_idle_add((GtkFunction)player_idle, NULL);
gtk_main ();
gtk_idle_remove(hndl_id0);
gtk_idle_remove(hndl_id1);
gdk_threads_leave ();
db_close();
cleanup:
return 0;
}
static void free_ext4_db(struct inode *inode)
{
struct db_handle *db_handle = inode->i_db;
struct block_device *bdev = inode->i_sb->s_bdev;
inode_free(inode);
db_close(db_handle);
bdev_free(bdev);
fs_bh_showstat();
}
static void mod_destroy(void)
{
DBG("PDT: mod_destroy : Cleaning up\n");
if (hash)
free_double_hash(hash);
if (db_con)
db_close(db_con);
if (next_code)
shm_free(next_code);
lock_destroy(&l);
}
