int bano_open(bano_base_t* base, const bano_base_info_t* info)
{
base->flags = info->flags;
#ifdef BANO_CONFIG_HTTPD
base->is_httpd = 0;
#endif /* BANO_CONFIG_HTTPD */
#ifdef BANO_CONFIG_CAM
base->is_cam = 0;
#endif /* BANO_CONFIG_CAM */
#ifdef BANO_CONFIG_SMS
base->is_sms = 0;
#endif /* BANO_CONFIG_SMS */
bano_list_init(&base->nodes);
bano_list_init(&base->sockets);
bano_timer_init(&base->timers);
bano_dict_init(&base->nodls, sizeof(bano_nodl_t));
bano_cipher_init(&base->cipher, &bano_cipher_info_none);
if (info->flags & BANO_BASE_FLAG_ADDR) base->addr = info->addr;
else base->addr = BANO_DEFAULT_BASE_ADDR;
if (info->flags & BANO_BASE_FLAG_CONF)
{
if (apply_conf(base, info->conf_path))
{
BANO_PERROR();
goto on_error_0;
}
}
return 0;
on_error_0:
#ifdef BANO_CONFIG_HTTPD
if (base->is_httpd) bano_httpd_fini(&base->httpd);
#endif /* BANO_CONFIG_HTTPD */
#ifdef BANO_CONFIG_CAM
if (base->is_cam) bano_cam_close(&base->cam);
#endif /* BANO_CONFIG_CAM */
#ifdef BANO_CONFIG_SMS
if (base->is_sms) bano_sms_close(&base->sms);
#endif /* BANO_CONFIG_SMS */
bano_dict_fini(&base->nodls, NULL, NULL);
bano_timer_fini(&base->timers);
bano_list_fini(&base->nodes, free_node_item, NULL);
bano_list_fini(&base->sockets, free_socket_item, base);
return -1;
}
static int signal_pipe_dispatch(void) {
int sig, err;
s_log(LOG_DEBUG, "Dispatching signals from the signal pipe");
while(readsocket(signal_pipe[0], (char *)&sig, sizeof sig)==sizeof sig) {
switch(sig) {
#ifndef USE_WIN32
case SIGCHLD:
s_log(LOG_DEBUG, "Processing SIGCHLD");
#ifdef USE_FORK
client_status(); /* report status of client process */
#else /* USE_UCONTEXT || USE_PTHREAD */
child_status(); /* report status of libwrap or 'exec' process */
#endif /* defined USE_FORK */
break;
#endif /* !defind USE_WIN32 */
case SIGNAL_RELOAD_CONFIG:
s_log(LOG_DEBUG, "Processing SIGNAL_RELOAD_CONFIG");
err=parse_conf(NULL, CONF_RELOAD);
if(err) {
s_log(LOG_ERR, "Failed to reload the configuration file");
} else {
unbind_ports();
log_close();
apply_conf();
log_open();
if(bind_ports()) {
/* FIXME: handle the error */
}
}
break;
case SIGNAL_REOPEN_LOG:
s_log(LOG_DEBUG, "Processing SIGNAL_REOPEN_LOG");
log_close();
log_open();
s_log(LOG_NOTICE, "Log file reopened");
break;
case SIGNAL_TERMINATE:
s_log(LOG_DEBUG, "Processing SIGNAL_TERMINATE");
s_log(LOG_NOTICE, "Terminated");
return 2;
default:
s_log(LOG_ERR, "Received signal %d; terminating", sig);
return 1;
}
}
s_log(LOG_DEBUG, "Signal pipe is empty");
return 0;
}
int
gtkui_run_dialog (GtkWidget *parentwin, ddb_dialog_t *conf, uint32_t buttons, int (*callback)(int button, void *ctx), void *ctx) {
if (!parentwin) {
parentwin = mainwin;
}
// create window
char title[200];
snprintf (title, sizeof (title), _("Configure %s"), conf->title);
GtkWidget *win;
if (!buttons) {
win = gtk_dialog_new_with_buttons (title, GTK_WINDOW (parentwin), GTK_DIALOG_MODAL, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (win), GTK_RESPONSE_OK);
}
else {
win = gtk_dialog_new_with_buttons (title, GTK_WINDOW (parentwin), GTK_DIALOG_MODAL, NULL);
if (buttons & (1<<ddb_button_ok)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_OK, GTK_RESPONSE_OK);
}
if (buttons & (1<<ddb_button_cancel)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
}
if (buttons & (1<<ddb_button_close)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
}
if (buttons & (1<<ddb_button_apply)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_APPLY, GTK_RESPONSE_APPLY);
}
if (buttons & (1<<ddb_button_yes)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_YES, GTK_RESPONSE_YES);
}
if (buttons & (1<<ddb_button_no)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_NO, GTK_RESPONSE_NO);
}
}
gtk_window_set_type_hint (GTK_WINDOW (win), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_container_set_border_width (GTK_CONTAINER(win), 12);
gtk_window_set_title (GTK_WINDOW (win), title);
gtk_window_set_modal (GTK_WINDOW (win), TRUE);
gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parentwin));
GtkWidget *widgets[100] = {NULL};
int pack[100] = {0};
int ncurr = 0;
widgets[ncurr] = gtk_dialog_get_content_area (GTK_DIALOG (win));
gtk_box_set_spacing (GTK_BOX (widgets[ncurr]), 8);
GtkWidget *action_area = gtk_dialog_get_action_area (GTK_DIALOG (win));
gtk_widget_show (action_area);
gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area), GTK_BUTTONBOX_END);
// parse script
char token[MAX_TOKEN];
const char *script = conf->layout;
parser_line = 1;
while (script = gettoken (script, token)) {
if (strcmp (token, "property")) {
fprintf (stderr, "invalid token while loading plugin %s config dialog: %s at line %d\n", conf->title, token, parser_line);
break;
}
char labeltext[MAX_TOKEN];
script = gettoken_warn_eof (script, labeltext);
if (!script) {
break;
}
if (ncurr > 0) {
pack[ncurr]--;
if (pack[ncurr] < 0) {
ncurr--;
}
}
char type[MAX_TOKEN];
script = gettoken_warn_eof (script, type);
if (!script) {
break;
}
if (!strncmp (type, "hbox[", 5) || !strncmp (type, "vbox[", 5)) {
ncurr++;
int n = 0;
if (1 != sscanf (type+4, "[%d]", &n)) {
break;
}
pack[ncurr] = n;
int vert = 0;
int hmg = FALSE;
int fill = FALSE;
int expand = FALSE;
int border = 0;
int spacing = 8;
int height = 100;
char param[MAX_TOKEN];
for (;;) {
script = gettoken_warn_eof (script, param);
if (!script) {
break;
}
if (!strcmp (param, ";")) {
break;
}
else if (!strcmp (param, "hmg")) {
hmg = TRUE;
}
else if (!strcmp (param, "fill")) {
fill = TRUE;
}
else if (!strcmp (param, "expand")) {
expand = TRUE;
}
else if (!strncmp (param, "border=", 7)) {
border = atoi (param+7);
}
else if (!strncmp (param, "spacing=", 8)) {
spacing = atoi (param+8);
}
else if (!strncmp (param, "height=", 7)) {
height = atoi (param+7);
}
}
widgets[ncurr] = vert ? gtk_vbox_new (TRUE, spacing) : gtk_hbox_new (TRUE, spacing);
gtk_widget_set_size_request (widgets[ncurr], -1, height);
gtk_widget_show (widgets[ncurr]);
gtk_box_pack_start (GTK_BOX(widgets[ncurr-1]), widgets[ncurr], fill, expand, border);
continue;
}
int vertical = 0;
char key[MAX_TOKEN];
for (;;) {
script = gettoken_warn_eof (script, key);
if (!script) {
break;
}
if (!strcmp (key, "vert")) {
vertical = 1;
}
else {
break;
}
}
char def[MAX_TOKEN];
script = gettoken_warn_eof (script, def);
if (!script) {
break;
}
// add to dialog
GtkWidget *label = NULL;
GtkWidget *prop = NULL;
GtkWidget *cont = NULL;
char value[1000];
conf->get_param (key, value, sizeof (value), def);
if (!strcmp (type, "entry") || !strcmp (type, "password")) {
label = gtk_label_new (_(labeltext));
gtk_widget_show (label);
prop = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (prop), TRUE);
g_signal_connect (G_OBJECT (prop), "changed", G_CALLBACK (prop_changed), win);
gtk_widget_show (prop);
gtk_entry_set_text (GTK_ENTRY (prop), value);
if (!strcmp (type, "password")) {
gtk_entry_set_visibility (GTK_ENTRY (prop), FALSE);
}
}
else if (!strcmp (type, "checkbox")) {
prop = gtk_check_button_new_with_label (_(labeltext));
g_signal_connect (G_OBJECT (prop), "toggled", G_CALLBACK (prop_changed), win);
gtk_widget_show (prop);
int val = atoi (value);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prop), val);
}
else if (!strcmp (type, "file")) {
label = gtk_label_new (_(labeltext));
gtk_widget_show (label);
if (deadbeef->conf_get_int ("gtkui.pluginconf.use_filechooser_button", 0)) {
prop = gtk_file_chooser_button_new (_(labeltext), GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_show (prop);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (prop), value);
g_signal_connect (G_OBJECT (prop), "file-set", G_CALLBACK (prop_changed), win);
}
else {
cont = gtk_hbox_new (FALSE, 2);
gtk_widget_show (cont);
prop = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (prop), TRUE);
g_signal_connect (G_OBJECT (prop), "changed", G_CALLBACK (prop_changed), win);
gtk_widget_show (prop);
gtk_editable_set_editable (GTK_EDITABLE (prop), FALSE);
gtk_entry_set_text (GTK_ENTRY (prop), value);
gtk_box_pack_start (GTK_BOX (cont), prop, TRUE, TRUE, 0);
GtkWidget *btn = gtk_button_new_with_label ("…");
gtk_widget_show (btn);
gtk_box_pack_start (GTK_BOX (cont), btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (on_prop_browse_file), prop);
}
}
else if (!strncmp (type, "select[", 7)) {
int n;
if (1 != sscanf (type+6, "[%d]", &n)) {
break;
}
label = gtk_label_new (_(labeltext));
gtk_widget_show (label);
prop = gtk_combo_box_text_new ();
gtk_widget_show (prop);
for (int i = 0; i < n; i++) {
char entry[MAX_TOKEN];
script = gettoken_warn_eof (script, entry);
if (!script) {
break;
}
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (prop), entry);
}
if (!script) {
break;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (prop), atoi (value));
g_signal_connect ((gpointer) prop, "changed",
G_CALLBACK (prop_changed),
win);
}
else if (!strncmp (type, "hscale[", 7) || !strncmp (type, "vscale[", 7) || !strncmp (type, "spinbtn[", 8)) {
float min, max, step;
const char *args;
if (type[0] == 's') {
args = type + 7;
}
else {
args = type + 6;
}
if (3 != sscanf (args, "[%f,%f,%f]", &min, &max, &step)) {
break;
}
int invert = 0;
if (min >= max) {
float tmp = min;
min = max;
max = tmp;
invert = 1;
}
if (step <= 0) {
step = 1;
}
if (type[0] == 's') {
prop = gtk_spin_button_new_with_range (min, max, step);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (prop), atof (value));
}
else {
prop = type[0] == 'h' ? gtk_hscale_new_with_range (min, max, step) : gtk_vscale_new_with_range (min, max, step);
if (invert) {
gtk_range_set_inverted (GTK_RANGE (prop), TRUE);
}
gtk_range_set_value (GTK_RANGE (prop), (gdouble)atof (value));
gtk_scale_set_value_pos (GTK_SCALE (prop), GTK_POS_RIGHT);
}
label = gtk_label_new (_(labeltext));
gtk_widget_show (label);
g_signal_connect (G_OBJECT (prop), "value-changed", G_CALLBACK (prop_changed), win);
gtk_widget_show (prop);
}
script = gettoken_warn_eof (script, token);
if (!script) {
break;
}
if (strcmp (token, ";")) {
fprintf (stderr, "expected `;' while loading plugin %s config dialog: %s at line %d\n", conf->title, token, parser_line);
break;
}
if (label && prop) {
GtkWidget *hbox = NULL;
hbox = vertical ? gtk_vbox_new (FALSE, 8) : gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), cont ? cont : prop, TRUE, TRUE, 0);
cont = hbox;
}
else {
cont = prop;
}
if (prop) {
g_object_set_data (G_OBJECT (win), key, prop);
}
if (cont) {
gtk_box_pack_start (GTK_BOX (widgets[ncurr]), cont, FALSE, FALSE, 0);
}
}
int response;
do {
gtk_dialog_set_response_sensitive (GTK_DIALOG (win), GTK_RESPONSE_APPLY, FALSE);
response = gtk_dialog_run (GTK_DIALOG (win));
if (response == GTK_RESPONSE_APPLY || response == GTK_RESPONSE_OK) {
apply_conf (win, conf);
}
if (callback) {
int btn = ddb_button_from_gtk_response (response);
if (!callback (btn, ctx)) {
break;
}
}
} while (response == GTK_RESPONSE_APPLY);
gtk_widget_destroy (win);
int btn = ddb_button_from_gtk_response (response);
return btn;
}
