static void *worker_bee(void *pArg){
const char *zFilename = (char*)pArg;
char *azErr;
int i, cnt;
int t = atoi(zFilename);
char **az;
sqlite *db;
pthread_mutex_lock(&lock);
thread_cnt++;
pthread_mutex_unlock(&lock);
printf("%s: START\n", zFilename);
fflush(stdout);
for(cnt=0; cnt<10; cnt++){
db = sqlite_open(&zFilename[2], 0, &azErr);
if( db==0 ){
fprintf(stdout,"%s: can't open\n", zFilename);
Exit(1);
}
sqlite_busy_handler(db, db_is_locked, zFilename);
db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t);
for(i=1; i<=100; i++){
db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);",
t, i, i*2, i*i);
}
az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t);
db_check(zFilename, "tX size", az, "100", 0);
az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
db_check(zFilename, "tX avg", az, "101", 0);
db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t);
az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
db_check(zFilename, "tX avg2", az, "51", 0);
for(i=1; i<=50; i++){
char z1[30], z2[30];
az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i);
sprintf(z1, "%d", i*2);
sprintf(z2, "%d", i*i);
db_check(zFilename, "readback", az, z1, z2, 0);
}
db_execute(db, zFilename, "DROP TABLE t%d;", t);
sqlite_close(db);
}
printf("%s: END\n", zFilename);
/* unlink(zFilename); */
fflush(stdout);
pthread_mutex_lock(&lock);
thread_cnt--;
if( thread_cnt<=0 ){
pthread_cond_signal(&sig);
}
pthread_mutex_unlock(&lock);
return 0;
}
int main(void)
{
Disp_Init(DISP_INIT_ON); //初始化 LCD
Disp_Clear();
KEY_Init(KEY_BEEP_KEY|KEY_AUTO_EL_ON); //初始化 Keyborad
KEY_Beep_Mask_Set(0xffffffff);
KEY_EL_Mask_Set(0xffffffff);
EL_Set_Timeout(20); //定时关闭背光灯
Sys_Auto_Poweroff_Set(60*2); //定时待机
//Meanless for 0218/0318/0518
Disp_Icon_Battery_Time_Set(1,ICON_AT_TAIL);
Disp_Icon_Battery_Time_Refresh();
Disp_Set_Color(SET_FONT_COLOR, 0x0000); //黑
Disp_Set_Color(SET_BACK_COLOR, 0xFFFF); //白
Disp_Set_Color(SET_SELECT_COLOR, 0x07E0); //绿
Disp_Set_Color(SET_CLEAR_COLOR, 0xFFFF); //白
adminPsd_init(); //一次性初始化，数据初置
db_check(); //数据库检查
//wifiInit_open(); //wifi初始化
main_task();
return 0;
}
int
pre_assemble(int handle,
int num_readings,
char **reading_array)
{
GapIO *io;
int ngels;
int nconts;
int idbsiz;
int *relpg;
int *lngthg;
int *lnbr;
int *rnbr;
if (NULL == (io = io_handle(&handle))) return -1;
/* initialise fortran arrays */
idbsiz = io_dbsize(io);
relpg = &io_relpos(io,1);
lngthg = &io_length(io,1);
lnbr = &io_lnbr(io,1);
rnbr = &io_rnbr(io,1);
if (-1 == load_preassembled(io, num_readings, reading_array)) {
verror(ERR_WARN, "enter_preassembled", "failed");
}
update_fortran_arrays(handle, &ngels, &nconts, &idbsiz,
relpg, lngthg, lnbr, rnbr);
/*
dbchek_(handle, relpg, lngthg, lnbr, rnbr, idm, idbsiz, ngels, nconts,
&ierr);
*/
if (db_check(io) != 0) {
verror(ERR_FATAL, "enter_preassembled",
"The database is now inconsistent.\n"
"You may wish to revert to a copy or to disassemble the newly "
"assembled contig.");
}
flush2t(io);
return 0;
} /* end pre_assemble */
/**
* Returns the database. If this function returns false, this has not
* succeeded, and the caller should create the database after the
* process has been daemonized.
*/
static bool
glue_db_init_and_load(void)
{
const char *path = config_get_path(CONF_DB_FILE);
bool ret;
GError *error = NULL;
if (!mapper_has_music_directory()) {
if (path != NULL)
g_message("Found " CONF_DB_FILE " setting without "
CONF_MUSIC_DIR " - disabling database");
db_init(NULL);
return true;
}
if (path == NULL)
g_error(CONF_DB_FILE " setting missing");
db_init(path);
ret = db_load(&error);
if (!ret) {
g_warning("Failed to load database: %s", error->message);
g_error_free(error);
if (!db_check())
exit(EXIT_FAILURE);
db_clear();
/* run database update after daemonization */
return false;
}
return true;
}
int atheme_main(int argc, char *argv[])
{
int daemonize_pipe[2];
bool have_conf = false;
bool have_log = false;
bool have_datadir = false;
char buf[32];
int pid, r;
FILE *pid_file;
const char *pidfilename = RUNDIR "/atheme.pid";
char *log_p = NULL;
mowgli_getopt_option_t long_opts[] = {
{ NULL, 0, NULL, 0, 0 },
};
atheme_bootstrap();
/* do command-line options */
while ((r = mowgli_getopt_long(argc, argv, "c:dhrl:np:D:v", long_opts, NULL)) != -1)
{
switch (r)
{
case 'c':
config_file = sstrdup(mowgli_optarg);
have_conf = true;
break;
case 'd':
log_force = true;
break;
case 'h':
print_help();
exit(EXIT_SUCCESS);
break;
case 'r':
readonly = true;
break;
case 'l':
log_p = sstrdup(mowgli_optarg);
have_log = true;
break;
case 'n':
runflags |= RF_LIVE;
break;
case 'p':
pidfilename = mowgli_optarg;
break;
case 'D':
datadir = mowgli_optarg;
have_datadir = true;
break;
case 'v':
print_version();
exit(EXIT_SUCCESS);
break;
default:
printf("usage: atheme [-dhnvr] [-c conf] [-l logfile] [-p pidfile]\n");
exit(EXIT_FAILURE);
break;
}
}
if (!have_conf)
config_file = sstrdup(SYSCONFDIR "/atheme.conf");
if (!have_log)
log_p = sstrdup(LOGDIR "/atheme.log");
if (!have_datadir)
datadir = sstrdup(DATADIR);
cold_start = true;
runflags |= RF_STARTING;
atheme_init(argv[0], log_p);
slog(LG_INFO, "%s is starting up...", PACKAGE_STRING);
/* check for pid file */
#ifndef MOWGLI_OS_WIN
if ((pid_file = fopen(pidfilename, "r")))
{
if (fgets(buf, 32, pid_file))
{
pid = atoi(buf);
if (!kill(pid, 0))
{
fprintf(stderr, "atheme: daemon is already running\n");
exit(EXIT_FAILURE);
}
}
fclose(pid_file);
}
#endif
if (!(runflags & RF_LIVE))
daemonize(daemonize_pipe);
atheme_setup();
conf_init();
if (!conf_parse(config_file))
{
slog(LG_ERROR, "Error loading config file %s, aborting",
config_file);
exit(EXIT_FAILURE);
}
if (config_options.languagefile)
{
slog(LG_DEBUG, "Using language: %s", config_options.languagefile);
if (!conf_parse(config_options.languagefile))
slog(LG_INFO, "Error loading language file %s, continuing",
config_options.languagefile);
}
if (!backend_loaded && authservice_loaded)
{
slog(LG_ERROR, "atheme: no backend modules loaded, see your configuration file.");
exit(EXIT_FAILURE);
}
/* we've done the critical startup steps now */
cold_start = false;
/* load our db */
if (db_load)
db_load(NULL);
else if (backend_loaded)
{
slog(LG_ERROR, "atheme: backend module does not provide db_load()!");
exit(EXIT_FAILURE);
}
db_check();
#ifdef HAVE_GETPID
/* write pid */
if ((pid_file = fopen(pidfilename, "w")))
{
fprintf(pid_file, "%d\n", getpid());
fclose(pid_file);
}
else
{
fprintf(stderr, "atheme: unable to write pid file\n");
exit(EXIT_FAILURE);
}
#endif
/* detach from terminal */
if ((runflags & RF_LIVE) || !detach_console(daemonize_pipe))
{
#ifdef HAVE_GETPID
slog(LG_INFO, "pid %d", getpid());
#endif
slog(LG_INFO, "running in foreground mode from %s", PREFIX);
}
/* no longer starting */
runflags &= ~RF_STARTING;
/* we probably have a few open already... */
me.maxfd = 3;
/* DB commit interval is configurable */
if (db_save && !readonly)
mowgli_timer_add(base_eventloop, "db_save", db_save, NULL, config_options.commit_interval);
/* check expires every hour */
mowgli_timer_add(base_eventloop, "expire_check", expire_check, NULL, 3600);
/* check k/x/q line expires every minute */
mowgli_timer_add(base_eventloop, "kline_expire", kline_expire, NULL, 60);
mowgli_timer_add(base_eventloop, "xline_expire", xline_expire, NULL, 60);
mowgli_timer_add(base_eventloop, "qline_expire", qline_expire, NULL, 60);
/* check authcookie expires every ten minutes */
mowgli_timer_add(base_eventloop, "authcookie_expire", authcookie_expire, NULL, 600);
/* reseed rng a little every five minutes */
mowgli_timer_add(base_eventloop, "rng_reseed", rng_reseed, NULL, 293);
me.connected = false;
uplink_connect();
/* main loop */
io_loop();
/* we're shutting down */
hook_call_shutdown();
if (db_save && !readonly)
db_save(NULL);
remove(pidfilename);
errno = 0;
if (curr_uplink != NULL && curr_uplink->conn != NULL)
sendq_flush(curr_uplink->conn);
connection_close_all();
me.connected = false;
/* should we restart? */
if (runflags & RF_RESTART)
{
slog(LG_INFO, "main(): restarting");
#ifdef HAVE_EXECVE
execv(BINDIR "/atheme-services", argv);
#endif
}
slog(LG_INFO, "main(): shutting down");
mowgli_eventloop_destroy(base_eventloop);
log_shutdown();
return 0;
}
int main(int argc, char *argv[])
{
bool have_conf = false;
bool have_log = false;
char buf[32];
int i, pid, r;
FILE *pid_file;
const char *pidfilename = RUNDIR "/atheme.pid";
#ifdef HAVE_GETRLIMIT
struct rlimit rlim;
#endif
curr_uplink = NULL;
mowgli_init();
/* Prepare gettext */
#ifdef ENABLE_NLS
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE_NAME, LOCALEDIR);
textdomain(PACKAGE_NAME);
#endif
/* change to our local directory */
if (chdir(PREFIX) < 0)
{
perror(PREFIX);
return 20;
}
#ifdef HAVE_GETRLIMIT
/* it appears certian systems *ahem*linux*ahem*
* don't dump cores by default, so we do this here.
*/
if (!getrlimit(RLIMIT_CORE, &rlim))
{
rlim.rlim_cur = rlim.rlim_max;
setrlimit(RLIMIT_CORE, &rlim);
}
#endif
/* do command-line options */
while ((r = getopt(argc, argv, "c:dhrl:np:v")) != -1)
{
switch (r)
{
case 'c':
config_file = sstrdup(optarg);
have_conf = true;
break;
case 'd':
log_force = true;
break;
case 'h':
print_help();
exit(EXIT_SUCCESS);
break;
case 'r':
readonly = true;
break;
case 'l':
log_path = sstrdup(optarg);
have_log = true;
break;
case 'n':
runflags |= RF_LIVE;
break;
case 'p':
pidfilename = optarg;
break;
case 'v':
print_version();
exit(EXIT_SUCCESS);
break;
default:
printf("usage: atheme [-dhnvr] [-c conf] [-l logfile] [-p pidfile]\n");
exit(EXIT_SUCCESS);
break;
}
}
if (!have_conf)
config_file = sstrdup(SYSCONFDIR "/atheme.conf");
if (!have_log)
log_path = sstrdup(LOGDIR "/atheme.log");
cold_start = true;
runflags |= RF_STARTING;
me.kline_id = 0;
me.start = time(NULL);
CURRTIME = me.start;
srand(arc4random());
me.execname = argv[0];
/* set signal handlers */
init_signal_handlers();
/* initialize strshare */
strshare_init();
/* open log */
log_open();
mowgli_log_set_cb(process_mowgli_log);
slog(LG_INFO, "%s is starting up...", PACKAGE_STRING);
/* check for pid file */
if ((pid_file = fopen(pidfilename, "r")))
{
if (fgets(buf, 32, pid_file))
{
pid = atoi(buf);
if (!kill(pid, 0))
{
fprintf(stderr, "atheme: daemon is already running\n");
exit(EXIT_FAILURE);
}
}
fclose(pid_file);
}
#if HAVE_UMASK
/* file creation mask */
umask(077);
#endif
event_init();
hooks_init();
init_netio();
init_socket_queues();
db_init();
translation_init();
#ifdef ENABLE_NLS
language_init();
#endif
init_nodes();
init_confprocess();
init_newconf();
servtree_init();
modules_init();
pcommand_init();
conf_init();
if (!conf_parse(config_file))
{
slog(LG_ERROR, "Error loading config file %s, aborting",
config_file);
exit(EXIT_FAILURE);
}
if (config_options.languagefile)
{
slog(LG_DEBUG, "Using language: %s", config_options.languagefile);
if (!conf_parse(config_options.languagefile))
slog(LG_INFO, "Error loading language file %s, continuing",
config_options.languagefile);
}
authcookie_init();
common_ctcp_init();
if (!backend_loaded && authservice_loaded)
{
slog(LG_ERROR, "atheme: no backend modules loaded, see your configuration file.");
exit(EXIT_FAILURE);
}
/* we've done the critical startup steps now */
cold_start = false;
/* load our db */
if (db_load)
db_load();
else if (backend_loaded)
{
slog(LG_ERROR, "atheme: backend module does not provide db_load()!");
exit(EXIT_FAILURE);
}
db_check();
#ifdef HAVE_FORK
/* fork into the background */
if (!(runflags & RF_LIVE))
{
close(0);
if (open("/dev/null", O_RDWR) != 0)
{
slog(LG_ERROR, "unable to open /dev/null??");
exit(EXIT_FAILURE);
}
if ((i = fork()) < 0)
{
slog(LG_ERROR, "can't fork into the background");
exit(EXIT_FAILURE);
}
/* parent */
else if (i != 0)
{
slog(LG_INFO, "pid %d", i);
slog(LG_INFO, "running in background mode from %s", PREFIX);
exit(EXIT_SUCCESS);
}
/* parent is gone, just us now */
if (setsid() < 0)
{
slog(LG_ERROR, "unable to create new session: %s", strerror(errno));
exit(EXIT_FAILURE);
}
dup2(0, 1);
dup2(0, 2);
}
else
{
slog(LG_INFO, "pid %d", getpid());
slog(LG_INFO, "running in foreground mode from %s", PREFIX);
}
#else
slog(LG_INFO, "running in foreground mode from %s", PREFIX);
#endif
#ifdef HAVE_GETPID
/* write pid */
if ((pid_file = fopen(pidfilename, "w")))
{
fprintf(pid_file, "%d\n", getpid());
fclose(pid_file);
}
else
{
fprintf(stderr, "atheme: unable to write pid file\n");
exit(EXIT_FAILURE);
}
#endif
/* no longer starting */
runflags &= ~RF_STARTING;
/* we probably have a few open already... */
me.maxfd = 3;
/* DB commit interval is configurable */
if (db_save && !readonly)
event_add("db_save", db_save, NULL, config_options.commit_interval);
/* check expires every hour */
event_add("expire_check", expire_check, NULL, 3600);
/* check k/x/q line expires every minute */
event_add("kline_expire", kline_expire, NULL, 60);
event_add("xline_expire", xline_expire, NULL, 60);
event_add("qline_expire", qline_expire, NULL, 60);
/* check authcookie expires every ten minutes */
event_add("authcookie_expire", authcookie_expire, NULL, 600);
/* reseed rng a little every five minutes */
event_add("rng_reseed", rng_reseed, NULL, 293);
me.connected = false;
uplink_connect();
/* main loop */
io_loop();
/* we're shutting down */
hook_call_shutdown();
if (db_save && !readonly)
db_save(NULL);
remove(pidfilename);
errno = 0;
if (curr_uplink != NULL && curr_uplink->conn != NULL)
sendq_flush(curr_uplink->conn);
connection_close_all();
me.connected = false;
/* should we restart? */
if (runflags & RF_RESTART)
{
slog(LG_INFO, "main(): restarting");
#ifdef HAVE_EXECVE
execv(BINDIR "/atheme-services", argv);
#endif
}
slog(LG_INFO, "main(): shutting down");
log_shutdown();
return 0;
}
int main(int argc, char** argv) {
(void) argc;
(void) argv;
int ret;
// Create a variable with our program directory
#ifndef PROG_ROOT
char *prog_dir = xmalloc(sizeof(getenv("HOME")) + sizeof(PROG_DIR) + 2);
prog_dir[0] = '\0';
prog_dir = strcat(prog_dir, getenv("HOME"));
#else
char *prog_dir = xmalloc(sizeof(PROG_ROOT) + sizeof(PROG_DIR) + 2);
prog_dir[0] = '\0';
prog_dir = strcat(prog_dir, PROG_ROOT);
#endif
prog_dir = strcat(prog_dir, "/");
prog_dir = strcat(prog_dir, PROG_DIR);
// Check program directory and other things. For now only
// the program directory.
check_config(prog_dir);
ret = chdir(prog_dir);
if(ret) {
fprintf(stderr, "Error changing dir to %s: %m\n", prog_dir);
exit(1);
}
// Initiate our DB code.
db_init(DB);
// Check if database is OK and possibly upgrade it.
db_check();
// vbox is the main vertical container.
GtkWidget *vbox;
// hbox is the main horizontal container.
GtkWidget *hbox;
// Elements for our menu
GtkWidget *menubar;
GtkWidget *filemenu;
GtkWidget *file;
GtkWidget *mopt_quit;
GtkWidget *mopt_add_feed;
// Button stuff
GtkWidget *playbtn;
GtkWidget *listbtn;
GtkWidget *btnbox;
// Podcast list
GtkWidget *casts;
GtkAccelGroup *accel;
//GtkWidget *feeds_treeview;
gtk_init(&argc, &argv);
// Create main window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// Set options to our main window
gtk_window_set_title(GTK_WINDOW(window), "Podfetcher");
gtk_window_set_default_size(GTK_WINDOW(window), 530, 500);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon(GTK_WINDOW(window),
create_pixbuf("/usr/share/icons/gnome/16x16/apps"
"/multimedia-volume-control.png"));
//Quit GTK on destroy event
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
vbox = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
/*
* Create menu
*/
menubar = gtk_menu_bar_new();
filemenu = gtk_menu_new();
file = gtk_menu_item_new_with_label("File");
mopt_add_feed = gtk_menu_item_new_with_label("Add feed");
mopt_quit = gtk_menu_item_new_with_label("Quit");
accel = gtk_accel_group_new();
// Add the ctrl-q accelerator to the quit button.
gtk_window_add_accel_group(GTK_WINDOW(window), accel);
gtk_widget_add_accelerator(mopt_quit, "activate", accel,
GDK_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), mopt_add_feed);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), mopt_quit);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/*
* Create buttons for updating etc.
*/
btnbox = gtk_hbutton_box_new();
playbtn = gtk_button_new_with_label("Play");
listbtn = gtk_button_new_with_label("Update Feeds");
casts = gtk_tree_view_new();
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(casts), TRUE);
//gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(casts), TRUE);
setup_feeds_tree_view(casts);
gtk_container_add(GTK_CONTAINER(btnbox), playbtn);
gtk_container_add(GTK_CONTAINER(btnbox), listbtn);
gtk_button_box_set_layout(GTK_BUTTON_BOX(btnbox),GTK_BUTTONBOX_START);
gtk_box_pack_start(GTK_BOX(hbox), btnbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), casts, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(playbtn), "clicked",
G_CALLBACK(play_clicked), NULL);
/*
g_signal_connect(G_OBJECT(listbtn), "clicked",
G_CALLBACK(list_clicked), (gpointer) casts);
*/
g_signal_connect(G_OBJECT(mopt_quit), "activate",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(mopt_add_feed), "activate",
G_CALLBACK(add_feed), NULL);
run_thread(populate_casts, casts);
gtk_widget_show_all(window);
gtk_main();
free(prog_dir);
return EXIT_SUCCESS;
}
/* connect to the database */
int db_connect()
{
int c;
char* f;
char* xdh;
char* fl;
error_msg = NULL;
f = getenv("HOME");
xdh = getenv("XDG_DATA_HOME");
/* use XDG data directory for storing the database */
if (!xdh || !xdh[0]) {
if (asprintf(&fl,"%s/.local/share/nodau",f) < 0)
return 1;
} else {
if (asprintf(&fl,"%s/nodau",xdh) < 0)
return 1;
}
dir_create(fl);
if (asprintf(&xdh,"%s/nodau.db",fl) < 0)
return 1;
free(fl);
fl = xdh;
/* connect */
c = sqlite3_open_v2(fl, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
free(fl);
/* check for an error */
if (c)
return 1;
c = db_check();
/* check for an error */
if (c)
return 1;
/* import from old database file */
if (!config_read("import_old_db","false")) {
sqlite3 *odb;
int i;
sql_result *res = db_result_alloc();
if (asprintf(&fl,"%s/.nodau",f) < 0)
return 1;
i = sqlite3_open_v2(fl, &odb, SQLITE_OPEN_READWRITE, NULL);
if (!i) {
sqlite3_get_table(odb, "SELECT * FROM nodau", &res->data, &res->num_rows, &res->num_cols, &error_msg);
if (!error_msg) {
if (res->num_rows) {
puts("Importing from old database\n");
for (i=0; i<res->num_rows; i++) {
db_insert(res->data[OCOLUMN(i,COL_NAME)],res->data[OCOLUMN(i,COL_TEXT)]);
}
}
db_result_free(res);
}
}
config_write("import_old_db","false");
free(fl);
}
/* check the table exists and return */
return c;
}
