static void
send_as_image (PidginWindow * win,
PidginConversation * _gtkconv) {
PurplePlugin *plugin = purple_plugins_find_with_id (PLUGIN_ID);
if (PLUGIN (locked))
return; /* Just return, don't fail. */
else {
PidginConversation *gtkconv;
PLUGIN (locked) = TRUE;
PLUGIN (send_as) = SEND_AS_IMAGE;
if (win != NULL)
gtkconv =
PIDGIN_CONVERSATION
(pidgin_conv_window_get_active_conversation (win));
else
gtkconv = _gtkconv;
REMEMBER_ACCOUNT (gtkconv);
PLUGIN (conv_features) = gtkconv->active_conv->features;
freeze_desktop (plugin, FALSE);
}
}
/** Eventually ask for a custom capture name when sending :
- as file
- to a remote FTP server
*/
void
screenshot_maybe_rename (PurplePlugin * plugin, gchar ** basename) {
g_assert (plugin != NULL && plugin->extra != NULL);
if (purple_prefs_get_bool (PREF_ASK_FILENAME) &&
(PLUGIN (send_as) == SEND_AS_FILE
#ifdef ENABLE_UPLOAD
|| PLUGIN (send_as) == SEND_AS_FTP_LINK)
#else
)
#endif
) {
GtkWidget *dlgbox_rename = NULL;
gint result = 0;
dlgbox_rename = capture_rename (plugin, *basename);
result = gtk_dialog_run (GTK_DIALOG (dlgbox_rename));
if (result == GTK_RESPONSE_OK) {
GtkWidget *entry = NULL;
entry = g_object_get_data (G_OBJECT (dlgbox_rename), "entry");
g_free (*basename);
*basename = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
}
gtk_widget_destroy (dlgbox_rename);
}
}
static void
send_as_link (PidginWindow * win,
PidginConversation * _gtkconv) {
PurplePlugin *plugin;
plugin = purple_plugins_find_with_id (PLUGIN_ID);
if (PLUGIN (locked))
return; /* Just return, don't fail. */
else {
PidginConversation *gtkconv;
PLUGIN (locked) = TRUE;
PLUGIN (send_as) = SEND_AS_HTTP_LINK;
if (win != NULL)
gtkconv =
PIDGIN_CONVERSATION
(pidgin_conv_window_get_active_conversation (win));
else
gtkconv = _gtkconv;
if (!strcmp (purple_prefs_get_string (PREF_UPLOAD_TO), HOST_DISABLED)) {
purple_notify_error (plugin, PLUGIN_NAME, PLUGIN_ERROR,
PLUGIN_HOST_DISABLED_ERROR);
plugin_stop (plugin);
return;
}
REMEMBER_ACCOUNT (gtkconv);
PLUGIN (conv_features) = gtkconv->active_conv->features;
freeze_desktop (plugin, FALSE);
}
}
/** Implements the init_input function of the plugin API */
int corsaro_dos_init_input(corsaro_in_t *corsaro)
{
struct corsaro_dos_in_state_t *state;
corsaro_plugin_t *plugin = PLUGIN(corsaro);
assert(plugin != NULL);
if((state = malloc_zero(sizeof(struct corsaro_dos_in_state_t)))
== NULL)
{
corsaro_log_in(__func__, corsaro,
"could not malloc corsaro_dos_state_t");
goto err;
}
corsaro_plugin_register_state(corsaro->plugin_manager, plugin, state);
/* we initially expect an corsaro interval record */
state->expected_type = CORSARO_IN_RECORD_TYPE_IO_INTERVAL_START;
/* don't set the vector_cnt until we actually see a header record */
return 0;
err:
corsaro_dos_close_input(corsaro);
return -1;
}
/** Implements the init_output function of the plugin API */
int corsaro_dos_init_output(corsaro_t *corsaro)
{
struct corsaro_dos_state_t *state;
/* retrieve a pointer to the plugin struct with our name and id */
corsaro_plugin_t *plugin = PLUGIN(corsaro);
assert(plugin != NULL);
/*
* allocate memory for the state structure which will hold a pointer to the
* output file and other statistics
*/
if((state = malloc_zero(sizeof(struct corsaro_dos_state_t))) == NULL)
{
corsaro_log(__func__, corsaro,
"could not malloc corsaro_dos_state_t");
goto err;
}
/*
* register the state structure with the plugin manager
* this associates it with our plugin id so it can be retrieved later
*/
corsaro_plugin_register_state(corsaro->plugin_manager, plugin, state);
/* init the hash table for attack vectors */
state->attack_hash = kh_init(av);
return 0;
err:
corsaro_dos_close_output(corsaro);
return -1;
}
/** Implements the init_output function of the plugin API */
int corsaro_anon_init_output(corsaro_t *corsaro)
{
struct corsaro_anon_state_t *state;
corsaro_plugin_t *plugin = PLUGIN(corsaro);
assert(plugin != NULL);
if((state = malloc_zero(sizeof(struct corsaro_anon_state_t))) == NULL)
{
corsaro_log(__func__, corsaro,
"could not malloc corsaro_anon_state_t");
goto err;
}
corsaro_plugin_register_state(corsaro->plugin_manager, plugin, state);
/* set the defaults */
state->encryption_type = CORSARO_ANON_ENC_CRYPTOPAN;
state->encrypt_source = ANON_SOURCE;
state->encrypt_destination = ANON_DEST;
/* parse the arguments */
if(parse_args(corsaro) != 0)
{
return -1;
}
assert(state->encryption_key != NULL);
corsaro_anon_init(state->encryption_type, state->encryption_key);
return 0;
err:
corsaro_anon_close_output(corsaro);
return -1;
}
/** Parse the arguments given to the plugin */
static int parse_args(bgpcorsaro_t *bgpcorsaro)
{
bgpcorsaro_plugin_t *plugin = PLUGIN(bgpcorsaro);
struct bgpcorsaro_pacifier_state_t *state = STATE(bgpcorsaro);
int opt;
if(plugin->argc <= 0)
{
return 0;
}
/* NB: remember to reset optind to 1 before using getopt! */
optind = 1;
while((opt = getopt(plugin->argc, plugin->argv, ":w:a?")) >= 0)
{
switch(opt)
{
case 'w':
state->wait = atoi(optarg);
break;
case 'a':
state->adaptive = 1;
break;
case '?':
case ':':
default:
usage(plugin);
return -1;
}
}
return 0;
}
/** Implements the close_output function of the plugin API */
int bgpcorsaro_pfxmonitor_close_output(bgpcorsaro_t *bgpcorsaro)
{
int i;
struct bgpcorsaro_pfxmonitor_state_t *state = STATE(bgpcorsaro);
khiter_t k;
khash_t(peer_asn_map) * v;
if (state == NULL) {
return 0;
}
/* close all the outfile pointers */
for (i = 0; i < OUTFILE_POINTERS; i++) {
if (state->outfile_p[i] != NULL) {
wandio_wdestroy(state->outfile_p[i]);
state->outfile_p[i] = NULL;
}
}
state->outfile = NULL;
if (state->poi != NULL) {
bgpstream_ip_counter_destroy(state->poi);
state->poi = NULL;
}
/* deallocate the dynamic memory in use */
if (state->overlapping_pfx_cache != NULL) {
bgpstream_pfx_storage_set_destroy(state->overlapping_pfx_cache);
state->overlapping_pfx_cache = NULL;
}
if (state->non_overlapping_pfx_cache != NULL) {
bgpstream_pfx_storage_set_destroy(state->non_overlapping_pfx_cache);
state->non_overlapping_pfx_cache = NULL;
}
if (state->peer_asns != NULL) {
bgpstream_id_set_destroy(state->peer_asns);
state->peer_asns = NULL;
}
if (state->pfx_info != NULL) {
for (k = kh_begin(state->pfx_info); k != kh_end(state->pfx_info); ++k) {
if (kh_exist(state->pfx_info, k)) {
v = kh_val(state->pfx_info, k);
kh_destroy(peer_asn_map, v);
}
}
kh_destroy(pfx_info_map, state->pfx_info);
state->pfx_info = NULL;
}
if (state->unique_origins != NULL) {
bgpstream_id_set_destroy(state->unique_origins);
state->unique_origins = NULL;
}
bgpcorsaro_plugin_free_state(bgpcorsaro->plugin_manager, PLUGIN(bgpcorsaro));
return 0;
}
/** Implements the close_input function of the plugin API */
int corsaro_dos_close_input(corsaro_in_t *corsaro)
{
struct corsaro_dos_in_state_t *state = STATE_IN(corsaro);
if(state != NULL)
{
corsaro_plugin_free_state(corsaro->plugin_manager, PLUGIN(corsaro));
}
return 0;
}
/** Implements the init_output function of the plugin API */
int bgpcorsaro_pfxmonitor_init_output(bgpcorsaro_t *bgpcorsaro)
{
struct bgpcorsaro_pfxmonitor_state_t *state;
bgpcorsaro_plugin_t *plugin = PLUGIN(bgpcorsaro);
assert(plugin != NULL);
if ((state = malloc_zero(sizeof(struct bgpcorsaro_pfxmonitor_state_t))) ==
NULL) {
bgpcorsaro_log(__func__, bgpcorsaro,
"could not malloc bgpcorsaro_pfxmonitor_state_t");
goto err;
}
bgpcorsaro_plugin_register_state(bgpcorsaro->plugin_manager, plugin, state);
/* initialize state with default values */
state = STATE(bgpcorsaro);
strncpy(state->metric_prefix, PFXMONITOR_DEFAULT_METRIC_PFX,
PFXMONITOR_METRIC_PFX_LEN);
strncpy(state->ip_space_name, PFXMONITOR_DEFAULT_IPSPACE_NAME,
PFXMONITOR_METRIC_PFX_LEN);
if ((state->poi = bgpstream_ip_counter_create()) == NULL) {
goto err;
}
state->peer_asns_th = PFXMONITOR_DEFAULT_PEER_ASNS_THRESHOLD;
state->more_specific = 0;
/* parse the arguments */
if (parse_args(bgpcorsaro) != 0) {
goto err;
}
graphite_safe(state->metric_prefix);
graphite_safe(state->ip_space_name);
/* create all the sets and maps we need */
if ((state->overlapping_pfx_cache = bgpstream_pfx_storage_set_create()) ==
NULL ||
(state->non_overlapping_pfx_cache = bgpstream_pfx_storage_set_create()) ==
NULL ||
(state->pfx_info = kh_init(pfx_info_map)) == NULL ||
(state->unique_origins = bgpstream_id_set_create()) == NULL ||
(state->peer_asns = bgpstream_id_set_create()) == NULL) {
goto err;
}
/* defer opening the output file until we start the first interval */
return 0;
err:
bgpcorsaro_pfxmonitor_close_output(bgpcorsaro);
return -1;
}
/* store screenshot contents in buf */
static size_t
read_callback (void *buf, size_t size, size_t nmemb, void *stream) {
PurplePlugin *plugin;
GIOChannel *io_chan;
GError *error = NULL;
size_t ret;
plugin = purple_plugins_find_with_id (PLUGIN_ID);
io_chan = (GIOChannel *) stream;
g_io_channel_read_chars (io_chan, buf, size * nmemb, &ret, &error);
if (error != NULL) {
g_propagate_error (&PLUGIN (error), error);
return CURL_READFUNC_ABORT;
}
PLUGIN (read_size) += ret; /* progress bar */
return ret;
}
static guint
update_countdown (PurplePlugin * plugin) {
GtkWidget *progress_bar = NULL;
g_assert (plugin != NULL && plugin->extra != NULL);
if (PLUGIN (countdown_dialog) == NULL) /* forced or canceled */
return FALSE;
progress_bar =
g_object_get_data (G_OBJECT (PLUGIN (countdown_dialog)),
"progress-bar");
if (progress_bar != NULL) {
gdouble val =
gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (progress_bar));
gdouble incr = 250.0 / ((gdouble)
((purple_prefs_get_int
(PREF_WAIT_BEFORE_SCREENSHOT) -
1)) * 1000.0);
if (val < 0.99) {
gchar *text = NULL;
text = g_strdup_printf ("%.02f sec.", ((gdouble)
purple_prefs_get_int
(PREF_WAIT_BEFORE_SCREENSHOT))
* (1.0 - (val + incr)));
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar),
MIN (val + incr, 1.0));
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress_bar), text);
g_free (text);
return TRUE;
}
else {
gtk_widget_destroy (PLUGIN (countdown_dialog));
PLUGIN (countdown_dialog) = NULL;
}
}
return FALSE;
}
/** Implements the start_interval function of the plugin API */
int corsaro_dos_start_interval(corsaro_t *corsaro, corsaro_interval_t *int_start)
{
/* open the output file if it has been closed */
if(STATE(corsaro)->outfile == NULL &&
(STATE(corsaro)->outfile =
corsaro_io_prepare_file(corsaro, PLUGIN(corsaro)->name,
int_start)) == NULL)
{
corsaro_log(__func__, corsaro, "could not open %s output file",
PLUGIN(corsaro)->name);
return -1;
}
if(STATE(corsaro)->first_interval == 0)
{
/* -1 to simulate the end of the 'previous' interval */
STATE(corsaro)->first_interval = int_start->time-1;
}
return 0;
}
/** Implements the start_interval function of the plugin API */
int bgpcorsaro_pacifier_start_interval(bgpcorsaro_t *bgpcorsaro,
bgpcorsaro_interval_t *int_start)
{
struct bgpcorsaro_pacifier_state_t *state = STATE(bgpcorsaro);
if(state->outfile == NULL)
{
if((
state->outfile_p[state->outfile_n] =
bgpcorsaro_io_prepare_file(bgpcorsaro,
PLUGIN(bgpcorsaro)->name,
int_start)) == NULL)
{
bgpcorsaro_log(__func__, bgpcorsaro, "could not open %s output file",
PLUGIN(bgpcorsaro)->name);
return -1;
}
state->outfile = state->
outfile_p[state->outfile_n];
}
bgpcorsaro_io_write_interval_start(bgpcorsaro, state->outfile, int_start);
struct timeval tv;
if(state->tv_start == 0)
{
gettimeofday_wrap(&tv);
state->tv_start = tv.tv_sec;
state->tv_first_time = state->tv_start;
}
// a new interval is starting
state->intervals++;
// fprintf(stderr, "START INTERVAL TIME: %d \n", state->tv_start);
return 0;
}
/** Implements the start_interval function of the plugin API */
int bgpcorsaro_pfxmonitor_start_interval(bgpcorsaro_t *bgpcorsaro,
bgpcorsaro_interval_t *int_start)
{
struct bgpcorsaro_pfxmonitor_state_t *state = STATE(bgpcorsaro);
/* open an output file */
if (state->outfile == NULL) {
if ((state->outfile_p[state->outfile_n] = bgpcorsaro_io_prepare_file(
bgpcorsaro, PLUGIN(bgpcorsaro)->name, int_start)) == NULL) {
bgpcorsaro_log(__func__, bgpcorsaro, "could not open %s output file",
PLUGIN(bgpcorsaro)->name);
return -1;
}
state->outfile = state->outfile_p[state->outfile_n];
}
bgpcorsaro_io_write_interval_start(bgpcorsaro, state->outfile, int_start);
/* save the interval start to correctly output the time series values */
state->interval_start = int_start->time;
return 0;
}
static
void
on_countdown_dialog_response_cb (PurplePlugin * plugin, gint response_id) {
g_assert (plugin != NULL && plugin->extra != NULL);
switch (response_id) {
case GTK_RESPONSE_ACCEPT:
{
if (purple_timeout_remove (PLUGIN (timeout_source))) {
PLUGIN (timeout_source) = 0;
/* delete_infobar (plugin); */
gtk_widget_destroy (PLUGIN (countdown_dialog));
PLUGIN (countdown_dialog) = NULL;
PLUGIN (timeout_source) =
purple_timeout_add
(MSEC_TIMEOUT_VAL, (GSourceFunc) timeout_freeze_screen,
plugin);
}
break;
}
case GTK_RESPONSE_REJECT:
case GTK_RESPONSE_DELETE_EVENT:
{
if (purple_timeout_remove (PLUGIN (timeout_source))) {
PLUGIN (timeout_source) = 0;
gtk_widget_destroy (PLUGIN (countdown_dialog));
PLUGIN (countdown_dialog) = NULL;
plugin_stop (plugin);
}
break;
}
}
}
void add_plugin_to_menu (gpointer data, gpointer user_data)
{
static int i=1;
GtkPluginManagerMenu *menu=(GtkPluginManagerMenu *) user_data;
GtkWidget *item;
Plugin *plugin;
plugin = PLUGIN(data);
/*
* Syntax plugins are automatically incorporate to the syntax check system so don't show that plugins here.
* TODO: maybe configure this in preferences??
*/
if (get_plugin_syntax_type(plugin)==-1){
item = gtk_menu_item_new_image_item(GTK_STOCK_EXECUTE, get_plugin_name(plugin));
gtk_widget_show(item);
install_menu_hint(item, (gchar *)get_plugin_description(plugin), &main_window);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(plugin_exec), (gpointer) menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
if (i<10) gtk_widget_add_accelerator(item, "activate", menu->priv->accel_group, parse_shortcut(i), GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
i++;
}
}
/** Implements the close_output function of the plugin API */
int bgpcorsaro_pacifier_close_output(bgpcorsaro_t *bgpcorsaro)
{
int i;
struct bgpcorsaro_pacifier_state_t *state = STATE(bgpcorsaro);
if(state != NULL)
{
/* close all the outfile pointers */
for(i = 0; i < OUTFILE_POINTERS; i++)
{
if(state->outfile_p[i] != NULL)
{
wandio_wdestroy(state->outfile_p[i]);
state->outfile_p[i] = NULL;
}
}
state->outfile = NULL;
bgpcorsaro_plugin_free_state(bgpcorsaro->plugin_manager, PLUGIN(bgpcorsaro));
}
return 0;
}
/** Implements the close_output function of the plugin API */
int corsaro_dos_close_output(corsaro_t *corsaro)
{
struct corsaro_dos_state_t *state = STATE(corsaro);
if(state != NULL)
{
if(state->attack_hash != NULL)
{
kh_free(av, state->attack_hash, &attack_vector_free);
kh_destroy(av, state->attack_hash);
state->attack_hash = NULL;
}
if(state->outfile != NULL)
{
corsaro_file_close(corsaro, state->outfile);
state->outfile = NULL;
}
corsaro_plugin_free_state(corsaro->plugin_manager, PLUGIN(corsaro));
}
return 0;
}
/**
* Handle hiding and showing stuff based on what type of conv this is...
*/
static void
on_conversation_menu_show_cb (PidginWindow * win) {
PurpleConversation *conv;
GtkWidget *conversation_menu, *img_menuitem, *screenshot_menuitem;
#ifdef ENABLE_UPLOAD
GtkWidget *link_menuitem, *ftp_link_menuitem;
#endif
PurplePlugin *plugin = purple_plugins_find_with_id (PLUGIN_ID);
conv = pidgin_conv_window_get_active_conversation (win);
conversation_menu =
gtk_item_factory_get_widget (win->menu.item_factory,
N_("/Conversation"));
#ifdef ENABLE_UPLOAD
link_menuitem =
g_object_get_data (G_OBJECT (conversation_menu), "link_menuitem");
ftp_link_menuitem =
g_object_get_data (G_OBJECT (conversation_menu), "ftp_link_menuitem");
on_screenshot_insert_as_link_show_cb (link_menuitem,
PIDGIN_CONVERSATION (conv));
on_screenshot_insert_as_ftp_link_show_cb (ftp_link_menuitem,
PIDGIN_CONVERSATION (conv));
#endif
img_menuitem =
g_object_get_data (G_OBJECT (conversation_menu), "img_menuitem");
// on_screenshot_insert_as_image_show_cb (img_menuitem,
// PIDGIN_CONVERSATION (conv));
screenshot_menuitem =
g_object_get_data (G_OBJECT (conversation_menu),
"screenshot_menuitem");
gtk_widget_set_sensitive (screenshot_menuitem, !PLUGIN (locked));
}
/** Implements the init_output function of the plugin API */
int bgpcorsaro_pacifier_init_output(bgpcorsaro_t *bgpcorsaro)
{
struct bgpcorsaro_pacifier_state_t *state;
bgpcorsaro_plugin_t *plugin = PLUGIN(bgpcorsaro);
assert(plugin != NULL);
if((state = malloc_zero(sizeof(struct bgpcorsaro_pacifier_state_t))) == NULL)
{
bgpcorsaro_log(__func__, bgpcorsaro,
"could not malloc bgpcorsaro_pacifier_state_t");
goto err;
}
bgpcorsaro_plugin_register_state(bgpcorsaro->plugin_manager, plugin, state);
// initializing state
state = STATE(bgpcorsaro);
state->tv_start = 0; // 0 means it is the first interval, so the time has to be initialized at interval start
state->wait = 30; // 30 seconds is the default wait time, between start and end
state->tv_first_time = 0; // 0 means it is the first interval, so the time has to be initialized at interval start
state->intervals = 0; // number of intervals processed
state->adaptive = 0; // default behavior is not adaptive
/* parse the arguments */
if(parse_args(bgpcorsaro) != 0)
{
return -1;
}
/* defer opening the output file until we start the first interval */
return 0;
err:
bgpcorsaro_pacifier_close_output(bgpcorsaro);
return -1;
}
void
ftp_upload_prepare (PurplePlugin * plugin) {
struct host_param_data *host_data;
g_assert (plugin != NULL && plugin->extra != NULL);
host_data = PLUGIN (host_data);
g_assert (PLUGIN (uploading_dialog) == NULL);
g_assert (PLUGIN (libcurl_thread) == NULL);
PLUGIN (read_size) = 0;
PLUGIN (uploading_dialog) =
show_uploading_dialog (plugin,
purple_prefs_get_string (PREF_FTP_REMOTE_URL));
PLUGIN (libcurl_thread) =
g_thread_create ((GThreadFunc) ftp_upload, plugin, FALSE, NULL);
PLUGIN (timeout_cb_handle) =
g_timeout_add (PLUGIN_UPLOAD_PROGRESS_INTERVAL,
(GSourceFunc) insert_ftp_link_cb, plugin);
}
static void
on_blist_context_menu_send_capture (PurpleBuddy * buddy,
PurplePlugin * plugin) {
if (PLUGIN (locked))
return; /* Just return, don't fail. */
else {
PLUGIN (locked) = TRUE;
PLUGIN (send_as) = SEND_AS_FILE;
PLUGIN (conv_type) = PURPLE_CONV_TYPE_UNKNOWN; /* no conv opened */
PLUGIN (account) = purple_buddy_get_account (buddy);
PLUGIN (name) = g_strdup_printf ("%s", purple_buddy_get_name (buddy));
/* see on_screenshot_insert_as_image_activate_cb () */
freeze_desktop (plugin, FALSE);
}
}
/** Implements the end_interval function of the plugin API */
int corsaro_dos_end_interval(corsaro_t *corsaro, corsaro_interval_t *int_end)
{
int this_interval = int_end->time-STATE(corsaro)->first_interval;
khiter_t i;
attack_vector_t *vector;
attack_vector_t **attack_arr = NULL;
int attack_arr_cnt = 0;
uint8_t gbuf[12];
uint8_t cntbuf[4];
if(this_interval < CORSARO_DOS_INTERVAL)
{
/* we haven't run for long enough to dump */
return 0;
}
else
{
/* we either have hit exactly the right amount of time,
or we have gone for too long, dump now and reset the counter */
STATE(corsaro)->first_interval = int_end->time;
/* fall through and continue to dump */
}
/* this is an interval we care about */
/* malloc an array big enough to hold the entire hash even though we wont
need it to be that big */
if((attack_arr =
malloc(sizeof(attack_vector_t *)*
kh_size(STATE(corsaro)->attack_hash))) == NULL)
{
corsaro_log(__func__, corsaro,
"could not malloc array for attack vectors");
return -1;
}
/* classify the flows and dump the attack ones */
for(i = kh_begin(STATE(corsaro)->attack_hash);
i != kh_end(STATE(corsaro)->attack_hash); ++i)
{
if(kh_exist(STATE(corsaro)->attack_hash, i))
{
vector = kh_key(STATE(corsaro)->attack_hash, i);
if(attack_vector_is_expired(vector, int_end->time) != 0)
{
kh_del(av, STATE(corsaro)->attack_hash, i);
attack_vector_free(vector);
vector = NULL;
}
else if(attack_vector_is_attack(corsaro, vector, int_end->time) != 0)
{
/* this is an attack */
/* add it to the attack array so we can know how many
before we dump it */
attack_arr[attack_arr_cnt] = vector;
attack_arr_cnt++;
}
else
{
attack_vector_reset(vector);
}
}
}
corsaro_io_write_interval_start(corsaro, STATE(corsaro)->outfile,
&corsaro->interval_start);
if(corsaro->global_file != NULL)
{
corsaro_io_write_plugin_start(corsaro, corsaro->global_file,
PLUGIN(corsaro));
}
if(CORSARO_FILE_MODE(STATE(corsaro)->outfile) == CORSARO_FILE_MODE_ASCII)
{
if(corsaro->global_file != NULL)
{
/* global stats */
/* dump the number of mismatched packets and vectors */
corsaro_file_printf(corsaro, corsaro->global_file,
"mismatch: %"PRIu32"\n"
"attack_vectors: %"PRIu32"\n"
"non-attack_vectors: %"PRIu32"\n",
STATE(corsaro)->number_mismatched_packets,
attack_arr_cnt,
kh_size(STATE(corsaro)->attack_hash)
-attack_arr_cnt);
}
/* dump the number of vectors */
corsaro_file_printf(corsaro, STATE(corsaro)->outfile, "%"PRIu32"\n",
attack_arr_cnt);
/* dump the vectors */
for(i = 0; i < attack_arr_cnt; i++)
{
if(ascii_dump(corsaro, attack_arr[i]) != 0)
{
corsaro_log(__func__, corsaro, "could not dump hash");
return -1;
}
/* reset the interval stats */
attack_vector_reset(attack_arr[i]);
}
}
else if(CORSARO_FILE_MODE(STATE(corsaro)->outfile) == CORSARO_FILE_MODE_BINARY)
{
if(corsaro->global_file != NULL)
{
/* global stats */
bytes_htonl(&gbuf[0], STATE(corsaro)->number_mismatched_packets);
bytes_htonl(&gbuf[4], attack_arr_cnt);
bytes_htonl(&gbuf[8],
kh_size(STATE(corsaro)->attack_hash)-attack_arr_cnt);
if(corsaro_file_write(corsaro, corsaro->global_file,
&gbuf[0], 12) != 12)
{
corsaro_log(__func__, corsaro,
"could not dump global stats to file");
return -1;
}
}
/* dump the number of vectors */
bytes_htonl(&cntbuf[0], attack_arr_cnt);
if(corsaro_file_write(corsaro, STATE(corsaro)->outfile,
&cntbuf[0], 4) != 4)
{
corsaro_log(__func__, corsaro,
"could not dump vector count to file");
return -1;
}
/* dump the vectors */
for(i = 0; i < attack_arr_cnt; i++)
{
if(binary_dump(corsaro, attack_arr[i]) != 0)
{
corsaro_log(__func__, corsaro, "could not dump hash");
return -1;
}
attack_vector_reset(attack_arr[i]);
}
}
else
{
corsaro_log(__func__, corsaro, "invalid mode");
return -1;
}
if(corsaro->global_file != NULL)
{
corsaro_io_write_plugin_end(corsaro, corsaro->global_file,
PLUGIN(corsaro));
}
corsaro_io_write_interval_end(corsaro, STATE(corsaro)->outfile, int_end);
STATE(corsaro)->number_mismatched_packets = 0;
free(attack_arr);
/* if we are rotating, now is when we should do it */
if(corsaro_is_rotate_interval(corsaro))
{
/* close the current file */
if(STATE(corsaro)->outfile != NULL)
{
corsaro_file_close(corsaro, STATE(corsaro)->outfile);
STATE(corsaro)->outfile = NULL;
}
}
return 0;
}
void
show_countdown_dialog (PurplePlugin * plugin) {
GtkWidget *content_area;
GtkWidget *img;
GtkWidget *hbox, *vbox;
GtkWidget *progress_bar;
GtkWidget *gtkconv_window;
GtkWidget *blist_window;
GtkWidget *label = NULL;
g_assert (plugin != NULL && plugin->extra != NULL);
g_assert (PLUGIN (countdown_dialog) == NULL);
progress_bar = gtk_progress_bar_new ();
img =
gtk_image_new_from_stock (PIDGIN_STOCK_INFO,
gtk_icon_size_from_name
(PIDGIN_ICON_SIZE_TANGO_SMALL));
hbox = gtk_hbox_new (FALSE, PIDGIN_HIG_BOX_SPACE);
vbox = gtk_vbox_new (FALSE, PIDGIN_HIG_BOX_SPACE);
gtkconv_window = get_receiver_window (plugin);
blist_window = pidgin_blist_get_default_gtk_blist ()->window;
PLUGIN (countdown_dialog) =
gtk_dialog_new_with_buttons (PLUGIN_NAME,
GTK_WINDOW ((gtkconv_window) ?
gtkconv_window :
blist_window),
0, GTK_STOCK_EXECUTE,
GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT, NULL);
gtk_window_set_resizable (GTK_WINDOW (PLUGIN (countdown_dialog)), FALSE);
gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (progress_bar), 0.05);
g_object_set_data (G_OBJECT (PLUGIN (countdown_dialog)), "progress-bar",
progress_bar);
label = gtk_label_new (COUNTDOWN_MSG);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), 0);
#if GTK_CHECK_VERSION (2,14,0)
content_area =
gtk_dialog_get_content_area (GTK_DIALOG (PLUGIN (countdown_dialog)));
#else
content_area = (GTK_DIALOG (PLUGIN (countdown_dialog)))->vbox;
#endif
gtk_window_set_deletable (GTK_WINDOW (PLUGIN (countdown_dialog)), FALSE);
gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
gtk_box_pack_start_defaults (GTK_BOX (vbox), hbox);
gtk_box_pack_start (GTK_BOX (hbox), img, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), progress_bar, FALSE, FALSE, 0);
gtk_widget_show_all (PLUGIN (countdown_dialog));
purple_timeout_add (250, (GSourceFunc) update_countdown, plugin);
g_signal_connect_swapped (G_OBJECT (PLUGIN (countdown_dialog)),
"response",
G_CALLBACK (on_countdown_dialog_response_cb),
plugin);
}
static gboolean
catch_hotkeys_cb (PidginWindow * win, GdkEventKey * event) {
if (event->is_modifier == FALSE) {
gint all_modifiers = 0;
PurpleConversation *conv = NULL;
if (event->state & GDK_SHIFT_MASK)
all_modifiers |= GDK_SHIFT_MASK;
if (event->state & GDK_CONTROL_MASK)
all_modifiers |= GDK_CONTROL_MASK;
if (event->state & GDK_MOD1_MASK)
all_modifiers |= GDK_MOD1_MASK;
conv = pidgin_conv_window_get_active_conversation (win);
if (gdk_keyval_to_lower (event->keyval) ==
(guint) purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_FILE)
&&
all_modifiers ==
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_FILE_MDFS))
{
PurpleConnection *gc = NULL;
PurplePluginProtocolInfo *prpl_info = NULL;
gc = purple_conversation_get_gc (conv);
if ((gc != NULL) &&
((purple_conversation_get_type (conv) !=
PURPLE_CONV_TYPE_CHAT)
|| !purple_conv_chat_has_left (PURPLE_CONV_CHAT (conv)))) {
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO (gc->prpl);
if (purple_conversation_get_type (conv) ==
PURPLE_CONV_TYPE_IM
&& prpl_info->send_file != NULL
&& (!prpl_info->can_receive_file
|| prpl_info->can_receive_file (gc,
purple_conversation_get_name
(conv)))) {
PurplePlugin *plugin =
purple_plugins_find_with_id (PLUGIN_ID);
if (PLUGIN (locked))
return FALSE; /* Just return, don't fail. */
else {
PLUGIN (locked) = TRUE;
PLUGIN (send_as) = SEND_AS_FILE;
REMEMBER_ACCOUNT (PIDGIN_CONVERSATION (conv));
freeze_desktop (plugin, FALSE);
}
}
}
}
#ifdef ENABLE_UPLOAD
else if (gdk_keyval_to_lower (event->keyval) ==
(guint) purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_FTP)
&&
all_modifiers ==
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_FTP_MDFS)
)
send_as_ftp_link(win, NULL);
//on_screenshot_insert_as_ftp_link_fromwin_activate_cb (win);
else if (gdk_keyval_to_lower (event->keyval) ==
(guint) purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_HTTP)
&&
all_modifiers ==
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_HTTP_MDFS)
)
send_as_link(win, NULL);
//on_screenshot_insert_as_link_fromwin_activate_cb (win);
#endif
else if (gdk_keyval_to_lower (event->keyval) == (guint)
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_IMAGE)
&&
all_modifiers ==
purple_prefs_get_int (PREF_HOTKEYS_SEND_AS_IMAGE_MDFS)
) {
// if (!(purple_conversation_get_features (conv) &
// PURPLE_CONNECTION_NO_IMAGES))
// on_screenshot_insert_as_image_fromwin_activate_cb (win);
}
else {
/* nothing match ! */
}
return TRUE;
}
return FALSE; /* let the signal be handled by other callbacks */
}
/**
If the plugin is locked, don't activate the menuitem.
This tipically happens when we're sending the capture to a remote server.
*/
static void
on_insert_menu_show_cb (GtkWidget * screenshot_insert_menuitem) {
PurplePlugin *plugin = purple_plugins_find_with_id (PLUGIN_ID);
gtk_widget_set_sensitive (screenshot_insert_menuitem, !PLUGIN (locked));
}
/** Parse the arguments given to the plugin */
static int parse_args(bgpcorsaro_t *bgpcorsaro)
{
bgpcorsaro_plugin_t *plugin = PLUGIN(bgpcorsaro);
struct bgpcorsaro_pfxmonitor_state_t *state = STATE(bgpcorsaro);
int opt;
bgpstream_pfx_storage_t pfx_st;
if (plugin->argc <= 0) {
return 0;
}
/* NB: remember to reset optind to 1 before using getopt! */
optind = 1;
while ((opt = getopt(plugin->argc, plugin->argv, ":l:L:m:n:i:M?")) >= 0) {
switch (opt) {
case 'm':
if (optarg != NULL && strlen(optarg) - 1 <= PFXMONITOR_METRIC_PFX_LEN) {
strncpy(state->metric_prefix, optarg, PFXMONITOR_METRIC_PFX_LEN);
} else {
fprintf(stderr, "Error: could not set metric prefix\n");
usage(plugin);
return -1;
}
break;
case 'i':
if (optarg != NULL && strlen(optarg) - 1 <= PFXMONITOR_METRIC_PFX_LEN) {
strncpy(state->ip_space_name, optarg, PFXMONITOR_METRIC_PFX_LEN);
} else {
fprintf(stderr, "Error: could not set IP space name\n");
usage(plugin);
return -1;
}
break;
case 'l':
if (bgpstream_str2pfx(optarg, &pfx_st) == NULL) {
fprintf(stderr, "Error: Could not parse prefix (%s)\n", optarg);
usage(plugin);
return -1;
}
bgpstream_ip_counter_add(state->poi, (bgpstream_pfx_t *)&pfx_st);
break;
case 'L':
if (add_prefixes_from_file(state->poi, optarg) != 0) {
return -1;
}
break;
case 'M':
state->more_specific = 1;
break;
case 'n':
state->peer_asns_th = atoi(optarg);
break;
case '?':
case ':':
default:
usage(plugin);
return -1;
}
}
/* if no prefixes were provided, */
if (bgpstream_ip_counter_get_ipcount(state->poi,
BGPSTREAM_ADDR_VERSION_IPV4) == 0 &&
bgpstream_ip_counter_get_ipcount(state->poi,
BGPSTREAM_ADDR_VERSION_IPV6) == 0) {
fprintf(stderr, "Error: no valid prefixes provided\n");
usage(plugin);
return -1;
}
return 0;
}
/* inspired from http://curl.haxx.se/libcurl/c/ftpupload.html */
static gpointer
ftp_upload (PurplePlugin * plugin) {
CURL *curl;
CURLcode res;
GIOChannel *io_chan = NULL;
struct stat file_info;
gchar *remote_url = NULL;
gchar *basename = NULL;
g_assert (plugin != NULL && plugin->extra != NULL);
G_LOCK (unload);
/* get the file size of the local file */
if (g_stat (PLUGIN (capture_path_filename), &file_info) == -1) {
g_assert (PLUGIN (error) == NULL);
g_set_error (&PLUGIN (error),
SENDSCREENSHOT_PLUGIN_ERROR,
PLUGIN_ERROR_OPEN_SCREENSHOT_FILE,
"%s\n%s",
PLUGIN_ERROR_OPEN_SCREENSHOT_FILE_s, g_strerror (errno));
THREAD_QUIT;
}
PLUGIN (total_size) = file_info.st_size;
basename = g_path_get_basename (PLUGIN (capture_path_filename));
remote_url =
g_strdup_printf ("%s/%s",
purple_prefs_get_string (PREF_FTP_REMOTE_URL),
basename);
g_free (basename);
basename = NULL;
io_chan =
g_io_channel_new_file (PLUGIN (capture_path_filename), "r",
&PLUGIN (error));
if (io_chan == NULL) {
g_assert (PLUGIN (error) != NULL);
g_free (remote_url);
THREAD_QUIT;
}
/* binary data, this should never fail */
g_io_channel_set_encoding (io_chan, NULL, NULL);
/* get a curl handle */
curl = curl_easy_init ();
if (curl != NULL) {
static char curl_error[CURL_ERROR_SIZE];
plugin_curl_set_common_opts (curl, plugin);
/* we want to use our own read function */
curl_easy_setopt (curl, CURLOPT_READFUNCTION, read_callback);
curl_easy_setopt (curl, CURLOPT_READDATA, io_chan);
/* enable uploading */
curl_easy_setopt (curl, CURLOPT_UPLOAD, 1L);
/* specify target */
curl_easy_setopt (curl, CURLOPT_URL, remote_url);
/* specify username and password */
curl_easy_setopt (curl, CURLOPT_USERNAME,
purple_prefs_get_string (PREF_FTP_USERNAME));
curl_easy_setopt (curl, CURLOPT_PASSWORD,
purple_prefs_get_string (PREF_FTP_PASSWORD));
curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, curl_error);
/* Now run off and do what you've been told! */
res = curl_easy_perform (curl);
PLUGIN (read_size) = 0;
/* always cleanup */
curl_easy_cleanup (curl);
g_free (remote_url);
if (PLUGIN (error) != NULL) { /* read_callback() failed */
g_io_channel_unref (io_chan);
THREAD_QUIT;
}
else if (res != 0) {
g_assert (PLUGIN (error) == NULL);
g_set_error (&PLUGIN (error),
SENDSCREENSHOT_PLUGIN_ERROR,
PLUGIN_ERROR_FTP_UPLOAD,
"%s\n%s", PLUGIN_ERROR_FTP_UPLOAD_s, curl_error);
}
}
if ((g_io_channel_shutdown (io_chan, TRUE, NULL)) == G_IO_STATUS_ERROR) {
g_io_channel_unref (io_chan);
THREAD_QUIT;
}
g_io_channel_unref (io_chan);
THREAD_QUIT;
}
static gboolean
insert_ftp_link_cb (PurplePlugin * plugin) {
g_assert (plugin != NULL && plugin->extra != NULL);
/* still uploading... */
if (PLUGIN (libcurl_thread) != NULL) {
GtkProgressBar *progress_bar =
g_object_get_data (G_OBJECT (PLUGIN (uploading_dialog)),
"progress-bar");
g_assert (progress_bar != NULL);
if (PLUGIN (read_size) == 0)
gtk_progress_bar_pulse (progress_bar);
else {
gchar *str = NULL;
gdouble val = PLUGIN (read_size) / (gdouble) PLUGIN (total_size);
str = g_strdup_printf ("%d%%", (gint) (val * 100));
gtk_progress_bar_set_text (progress_bar, str);
g_free (str);
gtk_progress_bar_set_fraction (progress_bar, val);
}
return TRUE;
}
else {
PLUGIN (timeout_cb_handle) = 0;
gtk_widget_destroy (PLUGIN (uploading_dialog));
PLUGIN (uploading_dialog) = NULL;
/* an error occured */
if (PLUGIN (error) != NULL) {
NotifyUploadError ("%s", PLUGIN (error)->message);
g_error_free (PLUGIN (error));
PLUGIN (error) = NULL;
}
else {
gchar *remote_url;
gchar *basename;
basename = g_path_get_basename (PLUGIN (capture_path_filename));
if (strcmp (purple_prefs_get_string (PREF_FTP_WEB_ADDR), ""))
/* not only a ftp server, but also a html server */
remote_url = g_strdup_printf ("%s/%s",
purple_prefs_get_string
(PREF_FTP_WEB_ADDR), basename);
else
remote_url = g_strdup_printf ("%s/%s",
purple_prefs_get_string
(PREF_FTP_REMOTE_URL),
basename);
real_insert_link (plugin, remote_url);
g_free (remote_url);
g_free (basename);
}
}
plugin_stop (plugin);
return FALSE;
}
