/**
* Switch to another output plugin.
* @param output output pointer
* @param new_plugin the new #xmms_plugin_t to use as output.
* @returns TRUE on success and FALSE on failure
*/
gboolean
xmms_output_plugin_switch (xmms_output_t *output, xmms_output_plugin_t *new_plugin)
{
xmms_output_plugin_t *old_plugin;
gboolean ret;
g_return_val_if_fail (output, FALSE);
g_return_val_if_fail (new_plugin, FALSE);
xmms_output_stop (output, NULL);
g_mutex_lock (output->status_mutex);
old_plugin = output->plugin;
ret = set_plugin (output, new_plugin);
/* if the switch succeeded, release the reference to the old plugin
* now.
* if we couldn't switch to the new plugin, but we had a working
* plugin before, switch back to the old plugin.
*/
if (ret) {
xmms_object_unref (old_plugin);
} else if (old_plugin) {
XMMS_DBG ("cannot switch plugin, going back to old one");
set_plugin (output, old_plugin);
}
g_mutex_unlock (output->status_mutex);
return ret;
}
void View::do_load(InputArchive& stream, const WritableLock& lock)
{
lock.check_write(get_local_mutex());
std::string plugin_name;
stream >> plugin_name;
set_plugin(plugin_name, lock);
unsigned int i;
double d;
ExtraNodeAction a;
bool b;
stream >> i; set_update_interval(i, lock);
stream >> a; set_extra_node_action(a, lock);
stream >> d; set_default_intrapid_pdistance(d, lock);
stream >> d; set_default_interpid_pdistance(d, lock);
stream >> d; set_default_interdomain_pdistance(d, lock);
stream >> d; set_default_pidlink_pdistance(d, lock);
stream >> b; set_interdomain_includes_intradomain(b, lock);
stream >> i; set_pid_ttl(i, lock);
stream >> i; set_pdistance_ttl(i, lock);
changed(lock);
}
static void fileext_cb(GtkWidget *combo, gpointer data)
{
fileext = gtk_combo_box_get_active(GTK_COMBO_BOX(fileext_combo));
set_plugin();
if (plugin->init)
plugin->init(&file_write_output);
gtk_widget_set_sensitive(plugin_button, plugin->configure != NULL);
}
/**
* Allocate a new #xmms_output_t
*/
xmms_output_t *
xmms_output_new (xmms_output_plugin_t *plugin, xmms_playlist_t *playlist, xmms_medialib_t *medialib)
{
xmms_output_t *output;
xmms_config_property_t *prop;
gint size;
g_return_val_if_fail (playlist, NULL);
XMMS_DBG ("Trying to open output");
output = xmms_object_new (xmms_output_t, xmms_output_destroy);
xmms_object_ref (playlist);
output->playlist = playlist;
xmms_object_ref (medialib);
output->medialib = medialib;
g_mutex_init (&output->status_mutex);
g_mutex_init (&output->playtime_mutex);
prop = xmms_config_property_register ("output.buffersize", "32768", NULL, NULL);
size = xmms_config_property_get_int (prop);
XMMS_DBG ("Using buffersize %d", size);
g_mutex_init (&output->filler_mutex);
output->filler_state = FILLER_STOP;
g_cond_init (&output->filler_state_cond);
output->filler_buffer = xmms_ringbuf_new (size);
output->filler_thread = g_thread_new ("x2 out filler", xmms_output_filler, output);
xmms_config_property_register ("output.flush_on_pause", "1", NULL, NULL);
xmms_playback_register_ipc_commands (XMMS_OBJECT (output));
output->status = XMMS_PLAYBACK_STATUS_STOP;
if (plugin) {
if (!set_plugin (output, plugin)) {
xmms_log_error ("Could not initialize output plugin");
}
} else {
xmms_log_error ("initalized output without a plugin, please fix!");
}
return output;
}
static void change_button_clicked(GtkWidget *widget, gpointer data)
{
int idx = gtk_combo_box_get_active(GTK_COMBO_BOX(file_list));
char *file = gtk_combo_box_get_active_text(GTK_COMBO_BOX(file_list));
if (idx == 0 || ! file) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_sound_button), FALSE);
} else {
if (set_plugin(file)) {
g_cfg->last_sound_file = file;
last_idx = idx;
gtk_label_set_text(GTK_LABEL(cur_file_label), file);
} else {
gtk_combo_box_set_active(GTK_COMBO_BOX(file_list), last_idx);
warn_dialog("Set sound config file failed: please check the file");
}
}
gtk_widget_set_sensitive(change_button, FALSE);
}
static gboolean file_init (void)
{
aud_config_set_defaults ("filewriter", filewriter_defaults);
fileext = aud_get_int ("filewriter", "fileext");
filenamefromtags = aud_get_bool ("filewriter", "filenamefromtags");
file_path = aud_get_string ("filewriter", "file_path");
prependnumber = aud_get_bool ("filewriter", "prependnumber");
save_original = aud_get_bool ("filewriter", "save_original");
use_suffix = aud_get_bool ("filewriter", "use_suffix");
if (! file_path[0])
{
g_return_val_if_fail (getenv ("HOME") != NULL, FALSE);
file_path = g_filename_to_uri (getenv ("HOME"), NULL, NULL);
g_return_val_if_fail (file_path != NULL, FALSE);
}
set_plugin();
if (plugin->init)
plugin->init(&file_write_output);
return TRUE;
}
/**
* Allocate a new #xmms_output_t
*/
xmms_output_t *
xmms_output_new (xmms_output_plugin_t *plugin, xmms_playlist_t *playlist)
{
xmms_output_t *output;
xmms_config_property_t *prop;
gint size;
g_return_val_if_fail (playlist, NULL);
XMMS_DBG ("Trying to open output");
output = xmms_object_new (xmms_output_t, xmms_output_destroy);
output->playlist = playlist;
output->status_mutex = g_mutex_new ();
output->playtime_mutex = g_mutex_new ();
prop = xmms_config_property_register ("output.buffersize", "32768", NULL, NULL);
size = xmms_config_property_get_int (prop);
XMMS_DBG ("Using buffersize %d", size);
output->filler_mutex = g_mutex_new ();
output->filler_state = FILLER_STOP;
output->filler_state_cond = g_cond_new ();
output->filler_buffer = xmms_ringbuf_new (size);
output->filler_thread = g_thread_create (xmms_output_filler, output, TRUE, NULL);
xmms_config_property_register ("output.flush_on_pause", "1", NULL, NULL);
xmms_ipc_object_register (XMMS_IPC_OBJECT_OUTPUT, XMMS_OBJECT (output));
/* Broadcasts are always transmitted to the client if he
* listens to them. */
xmms_ipc_broadcast_register (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_OUTPUT_VOLUME_CHANGED);
xmms_ipc_broadcast_register (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_PLAYBACK_STATUS);
xmms_ipc_broadcast_register (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_OUTPUT_CURRENTID);
/* Signals are only emitted if the client has a pending question to it
* after the client recivies a signal, he must ask for it again */
xmms_ipc_signal_register (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_OUTPUT_PLAYTIME);
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_START,
XMMS_CMD_FUNC (start));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_STOP,
XMMS_CMD_FUNC (stop));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_PAUSE,
XMMS_CMD_FUNC (pause));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_DECODER_KILL,
XMMS_CMD_FUNC (xform_kill));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_CPLAYTIME,
XMMS_CMD_FUNC (playtime));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_SEEKMS,
XMMS_CMD_FUNC (seekms));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_SEEKMS_REL,
XMMS_CMD_FUNC (seekms_rel));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_SEEKSAMPLES,
XMMS_CMD_FUNC (seeksamples));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_SEEKSAMPLES_REL,
XMMS_CMD_FUNC (seeksamples_rel));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_OUTPUT_STATUS,
XMMS_CMD_FUNC (output_status));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_CURRENTID,
XMMS_CMD_FUNC (currentid));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_VOLUME_SET,
XMMS_CMD_FUNC (volume_set));
xmms_object_cmd_add (XMMS_OBJECT (output),
XMMS_IPC_CMD_VOLUME_GET,
XMMS_CMD_FUNC (volume_get));
output->status = XMMS_PLAYBACK_STATUS_STOP;
if (plugin) {
if (!set_plugin (output, plugin)) {
xmms_log_error ("Could not initialize output plugin");
}
} else {
xmms_log_error ("initalized output without a plugin, please fix!");
}
return output;
}
void parse_options(int argc, char **argv)
{
int c;
static struct option long_options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'v' },
{ "iface", required_argument, NULL, 'i' },
{ "lifaces", no_argument, NULL, 'I' },
{ "netmask", required_argument, NULL, 'n' },
{ "address", required_argument, NULL, 'A' },
{ "write", required_argument, NULL, 'w' },
{ "read", required_argument, NULL, 'r' },
{ "pcapfilter", required_argument, NULL, 'f' },
{ "reversed", no_argument, NULL, 'R' },
{ "proto", required_argument, NULL, 't' },
{ "plugin", required_argument, NULL, 'P' },
{ "filter", required_argument, NULL, 'F' },
#ifdef HAVE_EC_LUA
{ "lua-script", required_argument, NULL, 0 },
{ "lua-args", required_argument, NULL, 0 },
#endif
{ "superquiet", no_argument, NULL, 'Q' },
{ "quiet", no_argument, NULL, 'q' },
{ "script", required_argument, NULL, 's' },
{ "silent", no_argument, NULL, 'z' },
#ifdef WITH_IPV6
{ "ip6scan", no_argument, NULL, '6' },
#endif
{ "unoffensive", no_argument, NULL, 'u' },
{ "nosslmitm", no_argument, NULL, 'S' },
{ "load-hosts", required_argument, NULL, 'j' },
{ "save-hosts", required_argument, NULL, 'k' },
{ "wifi-key", required_argument, NULL, 'W' },
{ "config", required_argument, NULL, 'a' },
{ "dns", no_argument, NULL, 'd' },
{ "regex", required_argument, NULL, 'e' },
{ "visual", required_argument, NULL, 'V' },
{ "ext-headers", no_argument, NULL, 'E' },
{ "log", required_argument, NULL, 'L' },
{ "log-info", required_argument, NULL, 'l' },
{ "log-msg", required_argument, NULL, 'm' },
{ "compress", no_argument, NULL, 'c' },
{ "text", no_argument, NULL, 'T' },
{ "curses", no_argument, NULL, 'C' },
{ "daemon", no_argument, NULL, 'D' },
{ "gtk", no_argument, NULL, 'G' },
{ "mitm", required_argument, NULL, 'M' },
{ "only-mitm", no_argument, NULL, 'o' },
{ "bridge", required_argument, NULL, 'B' },
{ "broadcast", required_argument, NULL, 'b' },
{ "promisc", no_argument, NULL, 'p' },
{ "gateway", required_argument, NULL, 'Y' },
{ "certificate", required_argument, NULL, 0 },
{ "private-key", required_argument, NULL, 0 },
{ 0 , 0 , 0 , 0}
};
for (c = 0; c < argc; c++)
DEBUG_MSG("parse_options -- [%d] [%s]", c, argv[c]);
/* OPTIONS INITIALIZATION */
GBL_PCAP->promisc = 1;
GBL_FORMAT = &ascii_format;
GBL_OPTIONS->ssl_mitm = 1;
GBL_OPTIONS->broadcast = 0;
GBL_OPTIONS->ssl_cert = NULL;
GBL_OPTIONS->ssl_pkey = NULL;
/* OPTIONS INITIALIZED */
optind = 0;
int option_index = 0;
while ((c = getopt_long (argc, argv, "A:a:bB:CchDdEe:F:f:GhIi:j:k:L:l:M:m:n:oP:pQqiRr:s:STt:uV:vW:w:Y:z6", long_options, &option_index)) != EOF) {
/* used for parsing arguments */
char *opt_end = optarg;
while (opt_end && *opt_end) opt_end++;
/* enable a loaded filter script? */
switch (c) {
case 'M':
set_mitm(optarg);
break;
case 'o':
set_onlymitm();
//select_text_interface();
break;
case 'b':
set_broadcast();
break;
case 'B':
set_iface_bridge(optarg);
break;
case 'p':
set_promisc();
break;
#ifndef JUST_LIBRARY
case 'T':
select_text_interface();
break;
case 'C':
select_curses_interface();
break;
case 'G':
select_gtk_interface();
break;
case 'D':
select_daemon_interface();
break;
#endif
case 'R':
set_reversed();
break;
case 't':
set_proto(optarg);
break;
case 'P':
set_plugin(optarg);
break;
case 'i':
set_iface(optarg);
break;
case 'I':
/* this option is only useful in the text interface */
set_lifaces();
break;
case 'Y':
set_secondary(optarg);
break;
case 'n':
set_netmask(optarg);
break;
case 'A':
set_address(optarg);
break;
case 'r':
set_read_pcap(optarg);
break;
case 'w':
set_write_pcap(optarg);
break;
case 'f':
set_pcap_filter(optarg);
break;
case 'F':
load_filter(opt_end, optarg);
break;
case 'L':
set_loglevel_packet(optarg);
case 'l':
set_loglevel_info(optarg);
break;
case 'm':
set_loglevel_true(optarg);
break;
case 'c':
set_compress();
break;
case 'e':
opt_set_regex(optarg);
break;
case 'Q':
set_superquiet();
/* no break, quiet must be enabled */
case 'q':
set_quiet();
break;
case 's':
set_script(optarg);
break;
case 'z':
set_silent();
break;
#ifdef WITH_IPV6
case '6':
set_ip6scan();
break;
#endif
case 'u':
set_unoffensive();
break;
case 'S':
disable_sslmitm();
break;
case 'd':
set_resolve();
break;
case 'j':
load_hosts(optarg);
break;
case 'k':
save_hosts(optarg);
break;
case 'V':
opt_set_format(optarg);
break;
case 'E':
set_ext_headers();
break;
case 'W':
set_wifi_key(optarg);
break;
case 'a':
set_conf_file(optarg);
break;
case 'h':
ec_usage();
break;
case 'v':
printf("%s %s\n", GBL_PROGRAM, GBL_VERSION);
clean_exit(0);
break;
/* Certificate and private key options */
case 0:
if (!strcmp(long_options[option_index].name, "certificate")) {
GBL_OPTIONS->ssl_cert = strdup(optarg);
} else if (!strcmp(long_options[option_index].name, "private-key")) {
GBL_OPTIONS->ssl_pkey = strdup(optarg);
#ifdef HAVE_EC_LUA
} else if (!strcmp(long_options[option_index].name,"lua-args")) {
ec_lua_cli_add_args(strdup(optarg));
}
else if (!strcmp(long_options[option_index].name,"lua-script")) {
ec_lua_cli_add_script(strdup(optarg));
break;
#endif
} else {
fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM);
clean_exit(-1);
}
break;
case ':': // missing parameter
fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM);
clean_exit(-1);
break;
case '?': // unknown option
fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM);
clean_exit(-1);
break;
}
}
DEBUG_MSG("parse_options: options parsed");
/* TARGET1 and TARGET2 parsing */
if (argv[optind]) {
GBL_OPTIONS->target1 = strdup(argv[optind]);
DEBUG_MSG("TARGET1: %s", GBL_OPTIONS->target1);
if (argv[optind+1]) {
GBL_OPTIONS->target2 = strdup(argv[optind+1]);
DEBUG_MSG("TARGET2: %s", GBL_OPTIONS->target2);
}
}
/* create the list form the TARGET format (MAC/IPrange/PORTrange) */
compile_display_filter();
DEBUG_MSG("parse_options: targets parsed");
/* check for other options */
if (GBL_SNIFF->start == NULL)
set_unified_sniff();
if (GBL_OPTIONS->read && GBL_PCAP->filter)
FATAL_ERROR("Cannot read from file and set a filter on interface");
if (GBL_OPTIONS->read && GBL_SNIFF->type != SM_UNIFIED )
FATAL_ERROR("You can read from a file ONLY in unified sniffing mode !");
if (GBL_OPTIONS->mitm && GBL_SNIFF->type != SM_UNIFIED )
FATAL_ERROR("You can't do mitm attacks in bridged sniffing mode !");
if (GBL_SNIFF->type == SM_BRIDGED && GBL_PCAP->promisc == 0)
FATAL_ERROR("During bridged sniffing the iface must be in promisc mode !");
if (GBL_OPTIONS->quiet && GBL_UI->type != UI_TEXT)
FATAL_ERROR("The quiet option is useful only with text only UI");
if (GBL_OPTIONS->load_hosts && GBL_OPTIONS->save_hosts)
FATAL_ERROR("Cannot load and save at the same time the hosts list...");
if (GBL_OPTIONS->unoffensive && GBL_OPTIONS->mitm)
FATAL_ERROR("Cannot use mitm attacks in unoffensive mode");
if (GBL_OPTIONS->read && GBL_OPTIONS->mitm)
FATAL_ERROR("Cannot use mitm attacks while reading from file");
#ifndef JUST_LIBRARY
if (GBL_UI->init == NULL)
FATAL_ERROR("Please select an User Interface");
#endif
/* force text interface for only mitm attack */
/* Do not select text interface for only MiTM mode
if (GBL_OPTIONS->only_mitm) {
if (GBL_OPTIONS->mitm)
select_text_interface();
else
FATAL_ERROR("Only mitm requires at least one mitm method");
} */
DEBUG_MSG("parse_options: options combination looks good");
return;
}
static void load_settings(struct trace_capture *cap, gchar *filename)
{
struct shark_info *info = cap->info;
struct tracecmd_xml_system_node *syschild;
struct tracecmd_xml_handle *handle;
struct tracecmd_xml_system *system;
const char *plugin;
const char *name;
handle = tracecmd_xml_open(filename);
if (!handle) {
warning("Could not open %s", filename);
return;
}
system = tracecmd_xml_find_system(handle, "CaptureSettings");
if (!system)
goto out;
syschild = tracecmd_xml_system_node(system);
if (!syschild)
goto out_free_sys;
g_free(info->cap_plugin);
info->cap_plugin = NULL;
do {
name = tracecmd_xml_node_type(syschild);
if (strcmp(name, "Events") == 0) {
load_cap_events(cap, handle, syschild);
trace_update_event_view(cap->event_view,
cap->pevent,
NULL,
info->cap_all_events,
info->cap_systems,
info->cap_events);
}
else if (strcmp(name, "Plugin") == 0) {
plugin = tracecmd_xml_node_value(handle, syschild);
info->cap_plugin = g_strdup(plugin);
} else if (strcmp(name, "Command") == 0) {
name = tracecmd_xml_node_value(handle, syschild);
gtk_entry_set_text(GTK_ENTRY(cap->command_entry), name);
} else if (strcmp(name, "File") == 0) {
name = tracecmd_xml_node_value(handle, syschild);
gtk_entry_set_text(GTK_ENTRY(cap->file_entry), name);
}
syschild = tracecmd_xml_node_next(syschild);
} while (syschild);
set_plugin(cap);
out_free_sys:
tracecmd_xml_free_system(system);
out:
tracecmd_xml_close(handle);
}
/*
* Trace Capture Dialog Window
*
* +--------------------------------------------------------------------+
* | Dialog Window |
* | +-------------------------------+-------------------------------+ |
* | | Paned Window | +---------------------------+ | |
* | | +---------------------------+ | | Scroll window | | |
* | | | Hbox | | | +-----------------------+ | | |
* | | | Label Plugin Combo | | | | Event Tree | | | |
* | | +---------------------------+ | | | | | | |
* | | | | | | | | |
* | | | | +-----------------------+ | | |
* | | | +---------------------------+ | |
* | +-------------------------------+-------------------------------+ |
* +--------------------------------------------------------------------+
*/
static void tracing_dialog(struct shark_info *info, const char *tracing)
{
struct pevent *pevent;
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *combo;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *scrollwin;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *event_tree;
GtkWidget *viewport;
GtkWidget *textview;
GtkWidget *hbox;
GtkTextBuffer *buffer;
GtkTextIter start_iter;
GtkTextIter end_iter;
char **plugins;
int nr_plugins;
struct trace_capture cap;
const gchar *file;
const char *command;
const char *val;
GString *str;
gint result;
memset(&cap, 0, sizeof(cap));
cap.info = info;
plugins = tracecmd_local_plugins(tracing);
/* Skip latency plugins */
nr_plugins = trim_plugins(plugins);
if (!nr_plugins && plugins) {
tracecmd_free_list(plugins);
plugins = NULL;
}
/* Send parse warnings to status display */
trace_dialog_register_alt_warning(vpr_stat);
pevent = tracecmd_local_events(tracing);
trace_dialog_register_alt_warning(NULL);
cap.pevent = pevent;
if (!pevent && !nr_plugins) {
warning("No events or plugins found");
return;
}
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog), "Capture");
button = gtk_button_new_with_label("Run");
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button,
GTK_RESPONSE_ACCEPT);
gtk_widget_show(button);
cap.run_button = button;
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE,
GTK_RESPONSE_REJECT);
cap.main_dialog = dialog;
/* --- Top Level Hpaned --- */
table = gtk_table_new(4, 2, FALSE);
/* It is possible that no pevents exist. */
if (pevent) {
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_table_attach(GTK_TABLE(table), scrollwin, 0, 1, 1, 2,
GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
gtk_widget_show(scrollwin);
event_tree = trace_create_event_list_view(pevent, NULL,
cap.info->cap_all_events,
cap.info->cap_systems,
cap.info->cap_events);
gtk_container_add(GTK_CONTAINER(scrollwin), event_tree);
gtk_widget_show(event_tree);
cap.event_view = event_tree;
} else {
/* No events */
label = gtk_label_new("No events enabled on system");
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_EXPAND|GTK_FILL,
0, 10);
gtk_widget_show(label);
cap.event_view = NULL;
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0);
gtk_widget_show(table);
/*------------------ Frame Settings --------------------------- */
frame = gtk_frame_new("Settings");
gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1,
GTK_FILL, 0, 0, 10);
gtk_widget_show(frame);
table2 = gtk_table_new(2, 3, FALSE);
gtk_container_add(GTK_CONTAINER(frame), table2);
gtk_widget_show(table2);
gtk_table_set_col_spacings(GTK_TABLE(table2), 5);
button = gtk_button_new_with_label("Save Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 0, 1, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (save_settings_clicked),
(gpointer)&cap);
button = gtk_button_new_with_label("Import Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 1, 2, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (import_settings_clicked),
(gpointer)&cap);
button = gtk_button_new_with_label("Export Settings");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 0, 1);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (export_settings_clicked),
(gpointer)&cap);
if (cap.info->cap_settings_name)
set_settings(&cap);
label = gtk_label_new("Available Settings: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2);
gtk_widget_show(label);
combo = trace_create_combo_box(NULL, NULL,
create_settings_model, NULL);
gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 1, 2);
cap.settings_combo = combo;
g_signal_connect (combo, "changed",
G_CALLBACK (settings_changed),
(gpointer)&cap);
/*------------------ Frame Settings --------------------------- */
frame = gtk_frame_new("Execute");
gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 3, 4,
GTK_FILL, 0, 0, 10);
gtk_widget_show(frame);
table2 = gtk_table_new(3, 3, FALSE);
gtk_container_add(GTK_CONTAINER(frame), table2);
gtk_widget_show(table2);
label = gtk_label_new("Plugin: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 0, 1);
gtk_widget_show(label);
combo = trace_create_combo_box(NULL, NULL, create_plugin_combo_model, plugins);
cap.plugin_combo = combo;
gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 0, 1);
if (cap.info->cap_plugin)
set_plugin(&cap);
label = gtk_label_new("Command:");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 3, 1, 2);
gtk_widget_show(entry);
cap.command_entry = entry;
if (cap.info->cap_command)
gtk_entry_set_text(GTK_ENTRY(entry), cap.info->cap_command);
label = gtk_label_new("Output file: ");
gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 2, 3);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 2, 2, 3);
gtk_widget_show(entry);
if (cap.info->cap_file)
file = cap.info->cap_file;
else
file = default_output_file;
gtk_entry_set_text(GTK_ENTRY(entry), file);
cap.file_entry = entry;
button = gtk_button_new_with_label("Browse");
gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 2, 3);
gtk_widget_show(button);
g_signal_connect (button, "clicked",
G_CALLBACK (file_clicked),
(gpointer)&cap);
/*------------------ Command Output ------------------ */
vbox = gtk_vbox_new(FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 1, 2, 0, 4);
gtk_widget_show(vbox);
gtk_widget_set_size_request(GTK_WIDGET(vbox), 500, 0);
label = gtk_label_new("Output Display:");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
gtk_widget_show(scrollwin);
viewport = gtk_viewport_new(NULL, NULL);
gtk_widget_show(viewport);
gtk_container_add(GTK_CONTAINER(scrollwin), viewport);
textview = gtk_text_view_new();
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_container_add(GTK_CONTAINER(viewport), textview);
gtk_widget_show(textview);
cap.output_text = textview;
cap.output_buffer = buffer;
/* set the buffer from its previous setting */
if (info->cap_buffer_output)
gtk_text_buffer_set_text(buffer, info->cap_buffer_output,
strlen(info->cap_buffer_output));
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
label = gtk_label_new("Max # of characters in output display: ");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
gtk_widget_show(entry);
cap.max_num_entry = entry;
if (!info->cap_max_buf_size)
info->cap_max_buf_size = DEFAULT_MAX_BUF_SIZE;
str = g_string_new("");
g_string_append_printf(str, "%d", info->cap_max_buf_size);
gtk_entry_set_text(GTK_ENTRY(entry), str->str);
g_string_free(str, TRUE);
g_signal_connect (entry, "insert-text",
G_CALLBACK (insert_text),
(gpointer)&cap);
gtk_widget_set_size_request(GTK_WIDGET(dialog),
DIALOG_WIDTH, DIALOG_HEIGHT);
gtk_widget_show(dialog);
cont:
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
execute_button_clicked(&cap);
goto cont;
}
/* Make sure no capture is running */
end_capture(&cap);
/* Get the max buffer size */
val = gtk_entry_get_text(GTK_ENTRY(entry));
info->cap_max_buf_size = atoi(val);
gtk_text_buffer_get_start_iter(cap.output_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cap.output_buffer, &end_iter);
g_free(info->cap_buffer_output);
info->cap_buffer_output = gtk_text_buffer_get_text(cap.output_buffer,
&start_iter,
&end_iter,
FALSE);
/* save the plugin and file to reuse if we come back */
update_plugin(&cap);
free(info->cap_file);
cap.info->cap_file = strdup(gtk_entry_get_text(GTK_ENTRY(cap.file_entry)));
free(info->cap_command);
command = gtk_entry_get_text(GTK_ENTRY(cap.command_entry));
if (command && strlen(command) && !is_just_ws(command))
cap.info->cap_command = strdup(command);
else
cap.info->cap_command = NULL;
update_events(&cap);
gtk_widget_destroy(dialog);
if (pevent)
pevent_free(pevent);
if (plugins)
tracecmd_free_list(plugins);
}
