static void sctp_graph_draw(struct sctp_udata *u_data) { int length, lwidth; guint32 distance=5, i, e, sec, w, start, a, j, b; gint label_width, label_height; char label_string[15]; gfloat dis; gboolean write_label = FALSE; PangoLayout *layout; if (u_data->io->x1_tmp_sec == 0 && u_data->io->x1_tmp_usec == 0) u_data->io->offset = 0; else u_data->io->offset = 5; if (u_data->io->x2_tmp_sec - u_data->io->x1_tmp_sec > 1500) { u_data->io->min_x=u_data->io->x1_tmp_sec; u_data->io->max_x=u_data->io->x2_tmp_sec; u_data->io->uoff = TRUE; } else { u_data->io->min_x=((guint32) (u_data->io->x1_tmp_sec*1000000.0))+u_data->io->x1_tmp_usec; u_data->io->max_x=((guint32) (u_data->io->x2_tmp_sec*1000000.0))+u_data->io->x2_tmp_usec; u_data->io->uoff = FALSE; } u_data->io->tmp_width = u_data->io->max_x - u_data->io->min_x; if (u_data->dir == 1) { if (u_data->io->tmp == FALSE) { if (u_data->assoc->sort_tsn1 != NULL) u_data->io->max_y = u_data->io->tmp_max_tsn1 - u_data->io->tmp_min_tsn1; else u_data->io->max_y = 0; u_data->io->min_y = 0; } else { u_data->io->max_y = u_data->io->tmp_max_tsn1; u_data->io->min_y = u_data->io->tmp_min_tsn1; } } else if (u_data->dir == 2) { if (u_data->io->tmp == FALSE) { if (u_data->assoc->tsn2 != NULL) u_data->io->max_y = u_data->io->tmp_max_tsn2 - u_data->io->tmp_min_tsn2; else u_data->io->max_y = 0; u_data->io->min_y = 0; } else { u_data->io->max_y = u_data->io->tmp_max_tsn2; u_data->io->min_y = u_data->io->tmp_min_tsn2; } } gdk_draw_rectangle(u_data->io->pixmap, u_data->io->draw_area->style->white_gc, TRUE, 0, 0, u_data->io->draw_area->allocation.width, u_data->io->draw_area->allocation.height); distance = 5; /* x_axis */ gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, LEFT_BORDER+u_data->io->offset,u_data->io->pixmap_height - BOTTOM_BORDER, u_data->io->pixmap_width - RIGHT_BORDER + u_data->io->offset, u_data->io->pixmap_height - BOTTOM_BORDER); gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, u_data->io->pixmap_width - RIGHT_BORDER + u_data->io->offset, u_data->io->pixmap_height - BOTTOM_BORDER, u_data->io->pixmap_width - RIGHT_BORDER + u_data->io->offset - 5, u_data->io->pixmap_height - BOTTOM_BORDER - 5); gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, u_data->io->pixmap_width - RIGHT_BORDER + u_data->io->offset, u_data->io->pixmap_height - BOTTOM_BORDER, u_data->io->pixmap_width - RIGHT_BORDER + u_data->io->offset - 5, u_data->io->pixmap_height - BOTTOM_BORDER + 5); u_data->io->axis_width = u_data->io->pixmap_width - LEFT_BORDER - RIGHT_BORDER - u_data->io->offset; if(u_data->io->tmp_width>0){ u_data->io->x_interval = (float)((u_data->io->axis_width*1.0)/u_data->io->tmp_width); /*distance in pixels between 2 data points*/ } else { u_data->io->x_interval = (float)(u_data->io->axis_width); } e=0; if (u_data->io->x_interval < 1) { dis = 1 / u_data->io->x_interval; while (dis >1) { dis /= 10; e++; } distance = 1; for (i=0; i<=e+1; i++) distance *= 10; } else distance = 5; g_snprintf(label_string, sizeof(label_string), "%d", 0); memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15); layout = gtk_widget_create_pango_layout(u_data->io->draw_area, label_string); pango_layout_get_pixel_size(layout, &label_width, &label_height); if (u_data->io->x1_tmp_usec == 0) sec = u_data->io->x1_tmp_sec; else sec = u_data->io->x1_tmp_sec+1; if (u_data->io->offset != 0) { g_snprintf(label_string, sizeof(label_string), "%u", u_data->io->x1_tmp_sec); memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); gdk_draw_layout(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, LEFT_BORDER - 25, u_data->io->pixmap_height - BOTTOM_BORDER + 20, layout); } w = (guint32)(500 / (guint32)(distance * u_data->io->x_interval)); if (w == 0) w = 1; if (w == 4 || w==3 || w==2) { w = 5; a = distance / 10; b = (guint32)((u_data->io->min_x/100000))%10; /* start for labels*/ } else { a = distance / 5; b = 0; } if (!u_data->io->uoff) { if (a>=1000000) { start=u_data->io->min_x/1000000*1000000; if (a==1000000) b = 0; } else { start=u_data->io->min_x/100000; if (start%2!=0) start--; start*=100000; b = (guint32)((start/100000))%10; } } else { start = u_data->io->min_x; if (start%2!=0) start--; b = 0; } for (i=start, j=b; i<=u_data->io->max_x; i+=a, j++) { if (!u_data->io->uoff) if (i >= u_data->io->min_x && i % 1000000 != 0) { length = 5; g_snprintf(label_string, sizeof(label_string), "%d", i%1000000); if (j % w == 0) { length = 10; memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); gdk_draw_layout(u_data->io->pixmap, u_data->io->draw_area->style->black_gc, (guint32)(LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval - lwidth / 2), u_data->io->pixmap_height - BOTTOM_BORDER + 10, layout); } gdk_draw_line(u_data->io->pixmap, u_data->io->draw_area->style->black_gc, (guint32)(LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval), u_data->io->pixmap_height - BOTTOM_BORDER, (guint32)(LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval), u_data->io->pixmap_height - BOTTOM_BORDER + length); } if (!u_data->io->uoff) { if (i%1000000==0 && j%w==0) { sec=i/1000000; write_label = TRUE; } } else { if (j%w == 0) { sec = i; write_label = TRUE; } } if (write_label) { gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, (guint32)(LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval), u_data->io->pixmap_height - BOTTOM_BORDER, (guint32)(LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval), u_data->io->pixmap_height - BOTTOM_BORDER + 10); g_snprintf(label_string, sizeof(label_string), "%d", sec); memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); gdk_draw_layout(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, (guint32)(LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval-10), u_data->io->pixmap_height - BOTTOM_BORDER + 20, layout); write_label = FALSE; } } g_strlcpy(label_string, "sec", sizeof(label_string)); memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); gdk_draw_layout(u_data->io->pixmap, u_data->io->draw_area->style->black_gc, u_data->io->pixmap_width - RIGHT_BORDER - 10, u_data->io->pixmap_height - BOTTOM_BORDER + 30, layout); distance = 5; /* y-axis */ gdk_draw_line(u_data->io->pixmap, u_data->io->draw_area->style->black_gc, LEFT_BORDER,TOP_BORDER - u_data->io->offset, LEFT_BORDER, u_data->io->pixmap_height - BOTTOM_BORDER - u_data->io->offset); gdk_draw_line(u_data->io->pixmap, u_data->io->draw_area->style->black_gc, LEFT_BORDER, TOP_BORDER - u_data->io->offset, LEFT_BORDER - 5, TOP_BORDER - u_data->io->offset + 5); gdk_draw_line(u_data->io->pixmap, u_data->io->draw_area->style->black_gc, LEFT_BORDER, TOP_BORDER - u_data->io->offset, LEFT_BORDER + 5, TOP_BORDER - u_data->io->offset + 5); u_data->io->y_interval = (float)(((u_data->io->pixmap_height - TOP_BORDER - BOTTOM_BORDER) * 1.0)/(u_data->io->max_y - u_data->io->min_y)); e = 0; if (u_data->io->y_interval < 1) { dis = 1 / u_data->io->y_interval; while (dis > 1) { dis /= 10; e++; } distance = 1; for (i=0; i<=e; i++) distance = distance * 10; } else if (u_data->io->y_interval<2) distance = 10; if (u_data->io->max_y > 0) { for (i=u_data->io->min_y/distance*distance; i<=u_data->io->max_y; i+=distance/5) { if (i >= u_data->io->min_y) { length = 5; g_snprintf(label_string, sizeof(label_string), "%d", i); if (i%distance == 0 || (distance <= 5 && u_data->io->y_interval > 10)) { length = 10; memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); gdk_draw_layout(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, LEFT_BORDER - length - lwidth - 5, (guint32)(u_data->io->pixmap_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval - 3), layout); } gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, LEFT_BORDER - length, (guint32)(u_data->io->pixmap_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval), LEFT_BORDER, (guint32)(u_data->io->pixmap_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval)); } } } else simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, "No Data Chunks sent"); }
/* Attempt to Write out "recent common" to the user's recent common file. If we got an error report it with a dialog box and return FALSE, otherwise return TRUE. */ gboolean write_recent(void) { char *pf_dir_path; char *rf_path; FILE *rf; /* To do: * - Split output lines longer than MAX_VAL_LEN * - Create a function for the preference directory check/creation * so that duplication can be avoided with filter.c */ /* Create the directory that holds personal configuration files, if necessary. */ if (create_persconffile_dir(&pf_dir_path) == -1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't create directory\n\"%s\"\nfor recent file: %s.", pf_dir_path, g_strerror(errno)); g_free(pf_dir_path); return FALSE; } rf_path = get_persconffile_path(RECENT_COMMON_FILE_NAME, FALSE, TRUE); if ((rf = ws_fopen(rf_path, "w")) == NULL) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't open recent file\n\"%s\": %s.", rf_path, g_strerror(errno)); g_free(rf_path); return FALSE; } g_free(rf_path); fputs("# Recent settings file for Wireshark " VERSION ".\n" "#\n" "# This file is regenerated each time Wireshark is quit.\n" "# So be careful, if you want to make manual changes here.\n" "\n" "######## Recent capture files (latest last), cannot be altered through command line ########\n" "\n", rf); menu_recent_file_write_all(rf); fputs("\n" "######## Recent capture filters (latest last), cannot be altered through command line ########\n" "\n", rf); cfilter_combo_recent_write_all(rf); fputs("\n" "######## Recent display filters (latest last), cannot be altered through command line ########\n" "\n", rf); dfilter_recent_combo_write_all(rf); #ifdef HAVE_PCAP_REMOTE fputs("\n" "######## Recent remote hosts, cannot be altered through command line ########\n" "\n", rf); capture_remote_combo_recent_write_all(rf); #endif fprintf(rf, "\n# Main window geometry.\n"); fprintf(rf, "# Decimal numbers.\n"); fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_X ": %d\n", recent.gui_geometry_main_x); fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_Y ": %d\n", recent.gui_geometry_main_y); fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_WIDTH ": %d\n", recent.gui_geometry_main_width); fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_HEIGHT ": %d\n", recent.gui_geometry_main_height); fprintf(rf, "\n# Main window maximized.\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED ": %s\n", recent.gui_geometry_main_maximized == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Statusbar left pane size.\n"); fprintf(rf, "# Decimal number.\n"); if (recent.gui_geometry_status_pane_left != 0) { fprintf(rf, RECENT_GUI_GEOMETRY_STATUS_PANE_LEFT ": %d\n", recent.gui_geometry_status_pane_left); } fprintf(rf, "\n# Statusbar middle pane size.\n"); fprintf(rf, "# Decimal number.\n"); if (recent.gui_geometry_status_pane_right != 0) { fprintf(rf, RECENT_GUI_GEOMETRY_STATUS_PANE_RIGHT ": %d\n", recent.gui_geometry_status_pane_right); } fprintf(rf, "\n# Last used Configuration Profile.\n"); fprintf(rf, RECENT_LAST_USED_PROFILE ": %s\n", get_profile_name()); fprintf(rf, "\n# WLAN statistics upper pane size.\n"); fprintf(rf, "# Decimal number.\n"); fprintf(rf, RECENT_GUI_GEOMETRY_WLAN_STATS_PANE ": %d\n", recent.gui_geometry_wlan_stats_pane); fprintf(rf, "\n# Warn if running with elevated permissions (e.g. as root).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_PRIVS_WARN_IF_ELEVATED ": %s\n", recent.privs_warn_if_elevated == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Warn if npf.sys isn't loaded on Windows >= 6.0.\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_PRIVS_WARN_IF_NO_NPF ": %s\n", recent.privs_warn_if_no_npf == TRUE ? "TRUE" : "FALSE"); window_geom_recent_write_all(rf); fclose(rf); /* XXX - catch I/O errors (e.g. "ran out of disk space") and return an error indication, or maybe write to a new recent file and rename that file on top of the old one only if there are not I/O errors. */ return TRUE; }
const gchar *apply_profile_changes(void) { char *pf_dir_path, *pf_dir_path2, *pf_filename; GList *fl1, *fl2; profile_def *profile1, *profile2; gboolean found; emem_strbuf_t *message = ep_strbuf_new(NULL); const gchar *err_msg; /* First validate all profile names */ fl1 = edited_profile_list(); while (fl1) { profile1 = (profile_def *) fl1->data; g_strstrip(profile1->name); if ((err_msg = profile_name_is_valid(profile1->name)) != NULL) { ep_strbuf_printf(message, "%s", err_msg); return message->str; } fl1 = g_list_next(fl1); } /* Then do all copy profiles */ fl1 = edited_profile_list(); while (fl1) { profile1 = (profile_def *) fl1->data; g_strstrip(profile1->name); if (profile1->status == PROF_STAT_COPY) { if (create_persconffile_profile(profile1->name, &pf_dir_path) == -1) { ep_strbuf_printf(message, "Can't create directory\n\"%s\":\n%s.", pf_dir_path, g_strerror(errno)); g_free(pf_dir_path); } profile1->status = PROF_STAT_EXISTS; if (profile1->reference) { if (copy_persconffile_profile(profile1->name, profile1->reference, profile1->from_global, &pf_filename, &pf_dir_path, &pf_dir_path2) == -1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't copy file \"%s\" in directory\n\"%s\" to\n\"%s\":\n%s.", pf_filename, pf_dir_path2, pf_dir_path, g_strerror(errno)); g_free(pf_filename); g_free(pf_dir_path); g_free(pf_dir_path2); } } g_free (profile1->reference); profile1->reference = g_strdup(profile1->name); } fl1 = g_list_next(fl1); } /* Then create new and rename changed */ fl1 = edited_profile_list(); while (fl1) { profile1 = (profile_def *) fl1->data; g_strstrip(profile1->name); if (profile1->status == PROF_STAT_NEW) { /* We do not create a directory for the default profile */ if (strcmp(profile1->name, DEFAULT_PROFILE)!=0) { if (create_persconffile_profile(profile1->name, &pf_dir_path) == -1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't create directory\n\"%s\":\n%s.", pf_dir_path, g_strerror(errno)); g_free(pf_dir_path); } profile1->status = PROF_STAT_EXISTS; g_free (profile1->reference); profile1->reference = g_strdup(profile1->name); } } else if (profile1->status == PROF_STAT_CHANGED) { if (strcmp(profile1->reference, profile1->name)!=0) { /* Rename old profile directory to new */ if (rename_persconffile_profile(profile1->reference, profile1->name, &pf_dir_path, &pf_dir_path2) == -1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't rename directory\n\"%s\" to\n\"%s\":\n%s.", pf_dir_path, pf_dir_path2, g_strerror(errno)); g_free(pf_dir_path); g_free(pf_dir_path2); } profile1->status = PROF_STAT_EXISTS; g_free (profile1->reference); profile1->reference = g_strdup(profile1->name); } } fl1 = g_list_next(fl1); } /* Last remove deleted */ fl1 = current_profile_list(); while (fl1) { found = FALSE; profile1 = (profile_def *) fl1->data; fl2 = edited_profile_list(); while (fl2) { profile2 = (profile_def *) fl2->data; if (!profile2->is_global) { if (strcmp(profile1->name, profile2->name)==0) { /* Profile exists in both lists */ found = TRUE; } else if (strcmp(profile1->name, profile2->reference)==0) { /* Profile has been renamed */ found = TRUE; } } fl2 = g_list_next(fl2); } if (!found) { /* Exists in existing list and not in edited, this is a deleted profile */ if (delete_persconffile_profile(profile1->name, &pf_dir_path) == -1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't delete profile directory\n\"%s\":\n%s.", pf_dir_path, g_strerror(errno)); g_free(pf_dir_path); } } fl1 = g_list_next(fl1); } copy_profile_list(); return NULL; }
/* * Update the channel offset of the given combobox according to the given frequency. */ void airpcap_update_channel_offset_combo(airpcap_if_info_t* if_info, guint32 chan_freq, GtkWidget *channel_offset_cb, gboolean set) { gint current_offset; gint new_offset; guint i; gint active_idx = 0; gint idx_count = -1; if (!if_info || airpcap_if_is_any(if_info) || if_info->pSupportedChannels == NULL || if_info->numSupportedChannels < 1) { gtk_widget_set_sensitive(GTK_WIDGET(channel_offset_cb),FALSE); gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), -1); return; } new_offset = current_offset = if_info->channelInfo.ExtChannel; /* Clear out the list */ while (gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(channel_offset_cb)), NULL) > 0) { gtk_combo_box_remove_text(GTK_COMBO_BOX(channel_offset_cb), 0); } gtk_widget_set_sensitive(GTK_WIDGET(channel_offset_cb), TRUE); for (i = 0; i < if_info->numSupportedChannels; i++) { if (if_info->pSupportedChannels[i].Frequency == chan_freq) { /* If we can't be low or high, nudge the offset to 0 */ if (current_offset == -1 && !(if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)) { new_offset = 0; } else if (current_offset == 1 && !(if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)) { new_offset = 0; } if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)) { gtk_combo_box_append_text(GTK_COMBO_BOX(channel_offset_cb), "-1"); idx_count++; if (new_offset == -1) { active_idx = idx_count; } } gtk_combo_box_append_text(GTK_COMBO_BOX(channel_offset_cb), "0"); idx_count++; if (new_offset == 0) { active_idx = idx_count; } if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)){ gtk_combo_box_append_text(GTK_COMBO_BOX(channel_offset_cb), "+1"); idx_count++; if (new_offset == 1) { active_idx = idx_count; } } break; } } gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), active_idx); if (set) { change_airpcap_settings = TRUE; if_info->channelInfo.ExtChannel = new_offset; if (!airpcap_update_frequency_and_offset(if_info)){ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Adapter failed to be set with the following settings: Frequency - %d Extension Channel - %d", if_info->channelInfo.Frequency, if_info->channelInfo.ExtChannel); } } if (idx_count < 1) { gtk_widget_set_sensitive(channel_offset_cb, FALSE); } }
/* XXX - Would it make more sense to use GStrings here instead of reallocing our buffers? */ static gboolean read_filters_file(FILE *f, gpointer user_data) { #define INIT_BUF_SIZE 128 gchar *name = NULL; gchar *filter_exp = NULL; guint32 name_len = INIT_BUF_SIZE; guint32 filter_exp_len = INIT_BUF_SIZE; guint32 i = 0; int c; guint16 fg_r, fg_g, fg_b, bg_r, bg_g, bg_b; gboolean disabled = FALSE; gboolean skip_end_of_line = FALSE; name = (gchar *)g_malloc(name_len + 1); filter_exp = (gchar *)g_malloc(filter_exp_len + 1); while (1) { if (skip_end_of_line) { do { c = getc(f); } while (c != EOF && c != '\n'); if (c == EOF) break; disabled = FALSE; skip_end_of_line = FALSE; } while ((c = getc(f)) != EOF && g_ascii_isspace(c)) { if (c == '\n') { continue; } } if (c == EOF) break; if (c == '!') { disabled = TRUE; continue; } /* skip # comments and invalid lines */ if (c != '@') { skip_end_of_line = TRUE; continue; } /* we get the @ delimiter. * Format is: * @name@filter expression@[background r,g,b][foreground r,g,b] */ /* retrieve name */ i = 0; while (1) { c = getc(f); if (c == EOF || c == '@') break; if (i >= name_len) { /* buffer isn't long enough; double its length.*/ name_len *= 2; name = (gchar *)g_realloc(name, name_len + 1); } name[i++] = c; } name[i] = '\0'; if (c == EOF) { break; } else if (i == 0) { skip_end_of_line = TRUE; continue; } /* retrieve filter expression */ i = 0; while (1) { c = getc(f); if (c == EOF || c == '@') break; if (i >= filter_exp_len) { /* buffer isn't long enough; double its length.*/ filter_exp_len *= 2; filter_exp = (gchar *)g_realloc(filter_exp, filter_exp_len + 1); } filter_exp[i++] = c; } filter_exp[i] = '\0'; if (c == EOF) { break; } else if (i == 0) { skip_end_of_line = TRUE; continue; } /* retrieve background and foreground colors */ if (fscanf(f,"[%hu,%hu,%hu][%hu,%hu,%hu]", &bg_r, &bg_g, &bg_b, &fg_r, &fg_g, &fg_b) == 6) { /* we got a complete color filter */ color_t bg_color, fg_color; color_filter_t *colorf; dfilter_t *temp_dfilter; if (!dfilter_compile(filter_exp, &temp_dfilter)) { g_warning("Could not compile \"%s\" in colorfilters file.\n%s", name, dfilter_error_msg); prefs.unknown_colorfilters = TRUE; skip_end_of_line = TRUE; continue; } if (!initialize_color(&fg_color, fg_r, fg_g, fg_b)) { /* oops */ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Could not allocate foreground color " "specified in input file for %s.", name); dfilter_free(temp_dfilter); skip_end_of_line = TRUE; continue; } if (!initialize_color(&bg_color, bg_r, bg_g, bg_b)) { /* oops */ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Could not allocate background color " "specified in input file for %s.", name); dfilter_free(temp_dfilter); skip_end_of_line = TRUE; continue; } colorf = color_filter_new(name, filter_exp, &bg_color, &fg_color, disabled); if(user_data == &color_filter_list) { GSList **cfl = (GSList **)user_data; /* internal call */ colorf->c_colorfilter = temp_dfilter; *cfl = g_slist_append(*cfl, colorf); } else { /* external call */ /* just editing, don't need the compiled filter */ dfilter_free(temp_dfilter); color_filter_add_cb (colorf, user_data); } } /* if sscanf */ skip_end_of_line = TRUE; } g_free(name); g_free(filter_exp); return TRUE; }
void pixmap_save_cb(GtkWidget *w, gpointer pixmap_ptr _U_) { GtkWidget *save_as_w; #if GTK_CHECK_VERSION(2,22,0) surface_info_t *surface_info = (surface_info_t *)g_object_get_data(G_OBJECT(w), "surface-info"); #else GdkPixmap *pixmap = (GdkPixmap *)g_object_get_data(G_OBJECT(w), "pixmap"); #endif GdkPixbuf *pixbuf; GdkPixbufFormat *pixbuf_format; GtkWidget *main_vb, *save_as_type_hb, *type_lb, *type_cm; GSList *file_formats,*ffp; GtkWidget *parent; gchar *format_name; guint format_index = 0; guint default_index = 0; gchar *filename, *file_type; GError *error = NULL; gboolean ret; GtkWidget *msg_dialog; #if GTK_CHECK_VERSION(2,22,0) pixbuf = gdk_pixbuf_get_from_surface (surface_info->surface, 0, 0, surface_info->width, surface_info->height); #else pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, NULL, 0, 0, 0, 0, -1, -1); #endif if(!pixbuf) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%sCould not get image from graph%s", simple_dialog_primary_start(), simple_dialog_primary_end()); return; } parent = gtk_widget_get_toplevel(w); save_as_w = file_selection_new("Wireshark: Save Graph As ...", GTK_WINDOW(parent), FILE_SELECTION_SAVE); /* Container for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE); file_selection_set_extra_widget(save_as_w, main_vb); gtk_widget_show(main_vb); save_as_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE); gtk_box_pack_start(GTK_BOX(main_vb), save_as_type_hb, FALSE, FALSE, 0); gtk_widget_show(save_as_type_hb); type_lb = gtk_label_new("File type: "); gtk_box_pack_start(GTK_BOX(save_as_type_hb), type_lb, FALSE, FALSE, 0); gtk_widget_show(type_lb); type_cm = gtk_combo_box_text_new(); gtk_box_pack_start(GTK_BOX(save_as_type_hb), type_cm, FALSE, FALSE, 0); /* List all of the file formats the gdk-pixbuf library supports */ file_formats = gdk_pixbuf_get_formats(); ffp = file_formats; while(ffp) { pixbuf_format = (GdkPixbufFormat *)ffp->data; if (gdk_pixbuf_format_is_writable(pixbuf_format)) { format_name = gdk_pixbuf_format_get_name(pixbuf_format); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(type_cm), format_name); if (!(g_ascii_strcasecmp(format_name, "png"))) default_index = format_index; format_index++; } ffp = g_slist_next(ffp); } g_slist_free(file_formats); gtk_combo_box_set_active(GTK_COMBO_BOX(type_cm), default_index); gtk_widget_show(type_cm); gtk_widget_show(save_as_w); window_present(save_as_w); /* * Loop until the user either selects a file or gives up. */ for (;;) { if (gtk_dialog_run(GTK_DIALOG(save_as_w)) != GTK_RESPONSE_ACCEPT) { /* They clicked "Cancel" or closed the dialog or.... */ window_destroy(save_as_w); return; } filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(save_as_w)); /* Perhaps the user specified a directory instead of a file. Check whether they did. */ if (test_for_directory(filename) == EISDIR) { /* It's a directory - set the file selection box to display that directory, and leave the selection box displayed. */ set_last_open_dir(filename); g_free(filename); file_selection_set_current_folder(save_as_w, get_last_open_dir()); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(save_as_w), ""); continue; } file_type = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(type_cm)); ret = gdk_pixbuf_save(pixbuf, filename, file_type, &error, NULL); g_free(filename); g_free(file_type); if (!ret) { msg_dialog = gtk_message_dialog_new(GTK_WINDOW(save_as_w), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", error->message); gtk_dialog_run(GTK_DIALOG(msg_dialog)); gtk_widget_destroy(msg_dialog); continue; } window_destroy(save_as_w); return; } }
// XXX Copied from ui/gtk/main.c. This should be moved to a common location. static e_prefs * read_configuration_files(char **gdp_path, char **dp_path) { int gpf_open_errno, gpf_read_errno; int cf_open_errno, df_open_errno; int gdp_open_errno, gdp_read_errno; int dp_open_errno, dp_read_errno; char *gpf_path, *pf_path; char *cf_path, *df_path; int pf_open_errno, pf_read_errno; e_prefs *prefs_p; /* Read the preference files. */ prefs_p = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path, &pf_open_errno, &pf_read_errno, &pf_path); if (gpf_path != NULL) { if (gpf_open_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open global preferences file\n\"%s\": %s.", gpf_path, g_strerror(gpf_open_errno)); } if (gpf_read_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "I/O error reading global preferences file\n\"%s\": %s.", gpf_path, g_strerror(gpf_read_errno)); } } if (pf_path != NULL) { if (pf_open_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open your preferences file\n\"%s\": %s.", pf_path, g_strerror(pf_open_errno)); } if (pf_read_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "I/O error reading your preferences file\n\"%s\": %s.", pf_path, g_strerror(pf_read_errno)); } g_free(pf_path); pf_path = NULL; } #ifdef _WIN32 /* if the user wants a console to be always there, well, we should open one for him */ if (prefs_p->gui_console_open == console_open_always) { create_console(); } #endif /* Read the capture filter file. */ read_filter_list(CFILTER_LIST, &cf_path, &cf_open_errno); if (cf_path != NULL) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open your capture filter file\n\"%s\": %s.", cf_path, g_strerror(cf_open_errno)); g_free(cf_path); } /* Read the display filter file. */ read_filter_list(DFILTER_LIST, &df_path, &df_open_errno); if (df_path != NULL) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open your display filter file\n\"%s\": %s.", df_path, g_strerror(df_open_errno)); g_free(df_path); } /* Read the disabled protocols file. */ read_disabled_protos_list(gdp_path, &gdp_open_errno, &gdp_read_errno, dp_path, &dp_open_errno, &dp_read_errno); if (*gdp_path != NULL) { if (gdp_open_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open global disabled protocols file\n\"%s\": %s.", *gdp_path, g_strerror(gdp_open_errno)); } if (gdp_read_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "I/O error reading global disabled protocols file\n\"%s\": %s.", *gdp_path, g_strerror(gdp_read_errno)); } g_free(*gdp_path); *gdp_path = NULL; } if (*dp_path != NULL) { if (dp_open_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open your disabled protocols file\n\"%s\": %s.", *dp_path, g_strerror(dp_open_errno)); } if (dp_read_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "I/O error reading your disabled protocols file\n\"%s\": %s.", *dp_path, g_strerror(dp_read_errno)); } g_free(*dp_path); *dp_path = NULL; } return prefs_p; }
/* open/merge the dnd file */ void dnd_open_file_cmd(gchar *cf_names_freeme) { int err; gchar *cf_name; int in_files; GString *dialog_text; int files_work; char **in_filenames; /* DND_TARGET_URL on Win32: * The cf_name_freeme is a single string, containing one or more URI's, * seperated by CR/NL chars. The length of the whole field can be found * in the selection_data->length field. If it contains one file, simply open it, * If it contains more than one file, ask to merge these files. */ /* count the number of input files */ cf_name = cf_names_freeme; for(in_files = 0; (cf_name = strstr(cf_name, "\r\n")) != NULL; ) { cf_name += 2; in_files++; } in_filenames = g_malloc(sizeof(char*) * in_files); /* store the starts of the file entries in a gchar array */ cf_name = cf_names_freeme; in_filenames[0] = cf_name; for(files_work = 1; (cf_name = strstr(cf_name, "\r\n")) != NULL && files_work < in_files; ) { cf_name += 2; in_filenames[files_work] = cf_name; files_work++; } /* replace trailing CR NL simply with zeroes (in place), so we get valid terminated strings */ cf_name = cf_names_freeme; g_strdelimit(cf_name, "\r\n", '\0'); /* convert all filenames from URI to local filename (in place) */ for(files_work = 0; files_work < in_files; files_work++) { in_filenames[files_work] = dnd_uri2filename(in_filenames[files_work]); } switch(in_files) { case(0): /* shouldn't happen */ break; case(1): /* open and read the capture file (this will close an existing file) */ if (cf_open(&cfile, in_filenames[0], FALSE, &err) == CF_OK) { /* XXX - add this to the menu if the read fails? */ cf_read(&cfile, FALSE); add_menu_recent_capture_file(in_filenames[0]); } else { /* the capture file couldn't be read (doesn't exist, file format unknown, ...) */ } break; default: /* build and show the info dialog */ dialog_text = g_string_sized_new(200); g_string_printf(dialog_text, "%sMerging the following files:%s\n\n", simple_dialog_primary_start(), simple_dialog_primary_end()); for(files_work = 0; files_work < in_files; files_work++) { g_string_append(dialog_text, in_filenames[files_work]); g_string_append(dialog_text, "\n"); } g_string_append(dialog_text, "\nThe packets in these files will be merged chronologically into a new temporary file."); simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTN_OK, "%s", dialog_text->str); g_string_free(dialog_text, TRUE); /* actually merge the files now */ dnd_merge_files(in_files, in_filenames); } g_free(in_filenames); g_free(cf_names_freeme); }
void PreferencesDialog::on_buttonBox_accepted() { gchar* err = NULL; unsigned int redissect_flags = 0; // XXX - We should validate preferences as the user changes them, not here. // XXX - We're also too enthusiastic about setting must_redissect. prefs_modules_foreach_submodules(NULL, module_prefs_unstash, (gpointer)&redissect_flags); if (redissect_flags & PREF_EFFECT_GUI_LAYOUT) { // Layout type changed, reset sizes recent.gui_geometry_main_upper_pane = 0; recent.gui_geometry_main_lower_pane = 0; } pd_ui_->columnFrame->unstash(); pd_ui_->filterExpressonsFrame->acceptChanges(); pd_ui_->expertFrame->acceptChanges(); //Filter expressions don't affect dissection, so there is no need to //send any events to that effect. However, the app needs to know //about any button changes. wsApp->emitAppSignal(WiresharkApplication::FilterExpressionsChanged); prefs_main_write(); if (save_decode_as_entries(&err) < 0) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err); g_free(err); } write_language_prefs(); wsApp->loadLanguage(QString(language)); #ifdef HAVE_AIRPCAP /* * Load the Wireshark decryption keys (just set) and save * the changes to the adapters' registry */ //airpcap_load_decryption_keys(airpcap_if_list); #endif // gtk/prefs_dlg.c:prefs_main_apply_all /* * Apply the protocol preferences first - "gui_prefs_apply()" could * cause redissection, and we have to make sure the protocol * preference changes have been fully applied. */ prefs_apply_all(); /* Fill in capture options with values from the preferences */ prefs_to_capture_opts(); #ifdef HAVE_AIRPCAP // prefs_airpcap_update(); #endif wsApp->setMonospaceFont(prefs.gui_qt_font_name); if (redissect_flags & PREF_EFFECT_DISSECTION) { /* Redissect all the packets, and re-evaluate the display filter. */ wsApp->queueAppSignal(WiresharkApplication::PacketDissectionChanged); } wsApp->queueAppSignal(WiresharkApplication::PreferencesChanged); if (redissect_flags & PREF_EFFECT_GUI_LAYOUT) { wsApp->queueAppSignal(WiresharkApplication::RecentPreferencesRead); } if (prefs.capture_no_extcap != saved_capture_no_extcap_) wsApp->refreshLocalInterfaces(); }
static void sctp_graph_draw(struct sctp_udata *u_data) { int length, lwidth; guint32 distance=5, i, e, sec, w, start, a, j, b; gint label_width, label_height; char label_string[15]; gfloat dis; gboolean write_label = FALSE; PangoLayout *layout; GtkAllocation widget_alloc; cairo_t *cr; if (u_data->io->x1_tmp_sec == 0 && u_data->io->x1_tmp_usec == 0) u_data->io->offset = 0; else u_data->io->offset = 5; if (u_data->io->x2_tmp_sec - u_data->io->x1_tmp_sec > 1500) { u_data->io->min_x=u_data->io->x1_tmp_sec; u_data->io->max_x=u_data->io->x2_tmp_sec; u_data->io->uoff = TRUE; } else { u_data->io->min_x=((guint32) (u_data->io->x1_tmp_sec*1000000.0))+u_data->io->x1_tmp_usec; u_data->io->max_x=((guint32) (u_data->io->x2_tmp_sec*1000000.0))+u_data->io->x2_tmp_usec; u_data->io->uoff = FALSE; } u_data->io->tmp_width = u_data->io->max_x - u_data->io->min_x; if (u_data->dir == 1) { if (u_data->io->tmp == FALSE) { if (u_data->assoc->sort_tsn1 != NULL) u_data->io->max_y = u_data->io->tmp_max_tsn1 - u_data->io->tmp_min_tsn1; else u_data->io->max_y = 0; u_data->io->min_y = 0; } else { u_data->io->max_y = u_data->io->tmp_max_tsn1; u_data->io->min_y = u_data->io->tmp_min_tsn1; } } else if (u_data->dir == 2) { if (u_data->io->tmp == FALSE) { if (u_data->assoc->tsn2 != NULL) u_data->io->max_y = u_data->io->tmp_max_tsn2 - u_data->io->tmp_min_tsn2; else u_data->io->max_y = 0; u_data->io->min_y = 0; } else { u_data->io->max_y = u_data->io->tmp_max_tsn2; u_data->io->min_y = u_data->io->tmp_min_tsn2; } } #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_set_source_rgb (cr, 1, 1, 1); gtk_widget_get_allocation(u_data->io->draw_area, &widget_alloc); cairo_rectangle (cr, 0, 0, widget_alloc.width, widget_alloc.height); cairo_fill (cr); cairo_destroy (cr); /* x_axis */ #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_set_line_width (cr, 1.0); cairo_move_to(cr, LEFT_BORDER+u_data->io->offset+0.5, u_data->io->surface_height - BOTTOM_BORDER+0.5); cairo_line_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset+0.5, u_data->io->surface_height - BOTTOM_BORDER+0.5); cairo_move_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset+0.5, u_data->io->surface_height - BOTTOM_BORDER+0.5); cairo_line_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset - 5+0.5, u_data->io->surface_height - BOTTOM_BORDER - 5+0.5); cairo_move_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset + 0.5, u_data->io->surface_height - BOTTOM_BORDER + 0.5); cairo_line_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset - 5.5, u_data->io->surface_height - BOTTOM_BORDER + 5.5); cairo_stroke(cr); cairo_destroy(cr); u_data->io->axis_width = u_data->io->surface_width - LEFT_BORDER - RIGHT_BORDER - u_data->io->offset; if(u_data->io->tmp_width>0){ u_data->io->x_interval = (float)((u_data->io->axis_width*1.0)/u_data->io->tmp_width); /*distance in pixels between 2 data points*/ } else { u_data->io->x_interval = (float)(u_data->io->axis_width); } e=0; if (u_data->io->x_interval < 1) { dis = 1 / u_data->io->x_interval; while (dis >1) { dis /= 10; e++; } distance = 1; for (i=0; i<=e+1; i++) distance *= 10; } else distance = 5; g_snprintf(label_string, sizeof(label_string), "%d", 0); memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15); layout = gtk_widget_create_pango_layout(u_data->io->draw_area, label_string); pango_layout_get_pixel_size(layout, &label_width, &label_height); if (u_data->io->x1_tmp_usec == 0) sec = u_data->io->x1_tmp_sec; else sec = u_data->io->x1_tmp_sec+1; if (u_data->io->offset != 0) { g_snprintf(label_string, sizeof(label_string), "%u", u_data->io->x1_tmp_sec); memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_move_to (cr, LEFT_BORDER - 25, u_data->io->surface_height - BOTTOM_BORDER + 20); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); cr = NULL; } w = (guint32)(500 / (guint32)(distance * u_data->io->x_interval)); if (w == 0) w = 1; if (w == 4 || w==3 || w==2) { w = 5; a = distance / 10; b = (guint32)((u_data->io->min_x/100000))%10; /* start for labels*/ } else { a = distance / 5; b = 0; } if (!u_data->io->uoff) { if (a>=1000000) { start=u_data->io->min_x/1000000*1000000; if (a==1000000) b = 0; } else { start=u_data->io->min_x/100000; if (start%2!=0) start--; start*=100000; b = (guint32)((start/100000))%10; } } else { start = u_data->io->min_x; if (start%2!=0) start--; b = 0; } for (i=start, j=b; i<=u_data->io->max_x; i+=a, j++) { if (!u_data->io->uoff) if (i >= u_data->io->min_x && i % 1000000 != 0) { length = 5; g_snprintf(label_string, sizeof(label_string), "%d", i%1000000); if (j % w == 0) { length = 10; memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_move_to (cr, LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval - lwidth / 2, u_data->io->surface_height - BOTTOM_BORDER + 10); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); cr = NULL; } #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_set_line_width (cr, 1.0); cairo_move_to(cr, LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval + 0.5, u_data->io->surface_height - BOTTOM_BORDER + 0.5); cairo_line_to(cr, LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval + 0.5, u_data->io->surface_height - BOTTOM_BORDER + length + 0.5); cairo_stroke(cr); cairo_destroy(cr); } if (!u_data->io->uoff) { if (i%1000000==0 && j%w==0) { sec=i/1000000; write_label = TRUE; } } else { if (j%w == 0) { sec = i; write_label = TRUE; } } if (write_label) { #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_set_line_width (cr, 1.0); cairo_move_to(cr, LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval + 0.5, u_data->io->surface_height - BOTTOM_BORDER + 0.5); cairo_line_to(cr, LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval + 0.5, u_data->io->surface_height - BOTTOM_BORDER + 10 + 0.5); cairo_stroke(cr); cairo_destroy(cr); g_snprintf(label_string, sizeof(label_string), "%d", sec); memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_move_to (cr, (LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval-10), u_data->io->surface_height - BOTTOM_BORDER + 20); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); cr = NULL; write_label = FALSE; } } g_strlcpy(label_string, "sec", sizeof(label_string)); memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_move_to (cr, u_data->io->surface_width - RIGHT_BORDER - 10, u_data->io->surface_height - BOTTOM_BORDER + 30); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); cr = NULL; distance = 5; /* y-axis */ #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_set_line_width (cr, 1.0); cairo_move_to(cr, LEFT_BORDER + 0.5, TOP_BORDER - u_data->io->offset + 0.5); cairo_line_to(cr, LEFT_BORDER + 0.5, u_data->io->surface_height - BOTTOM_BORDER - u_data->io->offset + 0.5); cairo_move_to(cr, LEFT_BORDER + 0.5, TOP_BORDER - u_data->io->offset + 0.5); cairo_line_to(cr, LEFT_BORDER - 5 + 0.5, TOP_BORDER - u_data->io->offset + 5 + 0.5); cairo_move_to(cr, LEFT_BORDER + 0.5, TOP_BORDER - u_data->io->offset + 0.5); cairo_line_to(cr, LEFT_BORDER +5 + 0.5, TOP_BORDER - u_data->io->offset + 5 + 0.5); cairo_stroke(cr); cairo_destroy(cr); u_data->io->y_interval = (float)(((u_data->io->surface_height - TOP_BORDER - BOTTOM_BORDER) * 1.0)/(u_data->io->max_y - u_data->io->min_y)); e = 0; if (u_data->io->y_interval < 1) { dis = 1 / u_data->io->y_interval; while (dis > 1) { dis /= 10; e++; } distance = 1; for (i=0; i<=e; i++) distance = distance * 10; } else if (u_data->io->y_interval<2) distance = 10; if (u_data->io->max_y > 0) { for (i=u_data->io->min_y/distance*distance; i<=u_data->io->max_y; i+=distance/5) { if (i >= u_data->io->min_y) { length = 5; g_snprintf(label_string, sizeof(label_string), "%d", i); if (i%distance == 0 || (distance <= 5 && u_data->io->y_interval > 10)) { length = 10; memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string)); pango_layout_set_text(layout, label_string, -1); pango_layout_get_pixel_size(layout, &lwidth, NULL); #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_move_to (cr, LEFT_BORDER - length - lwidth - 5, u_data->io->surface_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval - 3); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); cr = NULL; } #if GTK_CHECK_VERSION(2,22,0) cr = cairo_create (u_data->io->surface); #else cr = gdk_cairo_create (u_data->io->pixmap); #endif cairo_set_line_width (cr, 1.0); cairo_move_to(cr, LEFT_BORDER - length + 0.5, u_data->io->surface_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval + 0.5); cairo_line_to(cr, LEFT_BORDER + 0.5, u_data->io->surface_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval + 0.5); cairo_stroke(cr); cairo_destroy(cr); } } } else simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, "No Data Chunks sent"); g_object_unref(G_OBJECT(layout)); }
void WiresharkApplication::setConfigurationProfile(const gchar *profile_name) { char *gdp_path, *dp_path; char *rf_path; int rf_open_errno; /* First check if profile exists */ if (!profile_exists(profile_name, FALSE)) { if (profile_exists(profile_name, TRUE)) { char *pf_dir_path, *pf_dir_path2, *pf_filename; /* Copy from global profile */ if (create_persconffile_profile(profile_name, &pf_dir_path) == -1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't create directory\n\"%s\":\n%s.", pf_dir_path, g_strerror(errno)); g_free(pf_dir_path); } if (copy_persconffile_profile(profile_name, profile_name, TRUE, &pf_filename, &pf_dir_path, &pf_dir_path2) == -1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't copy file \"%s\" in directory\n\"%s\" to\n\"%s\":\n%s.", pf_filename, pf_dir_path2, pf_dir_path, g_strerror(errno)); g_free(pf_filename); g_free(pf_dir_path); g_free(pf_dir_path2); } } else { /* No personal and no global profile exists */ return; } } /* Then check if changing to another profile */ if (profile_name && strcmp (profile_name, get_profile_name()) == 0) { return; } /* Get the current geometry, before writing it to disk */ emit profileChanging(); if (profile_exists(get_profile_name(), FALSE)) { /* Write recent file for profile we are leaving, if it still exists */ write_profile_recent(); } /* Set profile name and update the status bar */ set_profile_name (profile_name); emit profileNameChanged(profile_name); /* Apply new preferences */ readConfigurationFiles (&gdp_path, &dp_path, true); if (!recent_read_profile_static(&rf_path, &rf_open_errno)) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open common recent file\n\"%s\": %s.", rf_path, g_strerror(rf_open_errno)); g_free(rf_path); } if (recent.gui_fileopen_remembered_dir && test_for_directory(recent.gui_fileopen_remembered_dir) == EISDIR) { set_last_open_dir(recent.gui_fileopen_remembered_dir); } timestamp_set_type (recent.gui_time_format); timestamp_set_precision(recent.gui_time_precision); timestamp_set_seconds_type (recent.gui_seconds_format); color_filters_enable(recent.packet_list_colorize); tap_update_timer_.setInterval(prefs.tap_update_interval); prefs_to_capture_opts(); prefs_apply_all(); #ifdef HAVE_LIBPCAP update_local_interfaces(); #endif setMonospaceFont(prefs.gui_qt_font_name); emit columnsChanged(); emit preferencesChanged(); emit recentFilesRead(); emit filterExpressionsChanged(); emit checkDisplayFilter(); /* Enable all protocols and disable from the disabled list */ proto_enable_all(); if (gdp_path == NULL && dp_path == NULL) { set_disabled_protos_list(); set_disabled_heur_dissector_list(); } /* Reload color filters */ color_filters_reload(); emit localInterfaceListChanged(); emit packetDissectionChanged(); }
/* capture child closed its side of the pipe, do the required cleanup */ void capture_input_closed(capture_options *capture_opts, gchar *msg) { int err; int packet_count_save; g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture stopped!"); g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING); if (msg != NULL) simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", msg); if(capture_opts->state == CAPTURE_PREPARING) { /* We didn't start a capture; note that the attempt to start it failed. */ capture_callback_invoke(capture_cb_capture_failed, capture_opts); } else { /* We started a capture; process what's left of the capture file if we were in "update list of packets in real time" mode, or process all of it if we weren't. */ if(capture_opts->real_time_mode) { cf_read_status_t status; /* Read what remains of the capture file. */ status = cf_finish_tail(capture_opts->cf, &err); /* XXX: If -Q (quit-after-cap) then cf->count clr'd below so save it first */ packet_count_save = cf_get_packet_count(capture_opts->cf); /* Tell the GUI we are not doing a capture any more. Must be done after the cf_finish_tail(), so file lengths are correctly displayed */ capture_callback_invoke(capture_cb_capture_update_finished, capture_opts); /* Finish the capture. */ switch (status) { case CF_READ_OK: if ((packet_count_save == 0) && !capture_opts->restart) { simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, "%sNo packets captured!%s\n" "\n" "As no data was captured, closing the %scapture file!\n" "\n" "\n" "Help about capturing can be found at:\n" "\n" " http://wiki.wireshark.org/CaptureSetup" #ifdef _WIN32 "\n\n" "Wireless (Wi-Fi/WLAN):\n" "Try to switch off promiscuous mode in the Capture Options!" #endif "", simple_dialog_primary_start(), simple_dialog_primary_end(), cf_is_tempfile(capture_opts->cf) ? "temporary " : ""); cf_close(capture_opts->cf); } break; case CF_READ_ERROR: /* Just because we got an error, that doesn't mean we were unable to read any of the file; we handle what we could get from the file. */ break; case CF_READ_ABORTED: /* Exit by leaving the main loop, so that any quit functions we registered get called. */ main_window_quit(); break; } } else { /* first of all, we are not doing a capture any more */ capture_callback_invoke(capture_cb_capture_fixed_finished, capture_opts); /* this is a normal mode capture and if no error happened, read in the capture file data */ if(capture_opts->save_file != NULL) { capture_input_read_all(capture_opts, cf_is_tempfile(capture_opts->cf), cf_get_drops_known(capture_opts->cf), cf_get_drops(capture_opts->cf)); } } } if(capture_opts->show_info) capture_info_close(); capture_opts->state = CAPTURE_STOPPED; /* if we couldn't open a capture file, there's nothing more for us to do */ if(capture_opts->save_file == NULL) { cf_close(capture_opts->cf); return; } /* does the user wants to restart the current capture? */ if(capture_opts->restart) { capture_opts->restart = FALSE; ws_unlink(capture_opts->save_file); /* if it was a tempfile, throw away the old filename (so it will become a tempfile again) */ if(cf_is_tempfile(capture_opts->cf)) { g_free(capture_opts->save_file); capture_opts->save_file = NULL; } /* ... and start the capture again */ if (capture_opts->ifaces->len == 0) { collect_ifaces(capture_opts); } /* close the currently loaded capture file */ cf_close(capture_opts->cf); capture_start(capture_opts); } else { /* We're not doing a capture any more, so we don't have a save file. */ g_free(capture_opts->save_file); capture_opts->save_file = NULL; } }
/* * Alert box for a failed attempt to open or create a file. * "err" is assumed to be a UNIX-style errno; "for_writing" is TRUE if * the file is being opened for writing and FALSE if it's being opened * for reading. * * XXX - add explanatory secondary text for at least some of the errors; * various HIGs suggest that you should, for example, suggest that the * user remove files if the file system is full. Perhaps that's because * they're providing guidelines for people less sophisticated than the * typical Wireshark user is, but.... */ void open_failure_alert_box(const char *filename, int err, gboolean for_writing) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, file_open_error_message(err, for_writing), filename); }
/* Attempt to Write out profile "recent" to the user's profile recent file. If we got an error report it with a dialog box and return FALSE, otherwise return TRUE. */ gboolean write_profile_recent(void) { char *pf_dir_path; char *rf_path; FILE *rf; /* To do: * - Split output lines longer than MAX_VAL_LEN * - Create a function for the preference directory check/creation * so that duplication can be avoided with filter.c */ /* Create the directory that holds personal configuration files, if necessary. */ if (create_persconffile_dir(&pf_dir_path) == -1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't create directory\n\"%s\"\nfor recent file: %s.", pf_dir_path, g_strerror(errno)); g_free(pf_dir_path); return FALSE; } rf_path = get_persconffile_path(RECENT_FILE_NAME, TRUE, TRUE); if ((rf = ws_fopen(rf_path, "w")) == NULL) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Can't open recent file\n\"%s\": %s.", rf_path, g_strerror(errno)); g_free(rf_path); return FALSE; } g_free(rf_path); fputs("# Recent settings file for Wireshark " VERSION ".\n" "#\n" "# This file is regenerated each time Wireshark is quit\n" "# and when changing configuration profile.\n" "# So be careful, if you want to make manual changes here.\n" "\n", rf); fprintf(rf, "\n# Main Toolbar show (hide).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_MAIN_TOOLBAR_SHOW ": %s\n", recent.main_toolbar_show == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Filter Toolbar show (hide).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_FILTER_TOOLBAR_SHOW ": %s\n", recent.filter_toolbar_show == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Wireless Settings Toolbar show (hide).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_WIRELESS_TOOLBAR_SHOW ": %s\n", recent.wireless_toolbar_show == TRUE ? "TRUE" : "FALSE"); #ifdef HAVE_AIRPCAP fprintf(rf, "\n# Show (hide) old AirPcap driver warning dialog box.\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_DRIVER_CHECK_SHOW ": %s\n", recent.airpcap_driver_check_show == TRUE ? "TRUE" : "FALSE"); #endif fprintf(rf, "\n# Packet list show (hide).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_PACKET_LIST_SHOW ": %s\n", recent.packet_list_show == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Tree view show (hide).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_TREE_VIEW_SHOW ": %s\n", recent.tree_view_show == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Byte view show (hide).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_BYTE_VIEW_SHOW ": %s\n", recent.byte_view_show == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Statusbar show (hide).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_STATUSBAR_SHOW ": %s\n", recent.statusbar_show == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Packet list colorize (hide).\n"); fprintf(rf, "# TRUE or FALSE (case-insensitive).\n"); fprintf(rf, RECENT_KEY_PACKET_LIST_COLORIZE ": %s\n", recent.packet_list_colorize == TRUE ? "TRUE" : "FALSE"); fprintf(rf, "\n# Timestamp display format.\n"); fprintf(rf, "# One of: RELATIVE, ABSOLUTE, ABSOLUTE_WITH_DATE, DELTA, DELTA_DIS, EPOCH, UTC, UTC_WITH_DATE\n"); fprintf(rf, RECENT_GUI_TIME_FORMAT ": %s\n", ts_type_text[recent.gui_time_format]); fprintf(rf, "\n# Timestamp display precision.\n"); fprintf(rf, "# One of: AUTO, SEC, DSEC, CSEC, MSEC, USEC, NSEC\n"); fprintf(rf, RECENT_GUI_TIME_PRECISION ": %s\n", ts_precision_text[recent.gui_time_precision]); fprintf(rf, "\n# Seconds display format.\n"); fprintf(rf, "# One of: SECONDS, HOUR_MIN_SEC\n"); fprintf(rf, RECENT_GUI_SECONDS_FORMAT ": %s\n", ts_seconds_text[recent.gui_seconds_format]); fprintf(rf, "\n# Zoom level.\n"); fprintf(rf, "# A decimal number.\n"); fprintf(rf, RECENT_GUI_ZOOM_LEVEL ": %d\n", recent.gui_zoom_level); fprintf(rf, "\n# Bytes view.\n"); fprintf(rf, "# A decimal number.\n"); fprintf(rf, RECENT_GUI_BYTES_VIEW ": %d\n", recent.gui_bytes_view); fprintf(rf, "\n# Main window upper (or leftmost) pane size.\n"); fprintf(rf, "# Decimal number.\n"); if (recent.gui_geometry_main_upper_pane != 0) { fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_UPPER_PANE ": %d\n", recent.gui_geometry_main_upper_pane); } fprintf(rf, "\n# Main window middle pane size.\n"); fprintf(rf, "# Decimal number.\n"); if (recent.gui_geometry_main_lower_pane != 0) { fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_LOWER_PANE ": %d\n", recent.gui_geometry_main_lower_pane); } fprintf(rf, "\n# Packet list column pixel widths.\n"); fprintf(rf, "# Each pair of strings consists of a column format and its pixel width.\n"); new_packet_list_recent_write_all(rf); if (get_last_open_dir() != NULL) { fprintf(rf, "\n# Last directory navigated to in File Open dialog.\n"); if(u3_active()) fprintf(rf, RECENT_GUI_FILEOPEN_REMEMBERED_DIR ": %s\n", u3_contract_device_path(get_last_open_dir())); else fprintf(rf, RECENT_GUI_FILEOPEN_REMEMBERED_DIR ": %s\n", get_last_open_dir()); } fclose(rf); /* XXX - catch I/O errors (e.g. "ran out of disk space") and return an error indication, or maybe write to a new recent file and rename that file on top of the old one only if there are not I/O errors. */ return TRUE; }
/* And now our feature presentation... [ fade to music ] */ int main(int argc, char *argv[]) { WiresharkApplication a(argc, argv); MainWindow *w; char *init_progfile_dir_error; char *s; int opt; gboolean arg_error = FALSE; extern int info_update_freq; /* Found in about_dlg.c. */ const gchar *filter; #ifdef _WIN32 WSADATA wsaData; #endif /* _WIN32 */ char *rf_path; int rf_open_errno; char *gdp_path, *dp_path; int err; #ifdef HAVE_LIBPCAP gboolean start_capture = FALSE; gboolean list_link_layer_types = FALSE; GList *if_list; gchar *err_str; #else gboolean capture_option_specified = FALSE; #ifdef _WIN32 #ifdef HAVE_AIRPCAP gchar *err_str; #endif #endif #endif gint pl_size = 280, tv_size = 95, bv_size = 75; gchar *rc_file, *cf_name = NULL, *rfilter = NULL, *jfilter = NULL; dfilter_t *rfcode = NULL; gboolean rfilter_parse_failed = FALSE; e_prefs *prefs_p; char badopt; //GtkWidget *splash_win = NULL; GLogLevelFlags log_flags; guint go_to_packet = 0; gboolean jump_backwards = FALSE; dfilter_t *jump_to_filter = NULL; int optind_initial; int status; //initialize language ! QString locale = QLocale::system().name(); g_log(NULL, G_LOG_LEVEL_DEBUG, "Translator %s", locale.toStdString().c_str()); QTranslator translator; translator.load(QString(":/i18n/qtshark_") + locale); a.installTranslator(&translator); // Hopefully we won't have to use QString::fromUtf8() in as many places. QTextCodec *utf8codec = QTextCodec::codecForName("UTF-8"); QTextCodec::setCodecForCStrings(utf8codec); QTextCodec::setCodecForTr(utf8codec); #ifdef HAVE_LIBPCAP #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) #define OPTSTRING_B "B:" #else #define OPTSTRING_B "" #endif /* _WIN32 or HAVE_PCAP_CREATE */ #else /* HAVE_LIBPCAP */ #define OPTSTRING_B "" #endif /* HAVE_LIBPCAP */ #ifdef HAVE_PCAP_CREATE #define OPTSTRING_I "I" #else #define OPTSTRING_I "" #endif #define OPTSTRING "a:b:" OPTSTRING_B "c:C:Df:g:Hhi:" OPTSTRING_I "jJ:kK:lLm:nN:o:P:pQr:R:Ss:t:u:vw:X:y:z:" static const char optstring[] = OPTSTRING; /* * Get credential information for later use, and drop privileges * before doing anything else. * Let the user know if anything happened. */ init_process_policies(); relinquish_special_privs_perm(); /* * Attempt to get the pathname of the executable file. */ init_progfile_dir_error = init_progfile_dir(argv[0], main); g_log(NULL, G_LOG_LEVEL_DEBUG, "progfile_dir: %s", get_progfile_dir()); /* initialize the funnel mini-api */ // xxx qtshark //initialize_funnel_ops(); AirPDcapInitContext(&airpdcap_ctx); // xxx qtshark #ifdef _WIN32 /* Load wpcap if possible. Do this before collecting the run-time version information */ load_wpcap(); /* ... and also load the packet.dll from wpcap */ wpcap_packet_load(); #ifdef HAVE_AIRPCAP /* Load the airpcap.dll. This must also be done before collecting * run-time version information. */ airpcap_dll_ret_val = load_airpcap(); switch (airpcap_dll_ret_val) { case AIRPCAP_DLL_OK: /* load the airpcap interfaces */ airpcap_if_list = get_airpcap_interface_list(&err, &err_str); if (airpcap_if_list == NULL || g_list_length(airpcap_if_list) == 0){ if (err == CANT_GET_AIRPCAP_INTERFACE_LIST && err_str != NULL) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", "Failed to open Airpcap Adapters!"); g_free(err_str); } airpcap_if_active = NULL; } else { /* select the first ad default (THIS SHOULD BE CHANGED) */ airpcap_if_active = airpcap_get_default_if(airpcap_if_list); } break; #if 0 /* * XXX - Maybe we need to warn the user if one of the following happens??? */ case AIRPCAP_DLL_OLD: simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DLL_OLD\n"); break; case AIRPCAP_DLL_ERROR: simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DLL_ERROR\n"); break; case AIRPCAP_DLL_NOT_FOUND: simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DDL_NOT_FOUND\n"); break; #endif } #endif /* HAVE_AIRPCAP */ /* Start windows sockets */ WSAStartup( MAKEWORD( 1, 1 ), &wsaData ); #endif /* _WIN32 */ profile_store_persconffiles (TRUE); /* Assemble the compile-time version information string */ comp_info_str = g_string_new("Compiled "); // xxx qtshark get_compiled_version_info(comp_info_str, get_qt_compiled_info, get_gui_compiled_info); /* Assemble the run-time version information string */ runtime_info_str = g_string_new("Running "); // xxx qtshark get_runtime_version_info(runtime_info_str, get_gui_runtime_info); /* Read the profile independent recent file. We have to do this here so we can */ /* set the profile before it can be set from the command line parameterts */ // xxx qtshark //recent_read_static(&rf_path, &rf_open_errno); //if (rf_path != NULL && rf_open_errno != 0) { // simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, // "Could not open common recent file\n\"%s\": %s.", // rf_path, strerror(rf_open_errno)); //} /* "pre-scan" the command line parameters, if we have "console only" parameters. We do this so we don't start GTK+ if we're only showing command-line help or version information. XXX - this pre-scan is done before we start GTK+, so we haven't run gtk_init() on the arguments. That means that GTK+ arguments have not been removed from the argument list; those arguments begin with "--", and will be treated as an error by getopt(). We thus ignore errors - *and* set "opterr" to 0 to suppress the error messages. */ opterr = 0; optind_initial = optind; while ((opt = getopt(argc, argv, optstring)) != -1) { switch (opt) { case 'C': /* Configuration Profile */ if (profile_exists (optarg, FALSE)) { set_profile_name (optarg); } else { cmdarg_err("Configuration Profile \"%s\" does not exist", optarg); exit(1); } break; case 'D': /* Print a list of capture devices and exit */ #ifdef HAVE_LIBPCAP if_list = capture_interface_list(&err, &err_str); if (if_list == NULL) { switch (err) { case CANT_GET_INTERFACE_LIST: cmdarg_err("%s", err_str); g_free(err_str); break; case NO_INTERFACES_FOUND: cmdarg_err("There are no interfaces on which a capture can be done"); break; } exit(2); } capture_opts_print_interfaces(if_list); free_interface_list(if_list); exit(0); #else capture_option_specified = TRUE; arg_error = TRUE; #endif break; case 'h': /* Print help and exit */ print_usage(TRUE); exit(0); break; #ifdef _WIN32 case 'i': if (strcmp(optarg, "-") == 0) stdin_capture = TRUE; break; #endif case 'P': /* Path settings - change these before the Preferences and alike are processed */ status = filesystem_opt(opt, optarg); if(status != 0) { cmdarg_err("-P flag \"%s\" failed (hint: is it quoted and existing?)", optarg); exit(status); } break; case 'v': /* Show version and exit */ show_version(); exit(0); break; case 'X': /* * Extension command line options have to be processed before * we call epan_init() as they are supposed to be used by dissectors * or taps very early in the registration process. */ ex_opt_add(optarg); break; case '?': /* Ignore errors - the "real" scan will catch them. */ break; } } cf_callback_add(main_cf_callback, NULL); /* Arrange that if we have no console window, and a GLib message logging routine is called to log a message, we pop up a console window. We do that by inserting our own handler for all messages logged to the default domain; that handler pops up a console if necessary, and then calls the default handler. */ /* We might want to have component specific log levels later ... */ log_flags = (GLogLevelFlags) ( G_LOG_LEVEL_ERROR| G_LOG_LEVEL_CRITICAL| G_LOG_LEVEL_WARNING| G_LOG_LEVEL_MESSAGE| G_LOG_LEVEL_INFO| G_LOG_LEVEL_DEBUG| G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION ); g_log_set_handler(NULL, log_flags, console_log_handler, NULL /* user_data */); g_log_set_handler(LOG_DOMAIN_MAIN, log_flags, console_log_handler, NULL /* user_data */); #ifdef HAVE_LIBPCAP g_log_set_handler(LOG_DOMAIN_CAPTURE, log_flags, console_log_handler, NULL /* user_data */); g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD, log_flags, console_log_handler, NULL /* user_data */); /* Set the initial values in the capture options. This might be overwritten by preference settings and then again by the command line parameters. */ capture_opts_init(&global_capture_opts, &cfile); #endif /* Register all dissectors; we must do this before checking for the "-G" flag, as the "-G" flag dumps information registered by the dissectors, and we must do it before we read the preferences, in case any dissectors register preferences. */ epan_init(register_all_protocols,register_all_protocol_handoffs, NULL, NULL, // splash_update, (gpointer) splash_win, failure_alert_box,open_failure_alert_box,read_failure_alert_box, write_failure_alert_box ); // splash_update(RA_LISTENERS, NULL, (gpointer)splash_win); /* Register all tap listeners; we do this before we parse the arguments, as the "-z" argument can specify a registered tap. */ /* we register the plugin taps before the other taps because stats_tree taps plugins will be registered as tap listeners by stats_tree_stat.c and need to registered before that */ g_log(NULL, G_LOG_LEVEL_DEBUG, "plugin_dir: %s", get_plugin_dir()); #ifdef HAVE_PLUGINS register_all_plugin_tap_listeners(); #endif // register_all_tap_listeners(); // splash_update(RA_PREFERENCES, NULL, (gpointer)splash_win); prefs_p = read_configuration_files (&gdp_path, &dp_path); /* Removed thread code: * http://anonsvn.wireshark.org/viewvc/viewvc.cgi?view=rev&revision=35027 */ g_log(NULL, G_LOG_LEVEL_DEBUG, "FIX: timestamp types should be set elsewhere"); timestamp_set_type(TS_RELATIVE); timestamp_set_precision(TS_PREC_AUTO_USEC); timestamp_set_seconds_type(TS_SECONDS_DEFAULT); ///////// build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE); font_init(); //////// /* Read the dynamic part of the recent file, as we have the gui now ready for it. */ recent_read_dynamic(&rf_path, &rf_open_errno); if (rf_path != NULL && rf_open_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open recent file\n\"%s\": %s.", rf_path, g_strerror(rf_open_errno)); } color_filters_enable(recent.packet_list_colorize); g_log(NULL, G_LOG_LEVEL_DEBUG, "FIX: fetch recent color settings"); color_filters_enable(TRUE); //////// switch (user_font_apply()) { case FA_SUCCESS: break; case FA_FONT_NOT_RESIZEABLE: /* "user_font_apply()" popped up an alert box. */ /* turn off zooming - font can't be resized */ case FA_FONT_NOT_AVAILABLE: /* XXX - did we successfully load the un-zoomed version earlier? If so, this *probably* means the font is available, but not at this particular zoom level, but perhaps some other failure occurred; I'm not sure you can determine which is the case, however. */ /* turn off zooming - zoom level is unavailable */ default: /* in any other case than FA_SUCCESS, turn off zooming */ // recent.gui_zoom_level = 0; /* XXX: would it be a good idea to disable zooming (insensitive GUI)? */ break; } //////// color_filters_init(); //////// w = new(MainWindow); w->show(); return a.exec(); }
/* We've succeeded in doing a (non real-time) capture; try to read it into a new capture file */ static gboolean capture_input_read_all(capture_session *cap_session, gboolean is_tempfile, gboolean drops_known, guint32 drops) { capture_options *capture_opts = cap_session->capture_opts; int err; /* Capture succeeded; attempt to open the capture file. */ if (cf_open((capture_file *)cap_session->cf, capture_opts->save_file, is_tempfile, &err) != CF_OK) { /* We're not doing a capture any more, so we don't have a save file. */ return FALSE; } /* Set the read filter to NULL. */ /* XXX - this is odd here; try to put it somewhere where it fits better */ cf_set_rfcode((capture_file *)cap_session->cf, NULL); /* Get the packet-drop statistics. XXX - there are currently no packet-drop statistics stored in libpcap captures, and that's what we're reading. At some point, we will add support in Wiretap to return packet-drop statistics for capture file formats that store it, and will make "cf_read()" get those statistics from Wiretap. We clear the statistics (marking them as "not known") in "cf_open()", and "cf_read()" will only fetch them and mark them as known if Wiretap supplies them, so if we get the statistics now, after calling "cf_open()" but before calling "cf_read()", the values we store will be used by "cf_read()". If a future libpcap capture file format stores the statistics, we'll put them into the capture file that we write, and will thus not have to set them here - "cf_read()" will get them from the file and use them. */ if (drops_known) { cf_set_drops_known((capture_file *)cap_session->cf, TRUE); /* XXX - on some systems, libpcap doesn't bother filling in "ps_ifdrop" - it doesn't even set it to zero - so we don't bother looking at it. Ideally, libpcap would have an interface that gave us several statistics - perhaps including various interface error statistics - and would tell us which of them it supplies, allowing us to display only the ones it does. */ cf_set_drops((capture_file *)cap_session->cf, drops); } /* read in the packet data */ switch (cf_read((capture_file *)cap_session->cf, FALSE)) { case CF_READ_OK: case CF_READ_ERROR: /* Just because we got an error, that doesn't mean we were unable to read any of the file; we handle what we could get from the file. */ break; case CF_READ_ABORTED: /* User wants to quit program. Exit by leaving the main loop, so that any quit functions we registered get called. */ main_window_nested_quit(); return FALSE; } /* if we didn't capture even a single packet, close the file again */ if(cf_get_packet_count((capture_file *)cap_session->cf) == 0 && !capture_opts->restart) { simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, "%sNo packets captured!%s\n" "\n" "As no data was captured, closing the %scapture file!\n" "\n" "\n" "Help about capturing can be found at:\n" "\n" " http://wiki.wireshark.org/CaptureSetup" #ifdef _WIN32 "\n\n" "Wireless (Wi-Fi/WLAN):\n" "Try to switch off promiscuous mode in the Capture Options!" #endif "", simple_dialog_primary_start(), simple_dialog_primary_end(), (cf_is_tempfile((capture_file *)cap_session->cf)) ? "temporary " : ""); cf_close((capture_file *)cap_session->cf); } return TRUE; }
/* * Alert box for a failed attempt to write to a file. * "err" is assumed to be a UNIX-style errno. * * XXX - add explanatory secondary text for at least some of the errors; * various HIGs suggest that you should, for example, suggest that the * user remove files if the file system is full. Perhaps that's because * they're providing guidelines for people less sophisticated than the * typical Wireshark user is, but.... */ void write_failure_alert_box(const char *filename, int err) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, file_write_error_message(err), filename); }