std::vector<std::string> process() { std::srand(std::time(0)); std::vector<CallbackData> dbs; std::vector<std::string> tortured_databases; dbs.emplace_back(CallbackData(tortured_databases, open_database("test1.db"))); dbs.emplace_back(CallbackData(tortured_databases, open_database("test2.db"))); dbs.emplace_back(CallbackData(tortured_databases, open_database("test3.db"))); dbs.emplace_back(CallbackData(tortured_databases, open_database("test4.db"))); dbs.emplace_back(CallbackData(tortured_databases, open_database("test5.db"))); for (size_t i = 0; i<dbs.size(); ++i) { sqlite3_trace(dbs[i].db_, trace_callback, &dbs[i]); } for (size_t i = 0; i<dbs.size(); ++i) { torture_database(dbs[std::rand() % dbs.size()].db_); } for (size_t i = 0; i<dbs.size(); ++i) { sqlite3_close(dbs[i].db_); } return tortured_databases; }
int run(void) { dbi_conn conn; if (!cache) { cache = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, free_probe); } LOG(LOG_INFO, "reading info from database"); uw_setproctitle("reading info from database"); conn = open_database(OPT_ARG(DBTYPE), OPT_ARG(DBHOST), OPT_ARG(DBPORT), OPT_ARG(DBNAME), OPT_ARG(DBUSER), OPT_ARG(DBPASSWD)); if (conn) { refresh_database(conn); close_database(conn); } if (g_hash_table_size(cache) > 0) { LOG(LOG_INFO, "running %d probes", g_hash_table_size(cache)); uw_setproctitle("running %d probes", g_hash_table_size(cache)); run_actual_probes(); /* this runs the actual probes */ LOG(LOG_INFO, "writing results"); uw_setproctitle("writing results"); write_results(); } return(g_hash_table_size(cache)); }
int main(int argc, char *argv[]) { int opt = 0; int all = 0; unsigned int lb = 2, rb = -1; while ((opt = getopt_long(argc, argv, "al:r:", NULL, NULL)) != -1) { switch (opt) { case 'a': /* all distances */ all = 1; break; case 'l': lb = atoi(optarg); break; case 'r': rb = atoi(optarg); break; default: return -1; } } assert(lb >= 2); open_database(); if(all == 1) distance_between_all_chunk_references(lb, rb); else distance_between_first_two_chunk_references(lb, rb); close_database(); return 0; }
int main(int argc, char *argv[]) { int opt = 0; unsigned int lb = 1, rb =-1; int distribution = 0; while ((opt = getopt_long(argc, argv, "l:r:d", NULL, NULL)) != -1) { switch (opt) { case 'l': lb = atoi(optarg); break; case 'r': rb = atoi(optarg); break; case 'd': distribution = 1; break; default: return -1; } } open_database(); if(distribution) get_chunksize_distribution(lb, rb); else avg_chunksize(); close_database(); return 0; }
int run(void) { database *db; if (!cache) { cache = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, free_probe); } LOG(LOG_INFO, "reading info from database (group %u)", (unsigned)OPT_VALUE_GROUPID); uw_setproctitle("reading info from database (group %u)", (unsigned)OPT_VALUE_GROUPID); db = open_database(OPT_ARG(DBTYPE), OPT_ARG(DBHOST), OPT_VALUE_DBPORT, OPT_ARG(DBNAME), OPT_ARG(DBUSER), OPT_ARG(DBPASSWD)); if (db) { refresh_database(db); close_database(db); } if (g_hash_table_size(cache) > 0) { LOG(LOG_INFO, "running %d probes from group %u", g_hash_table_size(cache), (unsigned)OPT_VALUE_GROUPID); uw_setproctitle("running %d probes from group %u", g_hash_table_size(cache), (unsigned)OPT_VALUE_GROUPID); run_actual_probes(); /* this runs the actual probes */ LOG(LOG_INFO, "writing results"); uw_setproctitle("writing results"); write_results(); } return(g_hash_table_size(cache)); }
DB_TEST_BASE::DB_TEST_BASE() : DateFormat("yyyy-MM-dd"), DateTimeFormat("yyyy-MM-dd hh:mm:ss"), TimeFormat("hh:mm:ss") { database_name = QString("drc_db.db3"); open_database(); AllocateTableNames(); AllocateTableColumns(); AllocateVectorValues(); //Write method that accepts vector, and inserts into DB Object FullPerson = InitializePersonObject(full_person_values); EmptyPerson = InitializePersonObject(empty_person_values); EmptyProcess = InitializeProcessObject(empty_process_values); FullProcess = InitializeProcessObject(full_process_values); EmptySession = InitializeSessionObject(empty_session_values); FullSession = InitializeSessionObject(full_session_values); EmptyParty = InitializeClientObject(EmptyPerson); FullParty = InitializeClientObject(FullPerson); EmptyClientSession = InitializeClientSessionObject(empty_client_session_values); FullClientSession = InitializeClientSessionObject(full_client_session_values); EmptyNote = InitializeNoteObject(empty_note_values); FullNote = InitializeNoteObject(full_note_values); EmptyEvaluation = InitializeEvaluationObject(empty_evaluation_values); }
int main(int argc, char** argv) { u32 seed; struct timeval tv; signal(SIGINT, ctrlc_handler); signal(SIGPIPE, SIG_IGN); SSL_library_init(); gettimeofday(&tv, NULL); seed = tv.tv_usec ^ (tv.tv_sec << 16) ^ getpid(); srandom(seed); if (resp_tmout < rw_tmout) resp_tmout = rw_tmout; if (max_connections < max_conn_host) max_connections = max_conn_host; open_database(); setup_bayes(); parse_opts(argc, argv); fflush(0); EVP_cleanup(); CRYPTO_cleanup_all_ex_data(); return 0; }
static int check_passwd(const char * user, const char *pass) { sqlite3_stmt *res; const char *tail; const char *tmp_pass; int ret = CMD_NOT_AUTHORIZED; char *sql; sql = "SELECT * FROM USERS WHERE NICK LIKE ?"; passwd_db = open_database(); CALL_SQLITE (prepare_v2(passwd_db, sql, strlen (sql), &res, &tail)); CALL_SQLITE (bind_text(res, 1, user, strlen (user), 0)); while (sqlite3_step(res) == SQLITE_ROW) { tmp_pass = (const char *) sqlite3_column_text(res, 1); if (strcmp(tmp_pass,pass) == 0) { log_debug("USER: (%s) is authenticated",user); ret = CMD_AUTHORIZED; } } sqlite3_reset(res); log_debug("auth_code_resp(%d) \n", ret); return (ret); }
int example_main(int argc, char **argv) { /* Create a database with the current schema definition */ db_t hdb = create_database( EXAMPLE_DATABASE, &v2_schema, init_data_cb ); /* Create database with v1 schema */ db_t hdb_upgrade = create_database( EXAMPLE_UPGRADE_DATABASE, &v1_schema, init_data_cb ); /* Open database with v1 schema and upgrade to current schema */ db_shutdown( hdb_upgrade, 0, NULL ); hdb = open_database( EXAMPLE_UPGRADE_DATABASE, &v2_schema, &upgrade_schema_cb ); if( hdb != NULL ) { int v = get_schema_version( hdb_upgrade ); db_shutdown( hdb_upgrade, 0, NULL ); db_shutdown( hdb, 0, NULL ); if (v == v2_schema.version) { return EXIT_SUCCESS; } } db_shutdown( hdb_upgrade, 0, NULL ); db_shutdown( hdb, 0, NULL ); return EXIT_FAILURE; }
int main(int argc, char **argv) { int fd, database_fd, database_size; krb5_error_code retval; krb5_context context; krb5_creds *my_creds; krb5_auth_context auth_context; setlocale(LC_ALL, ""); retval = krb5_init_context(&context); if (retval) { com_err(argv[0], retval, _("while initializing krb5")); exit(1); } parse_args(argc, argv); get_tickets(context); database_fd = open_database(context, file, &database_size); open_connection(context, slave_host, &fd); kerberos_authenticate(context, &auth_context, fd, my_principal, &my_creds); xmit_database(context, auth_context, my_creds, fd, database_fd, database_size); update_last_prop_file(slave_host, file); printf(_("Database propagation to %s: SUCCEEDED\n"), slave_host); krb5_free_cred_contents(context, my_creds); close_database(context, database_fd); exit(0); }
int main(int argc, char *argv[]) { if(open_database()) create_medialib(); else { g_print("错误:无法打开数据库。"); return 1; } link_t mlink = {NULL, 0}; link_t plink = {NULL, 0}; load_medialib(&mlink, 0); main_core(GENERAL_MEDIALIB_INIT, &mlink); main_core(GENERAL_PLAYLIST_INIT, &plink); gtk_init(&argc, &argv); InterFace ui; ui.winMain = create_winMain(&ui); ui.diaMedialib = create_diaMedialib(&ui); ui.diaPlaylist = create_diaPlaylist(&ui); ui.diaVolume = create_diaVolume(&ui); gtk_widget_show(ui.winMain); g_signal_connect(G_OBJECT(ui.winMain), "delete_event", G_CALLBACK(gtk_main_quit), NULL); gtk_main(); link_del_all(&mlink); link_del_all(&plink); close_database(); return 0; }
static int uw_password_ok(char *user, char *passwd) { MYSQL_RES *result; if (open_database() == 0) { gchar buffer[256]; MYSQL_ROW row; sprintf(buffer, "select id from contact where username = '******' and password = '******'", user, passwd); if (mysql_query(mysql, buffer)) { close_database(); LOG(LOG_ERR, "buffer: %s", mysql_error(mysql)); return(FALSE); } result = mysql_store_result(mysql); if (!result) { close_database(); if (debug) LOG(LOG_DEBUG, "user %s, pwd %s not found", user, passwd); return(FALSE); } if ((row = mysql_fetch_row(result))) { int id; id = atoi(row[0]); if (debug) LOG(LOG_DEBUG, "user %s, pwd %s resulted in id %d", user, passwd, id); printf("\n"); } mysql_free_result(result); close_database(); } return(TRUE); }
int main(int argc, char *argv[]) { int opt = 0; unsigned int lb = 2, rb =-1; int task = 0; while ((opt = getopt_long(argc, argv, "l:r:t", NULL, NULL)) != -1) { switch (opt) { case 'l': lb = atoi(optarg); break; case 'r': rb = atoi(optarg); break; case 't': task = 1; break; default: return -1; } } /* makes no sense to analyze reference number 1 */ assert(lb > 1); open_database(); if(task == 1) get_file2ref_ratio(lb, rb); else analyze_references_source(lb, rb); close_database(); return 0; }
int find_expired_probes(struct dbspec *dbspec) { xmlDocPtr doc; xmlNodePtr probe; dbi_result result; dbi_conn conn; int count = 0; char buf[10]; sprintf(buf, "%d", dbspec->port); conn = open_database(OPT_ARG(DBTYPE), dbspec->host, buf, dbspec->db, dbspec->user, dbspec->password); if (!conn) return 0; doc = UpwatchXmlDoc("result", NULL); // find all expired probes, but skip those for which processing // has been stopped for some reason result = db_query(conn, 0, "select probe.name, pr_status.probe, " " pr_status.server, pr_status.color, " " pr_status.expires " "from pr_status, probe " "where probe.id = pr_status.class and color <> 400 " " and expires < UNIX_TIMESTAMP()-30 " " and expires < probe.lastseen" " and probe.expiry = 'yes'"); if (!result) goto errexit; while (dbi_result_next_row(result)) { char buffer[256]; time_t now = time(NULL); probe = xmlNewChild(xmlDocGetRootElement(doc), NULL, dbi_result_get_string(result, "name"), NULL); xmlSetProp(probe, "realm", dbspec->realm); xmlSetProp(probe, "id", dbi_result_get_string(result, "probe")); xmlSetProp(probe, "server", dbi_result_get_string(result, "server")); sprintf(buffer, "%u", (int) now); xmlSetProp(probe, "date", buffer); xmlSetProp(probe, "expires", dbi_result_get_string(result, "expires")); xmlNewChild(probe, NULL, "color", "400"); // PURPLE xmlNewChild(probe, NULL, "prevcolor", dbi_result_get_string(result, "color")); LOG(LOG_INFO, "%s: purpled %s %d", dbspec->realm, dbi_result_get_string(result, "name"), dbi_result_get_uint(result, "probe")); count++; } if (count) { xmlSetDocCompressMode(doc, OPT_VALUE_COMPRESS); spool_result(OPT_ARG(SPOOLDIR), OPT_ARG(OUTPUT), doc, NULL); LOG(LOG_INFO, "%s: purpled %u probes", dbspec->realm, count); } errexit: if (result) dbi_result_free(result); if (conn) close_database(conn); if (doc) xmlFreeDoc(doc); return count; }
void MainWindow::setup_database() { //setup database QSettings settings; if(!settings.contains("database file name")) settings.setValue("database file name", db_location); QFileInfo dbpath(settings.value("database file name").toString()); open_database(dbpath); }
/** * Start logging * * @param sqlite3 db * * @return int */ int activate_log(sqlite3* db) { remove("log.db"); if (open_database(db)) { if (create_table(db)) { enableLog = 1; return 1; } } }
int main() { open_database("database.dat"); int nums = 0; char** a = lookup_songs(&nums); for(int i = 0; i < nums; i++) { printf("%s\n", a[i]); } return 0; }
/** * Inits the main structure. * @note With sqlite version > 3.7.7 we should use URI filename. * @param opt : a filled options_t * structure that contains all options * by default, read into the file or selected in the command line. * @returns a main_struct_t * pointer to the main structure */ static main_struct_t *init_main_structure(options_t *opt) { main_struct_t *main_struct = NULL; gchar *db_uri = NULL; gchar *conn = NULL; if (opt != NULL) { print_debug(_("Please wait while initializing main structure...\n")); main_struct = (main_struct_t *) g_malloc0(sizeof(main_struct_t)); create_directory(opt->dircache); db_uri = g_build_filename(opt->dircache, opt->dbname , NULL); main_struct->database = open_database(db_uri); db_uri = free_variable(db_uri); main_struct->opt = opt; main_struct->hostname = g_get_host_name(); if (opt != NULL && opt->ip != NULL) { conn = make_connexion_string(opt->ip, opt->port); main_struct->comm = init_comm_struct(conn); main_struct->reconnected = init_comm_struct(conn); free_variable(conn); } else { /* This should never happen because we have default values */ main_struct->comm = NULL; } main_struct->signal_fd = start_signals(); main_struct->fanotify_fd = start_fanotify(opt); /* inits the queue that will wait for events on files */ main_struct->save_queue = g_async_queue_new(); main_struct->dir_queue = g_async_queue_new(); main_struct->regex_exclude_list = make_regex_exclude_list(opt->exclude_list); /* Thread initialization */ main_struct->save_one_file = g_thread_new("save_one_file", save_one_file_threaded, main_struct); main_struct->carve_all_directories = g_thread_new("carve_all_directories", carve_all_directories, main_struct); main_struct->reconn_thread = g_thread_new("reconnected", reconnected, main_struct); print_debug(_("Main structure initialized !\n")); } return main_struct; }
void find(const bfs::path& cdb_path, const options& opt) { config cfg = load_config(cdb_path / "config"); const bfs::path cdb_root = cdb_path.parent_path(); const bfs::path search_root = bfs::initial_path(); std::size_t prefix_size = 0; std::string file_match; if(opt.m_options.count("-a") == 0 && search_root != cdb_root) { file_match = "^" + escape_regex( search_root.generic_string().substr(cdb_root.string().size() + 1) + "/") + ".*"; prefix_size = search_root.string().size() - cdb_root.string().size(); } file_lock lock(cdb_path / "lock"); lock.lock_sharable(); const char* find_regex_options = opt.m_options.count("-i") ? "i" : ""; const char* file_regex_options = cfg.get_value("nocase-file-match") == "on" ? "i" : ""; bool trim = cfg.get_value("find-trim-ws") == "on"; unsigned thread_count = get_thread_count(cfg); unsigned buffer_count = get_buffer_count(thread_count); for(unsigned i = 0; i != opt.m_args.size(); ++i) { database_ptr db = open_database(cdb_path / "db"); std::string pattern = opt.m_args[i]; if(opt.m_options.count("-v")) pattern = escape_regex(pattern); mt_search mts(*db, trim, prefix_size, buffer_count); auto worker = [&] { mts.search_db(compile_regex(pattern, 0, find_regex_options), compile_regex(file_match, 0, file_regex_options)); }; boost::thread_group workers; for(unsigned i = 0; i != thread_count-1; ++i) workers.create_thread(worker); worker(); workers.join_all(); } }
static VALUE t_use(VALUE self, VALUE dbname) { char *name; if (TYPE(dbname) != T_STRING){ rb_raise(rb_eArgError, "ArgError: need a String, %s given", rb_obj_classname(dbname)); } name = StringValueCStr(dbname); return INT2NUM(open_database(name)); }
int main(int argc, char *argv[]) { /* dedup? */ int dedup = 0; /* weighted by file/chunk size? */ int weighted = 0; /* chunk level or file level */ int file_level = 0; char *pophash = NULL; int opt = 0; while ((opt = getopt_long(argc, argv, "fwdp:", NULL, NULL)) != -1) { switch (opt) { case'f': file_level = 1; break; case 'd': dedup = 1; break; case 'w': weighted = 1; break; case 'p': pophash = optarg; break; default: fprintf(stderr, "invalid option\n"); return -1; } } open_database(); if (!file_level) { if (!dedup) chunk_nodedup_simd_trace(&argv[optind], argc - optind, weighted); else chunk_dedup_simd_trace(&argv[optind], argc - optind, weighted, pophash); } else { if (!dedup) file_nodedup_simd_trace(&argv[optind], argc - optind, weighted); else file_dedup_simd_trace(&argv[optind], argc - optind, weighted, pophash); } close_database(); return 0; }
/*================================================== * open_or_create_database -- open database, prompt for * creating new one if it doesn't exist * if fails, displays error (show_open_error) and returns * FALSE * alteration: [IN] flags for locking, forcing open... * dbused: [I/O] actual database path (may be relative) * If this routine creates new database, it will alter dbused * Created: 2001/04/29, Perry Rapp *================================================*/ BOOLEAN open_or_create_database (INT alteration, STRING *dbused) { INT lldberrnum=0; /* Open Database */ if (open_database(alteration, *dbused, &lldberrnum)) return TRUE; /* filter out real errors */ if (lldberrnum != BTERR_NODB && lldberrnum != BTERR_NOKEY) { show_open_error(lldberrnum); return FALSE; } if (readonly || immutable || alteration) { llwprintf(_("Cannot create new database with -r, -i, -l, or -f flags.")); return FALSE; } /* error was only that db doesn't exist, so lets try making a new one If no database directory specified, add prefix llnewdbdir */ if (is_unadorned_directory(*dbused)) { STRING dbpath = getlloptstr("LLDATABASES", "."); CNSTRING newdbdir = get_first_path_entry(dbpath); STRING temp = *dbused; if (newdbdir) { char tempth[MAXPATHLEN]; newdbdir = strdup(newdbdir); concat_path(newdbdir, *dbused, uu8, tempth, sizeof(tempth)); *dbused = strsave(tempth); stdfree(temp); stdfree((STRING)newdbdir); } } /* Is user willing to make a new db ? */ if (!ask_yes_or_no_msg(_(qSnodbse), _(qScrdbse))) return FALSE; /* try to make a new db */ if (create_database(*dbused, &lldberrnum)) return TRUE; show_open_error(lldberrnum); return FALSE; }
void result_obtainer::Get_Result() { map_table *map_ptr = &Result_list; open_database(); const char* sql = pre_sql.c_str(); /* Execute SQL statement */ rc = sqlite3_exec(db, sql, callback, (void*)map_ptr, &zErrMsg); if( rc != SQLITE_OK ){ cout << sql << endl; fprintf(stderr, "SQL error: %s\n", zErrMsg); sqlite3_free(zErrMsg); } close_database(); }
static int open_env(struct databases *db, int which) { int e; memset(db, 0, sizeof(struct databases)); e = db_env_create(&db->env, 0); if (e) { log_error("Cannot create database environment, %s\n", db_strerror(e)); db->env = NULL; return -1; } e = db->env->open(db->env, cfg_data_dir, DB_INIT_LOCK |DB_INIT_MPOOL | DB_INIT_LOG | DB_INIT_TXN | DB_CREATE, 0 ); if (e) { log_error("Cannot open database environment, %s\n", db_strerror(e)); return -2; } if (which & MODEL_DB) { if (open_database(db->env, &db->model, "model.db")) return -3; } if (which & APP_DB) { if (open_database(db->env, &db->app, "app.db")) return -4; } if (which & CODE_DB) { if (open_database(db->env, &db->code, "code.db")) return -5; } if (which & PROFILE_DB) { if (open_database(db->env, &db->profile, "profile.db")) return -6; } return 0; }
string Database::getInitDate() { string re; open_database(); string pre_sql = "SELECT DATE FROM DATE_TIME WHERE ID = 2;"; const char* sql = pre_sql.c_str(); sqlite3_stmt *pstmt; sqlite3_prepare(db, sql, (int)strlen(sql), &pstmt, NULL); sqlite3_step(pstmt); re = (const char*)sqlite3_column_text(pstmt, 0); sqlite3_finalize(pstmt); sqlite3_close(db); return re; }
bool Database::exist_in_db(const string &name, const string &title, const string &table) { open_database(); string pre_sql = "SELECT COUNT(*) FROM " + table + " WHERE " + title + " = '" + name + "';"; const char* sql = pre_sql.c_str(); sqlite3_stmt *pstmt; sqlite3_prepare(db, sql, (int)strlen(sql), &pstmt, NULL); sqlite3_step(pstmt); int count = sqlite3_column_int(pstmt,0); sqlite3_finalize(pstmt); sqlite3_close(db); if(count > 0) return true; return false; }
EAPI int elm_main(int argc, char **argv) { //const char *theme; //int ret; //get users home dir const char *name = "HOME"; sprintf(home_dir, "%s", getenv(name)); //adjust finger size elm_config_finger_size_set(55); //paroli theme fix - not required anymore //theme = "tasks"; //elm_theme_overlay_add(theme); //set up win win = elm_win_add(NULL, "tasks", ELM_WIN_BASIC); elm_win_title_set(win, "Tasks"); evas_object_smart_callback_add(win, "delete,request", my_win_del, NULL); //open database open_database(); // show the window create_gui(win); evas_object_show(win); //restore state restore_state(); occupy_cpu(); elm_run(); //clean up stuff //clean_up(); ecore_main_loop_quit(); elm_shutdown(); return 0; }
int main(int argc, char *argv[]) { int opt = 0; int flag = FLAG_IDENTICAL_FILES; while ((opt = getopt_long(argc, argv, "isdr", NULL, NULL)) != -1) { switch (opt) { case 'i': flag = FLAG_IDENTICAL_FILES; break; case 's': flag = FLAG_SIMILAR_FILES; break; case 'd': flag = FLAG_DISTINCT_FILES; break; case 'r': flag = FLAG_INTRA_REDUNDANT_FILES; break; default: return -1; } } open_database(); if(flag == FLAG_IDENTICAL_FILES) collect_identical_files(); else if(flag == FLAG_SIMILAR_FILES) collect_similar_files(); else if(flag == FLAG_DISTINCT_FILES) collect_distinct_files(); else if(flag == FLAG_INTRA_REDUNDANT_FILES) collect_intra_redundant_files(); close_database(); return 0; }
//************************************************************************ // read pr_status file for expired probes. Construct fake results // for those. //*********************************************************************** int run(void) { dbi_result result; dbi_conn conn; int count = 0; conn = open_database(OPT_ARG(DBTYPE), OPT_ARG(DBHOST), OPT_ARG(DBPORT), OPT_ARG(DBNAME), OPT_ARG(DBUSER), OPT_ARG(DBPASSWD)); if (!conn) return 0; LOG(LOG_INFO, "processing .."); uw_setproctitle("reading info from database"); result = db_query(conn, 0, "select pr_realm.id, pr_realm.name, pr_realm.host, " " pr_realm.port, pr_realm.db, pr_realm.user, " " pr_realm.password " "from pr_realm " "where pr_realm.id > 1"); if (result) { while (dbi_result_next_row(result)) { struct dbspec db; db.domid = dbi_result_get_uint(result, "id"); db.realm = dbi_result_get_string(result, "name"); db.host = dbi_result_get_string(result, "host"); db.port = dbi_result_get_uint(result, "port"); db.db = dbi_result_get_string(result, "db"); db.user = dbi_result_get_string(result, "user"); db.password = dbi_result_get_string(result, "password"); uw_setproctitle("checking %s", dbi_result_get_string(result, "name")); LOG(LOG_DEBUG, "checking %s", dbi_result_get_string(result, "name")); count += find_expired_probes(&db); } dbi_result_free(result); } close_database(conn); LOG(LOG_INFO, "sleeping"); return count; }
main() { printf("hello\n"); char* ptr = malloc(5); convertLengthTo2Bytes(ptr, 5); printf("%d\n", ptr[1]); open_database("compare.dat"); char* in = "Name913221111111111111222222222222222222221222111111111111122222222222222222222N12221111111111111222222222222222222222222222222222226Name412221111111111111222222222222222222221222111111111111122222222222222222222N12221111111111111222222222222222222222222222222222221Name112221111111111111222222222222222222221222111111111111122222222222222222222N12221111111111111222222222222222222222222222222222226"; char* coma = compareSongsToClient(in, 2); char* comb = compareSongsToServer(in, 2); int lena = getLength(coma); coma += 2; for(int i = 0; i < lena; i++) { printf("song %s\n", coma); coma += SONG_LENGTH; printf("sha %s\n", coma); coma += SHA_LENGTH; } //printf("a: %s\n", coma); int lenb = getLength(comb); comb += 2; printf("\nnext\n"); for(int i = 0; i < lenb; i++) { printf("song %s\n", comb); comb += SONG_LENGTH; printf("sha %s\n", comb); comb += SHA_LENGTH; } close_database(); }