WSLUA_CONSTRUCTOR Dir_remove(lua_State* L) { /* Removes an empty directory. If the directory was removed successfully, a boolean `true` is returned. If the directory cannot be removed because it does not exist, `false` is returned. If the directory cannot be removed because an error occurred, `nil` is returned. This function only removes empty directories. To remove a directory regardless, use `Dir.remove_all()`. @since 1.11.3 */ #define WSLUA_ARG_Dir_remove_NAME 1 /* The name of the directory, possibly including path. */ const char *dir_path = luaL_checkstring(L, WSLUA_ARG_Dir_remove_NAME); int ret; if (test_for_directory (dir_path) == EISDIR) { ret = ws_remove(dir_path); if (ret != 0) { lua_pushnil(L); } else { lua_pushboolean(L, 1); } } else { lua_pushboolean(L, 0); } WSLUA_RETURN(1); /* Boolean `true` on success, `false` if does not exist, `nil` on error. */ }
WSLUA_CONSTRUCTOR Dir_exists(lua_State* L) { /* Returns true if the given directory name exists. If the directory exists, a boolean `true` is returned. If the path is a file instead, `false` is returned. If the path does not exist or an error occurred, `nil` is returned. @since 1.11.3 */ #define WSLUA_ARG_Dir_exists_NAME 1 /* The name of the directory, possibly including path. */ const char *dir_path = luaL_checkstring(L, WSLUA_ARG_Dir_exists_NAME); int ret; if ((ret = test_for_directory (dir_path)) == EISDIR) { lua_pushboolean(L, 1); } else { if (ret == 0) { lua_pushboolean(L, 0); } else { lua_pushnil(L); } } WSLUA_RETURN(1); /* Boolean `true` if the directory exists, `false` if it's a file, `nil` on error/not-exist. */ }
static int delete_directory(const char *directory) { WS_DIR *dir; WS_DIRENT *file; gchar *filename; int ret = 0; /* delete all contents of directory */ if ((dir = ws_dir_open(directory, 0, NULL)) != NULL) { while ((file = ws_dir_read_name(dir)) != NULL) { filename = g_strdup_printf ("%s%s%s", directory, G_DIR_SEPARATOR_S, ws_dir_get_name(file)); if (test_for_directory(filename) != EISDIR) { ret = ws_remove(filename); } else { /* recurse */ ret = delete_directory (filename); } if (ret != 0) { break; } g_free (filename); } ws_dir_close(dir); } if (ret == 0) { ret = ws_remove(directory); } return ret; }
void init_profile_list(void) { WS_DIR *dir; /* scanned directory */ WS_DIRENT *file; /* current file */ const gchar *profiles_dir, *name; gchar *filename; empty_profile_list(TRUE); /* Default entry */ add_to_profile_list(DEFAULT_PROFILE, DEFAULT_PROFILE, PROF_STAT_DEFAULT, FALSE, FALSE); /* Local (user) profiles */ profiles_dir = get_profiles_dir(); if ((dir = ws_dir_open(profiles_dir, 0, NULL)) != NULL) { while ((file = ws_dir_read_name(dir)) != NULL) { name = ws_dir_get_name(file); filename = g_strdup_printf ("%s%s%s", profiles_dir, G_DIR_SEPARATOR_S, name); if (test_for_directory(filename) == EISDIR) { /*fl_entry =*/ add_to_profile_list(name, name, PROF_STAT_EXISTS, FALSE, FALSE); } g_free (filename); } ws_dir_close (dir); } /* Global profiles */ profiles_dir = get_global_profiles_dir(); if ((dir = ws_dir_open(profiles_dir, 0, NULL)) != NULL) { while ((file = ws_dir_read_name(dir)) != NULL) { name = ws_dir_get_name(file); filename = g_strdup_printf ("%s%s%s", profiles_dir, G_DIR_SEPARATOR_S, name); if (test_for_directory(filename) == EISDIR) { /*fl_entry =*/ add_to_profile_list(name, name, PROF_STAT_EXISTS, TRUE, TRUE); /*profile = (profile_def *) fl_entry->data;*/ } g_free (filename); } ws_dir_close (dir); } /* Make the current list and the edited list equal */ copy_profile_list (); }
static GtkTreeIter * fill_list(GtkWidget *main_w) { WS_DIR *dir; /* scanned directory */ WS_DIRENT *file; /* current file */ GList *fl_entry; profile_def *profile; GtkTreeView *profile_l; GtkListStore *store; GtkTreeIter iter, *l_select = NULL; const gchar *profile_name = get_profile_name (); const gchar *profiles_dir, *name; gchar *filename; profile_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(main_w), E_PROF_PROFILE_L_KEY)); store = GTK_LIST_STORE(gtk_tree_view_get_model(profile_l)); fl_entry = add_to_profile_list(DEFAULT_PROFILE, DEFAULT_PROFILE, PROF_STAT_DEFAULT); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, DEFAULT_PROFILE, 1, fl_entry, -1); if (strcmp (profile_name, DEFAULT_PROFILE)==0) { l_select = g_memdup(&iter, sizeof(iter)); } /* fill in data */ profiles_dir = get_profiles_dir(); if ((dir = ws_dir_open(profiles_dir, 0, NULL)) != NULL) { while ((file = ws_dir_read_name(dir)) != NULL) { name = ws_dir_get_name(file); filename = g_strdup_printf ("%s%s%s", profiles_dir, G_DIR_SEPARATOR_S, name); if (test_for_directory(filename) == EISDIR) { fl_entry = add_to_profile_list(name, name, PROF_STAT_EXISTS); profile = (profile_def *) fl_entry->data; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, profile->name, 1, fl_entry, -1); if (profile->name) { if (strcmp(profile_name, profile->name) == 0) { /* * XXX - We're assuming that we can just copy a GtkTreeIter * and use it later without any crashes. This may not be a * valid assumption. */ l_select = g_memdup(&iter, sizeof(iter)); } } } g_free (filename); } ws_dir_close (dir); } /* Make the current list and the edited list equal */ copy_profile_list (); return l_select; }
/* * process command line option that affects the paths of the directories * used for personal files (configuration, saved captures) */ gboolean persfilepath_opt(int opt _U_, const char *optstr) { gchar *p, *colonp; colonp = strchr(optstr, ':'); if (colonp == NULL) { return FALSE; } p = colonp; *p++ = '\0'; /* * Skip over any white space (there probably won't be any, but * as we allow it in the preferences file, we might as well * allow it here). */ while (isspace((guchar)*p)) p++; if (*p == '\0') { /* * Put the colon back, so if our caller uses, in an * error message, the string they passed us, the message * looks correct. */ *colonp = ':'; return FALSE; } /* directory should be existing */ /* XXX - is this a requirement? */ if(test_for_directory(p) != EISDIR) { /* * Put the colon back, so if our caller uses, in an * error message, the string they passed us, the message * looks correct. */ *colonp = ':'; return FALSE; } if (strcmp(optstr,"persconf") == 0) { set_persconffile_dir(p); } else if (strcmp(optstr,"persdata") == 0) { set_persdatafile_dir(p); } else { /* XXX - might need to add the temp file path */ return FALSE; } *colonp = ':'; /* put the colon back */ return TRUE; }
WSLUA_CONSTRUCTOR Dir_open(lua_State* L) { /* Opens a directory and returns a `Dir` object representing the files in the directory. @code for filename in Dir.open(path) do ... end @endcode */ #define WSLUA_ARG_Dir_open_PATHNAME 1 /* The pathname of the directory. */ #define WSLUA_OPTARG_Dir_open_EXTENSION 2 /* If given, only files with this extension will be returned. */ const char* dirname = luaL_checkstring(L,WSLUA_ARG_Dir_open_PATHNAME); const char* extension = luaL_optstring(L,WSLUA_OPTARG_Dir_open_EXTENSION,NULL); Dir dir; char* dirname_clean; dirname_clean = wslua_get_actual_filename(dirname); if (!dirname_clean) { WSLUA_ARG_ERROR(Dir_open,PATHNAME,"directory does not exist"); return 0; } if (!test_for_directory(dirname_clean)) { g_free(dirname_clean); WSLUA_ARG_ERROR(Dir_open,PATHNAME, "must be a directory"); return 0; } dir = (Dir)g_malloc(sizeof(struct _wslua_dir)); dir->dir = g_dir_open(dirname_clean, 0, dir->dummy); g_free(dirname_clean); dir->ext = extension ? g_strdup(extension) : NULL; dir->dummy = (GError **)g_malloc(sizeof(GError *)); *(dir->dummy) = NULL; if (dir->dir == NULL) { g_free(dir->dummy); g_free(dir); WSLUA_ARG_ERROR(Dir_open,PATHNAME,"could not open directory"); return 0; } pushDir(L,dir); WSLUA_RETURN(1); /* the `Dir` object. */ }
WSLUA_CONSTRUCTOR Dir_open(lua_State* L) { /* Usage: for filename in Dir.open(path) do ... end */ #define WSLUA_ARG_Dir_open_PATHNAME 1 /* The pathname of the directory */ #define WSLUA_OPTARG_Dir_open_EXTENSION 2 /* If given, only file with this extension will be returned */ const char* dirname = luaL_checkstring(L,WSLUA_ARG_Dir_open_PATHNAME); const char* extension = luaL_optstring(L,WSLUA_OPTARG_Dir_open_EXTENSION,NULL); Dir dir; char* dirname_clean; if (!dirname) WSLUA_ARG_ERROR(Dir_open,PATHNAME,"must be a string"); dirname_clean = wslua_get_actual_filename(dirname); if (!dirname_clean) WSLUA_ARG_ERROR(Dir_open,PATHNAME,"directory does not exist"); if (!test_for_directory(dirname_clean)) { g_free(dirname_clean); WSLUA_ARG_ERROR(Dir_open,PATHNAME, "must be a directory"); } dir = g_malloc(sizeof(struct _wslua_dir)); dir->dir = OPENDIR_OP(dirname_clean); g_free(dirname_clean); dir->ext = extension ? g_strdup(extension) : NULL; dir->dummy = g_malloc(sizeof(GError *)); *(dir->dummy) = NULL; if (dir->dir == NULL) { g_free(dir->dummy); g_free(dir); WSLUA_ARG_ERROR(Dir_open,PATHNAME,"could not open directory"); } pushDir(L,dir); WSLUA_RETURN(1); /* the Dir object */ }
/* * Scan for plugins. */ void scan_plugins(void) { const char *plugin_dir; const char *name; char *plugin_dir_path; char *plugins_pers_dir; WS_DIR *dir; /* scanned directory */ WS_DIRENT *file; /* current file */ if (plugin_list == NULL) /* ensure scan_plugins is only run once */ { /* * Scan the global plugin directory. * If we're running from a build directory, scan the subdirectories * of that directory, as the global plugin directory is the * "plugins" directory of the source tree, and the subdirectories * are the source directories for the plugins, with the plugins * built in those subdirectories. */ plugin_dir = get_plugin_dir(); if (running_in_build_directory()) { if ((dir = ws_dir_open(plugin_dir, 0, NULL)) != NULL) { while ((file = ws_dir_read_name(dir)) != NULL) { name = ws_dir_get_name(file); if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue; /* skip "." and ".." */ /* * Get the full path of a ".libs" subdirectory of that * directory. */ plugin_dir_path = g_strdup_printf( "%s" G_DIR_SEPARATOR_S "%s" G_DIR_SEPARATOR_S ".libs", plugin_dir, name); if (test_for_directory(plugin_dir_path) != EISDIR) { /* * Either it doesn't refer to a directory or it * refers to something that doesn't exist. * * Assume that means that the plugins are in * the subdirectory of the plugin directory, not * a ".libs" subdirectory of that subdirectory. */ g_free(plugin_dir_path); plugin_dir_path = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", plugin_dir, name); } plugins_scan_dir(plugin_dir_path); g_free(plugin_dir_path); } ws_dir_close(dir); } } else plugins_scan_dir(plugin_dir); /* * If the program wasn't started with special privileges, * scan the users plugin directory. (Even if we relinquish * them, plugins aren't safe unless we've *permanently* * relinquished them, and we can't do that in Wireshark as, * if we need privileges to start capturing, we'd need to * reclaim them before each time we start capturing.) */ if (!started_with_special_privs()) { plugins_pers_dir = get_plugins_pers_dir(); plugins_scan_dir(plugins_pers_dir); g_free(plugins_pers_dir); } } }
void WiresharkApplication::setConfigurationProfile(const gchar *profile_name) { char *gdp_path, *dp_path; char *rf_path; int rf_open_errno; gchar *err_msg = NULL; /* 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); packet_list_enable_color(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 */ if (!color_filters_reload(&err_msg, color_filter_add_cb)) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_msg); g_free(err_msg); } emit localInterfaceListChanged(); emit packetDissectionChanged(); }
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 = g_object_get_data(G_OBJECT(w), "surface-info"); #else GdkPixmap *pixmap = 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; GdkWindow *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; } save_as_w = file_selection_new("Wireshark: Save Graph As ...", FILE_SELECTION_SAVE); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(save_as_w), TRUE); /* 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 = 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); parent = gtk_widget_get_parent_window(w); gdk_window_set_transient_for(gtk_widget_get_window(save_as_w), parent); /* * 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; } }
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); /* Reset current preferences and apply the new */ prefs_reset(); // menu_prefs_reset(); (void) readConfigurationFiles (&gdp_path, &dp_path); recent_read_profile_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, g_strerror(rf_open_errno)); } 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_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(); emit preferencesChanged(); emit columnsChanged(); emit recentFilesRead(); emit filterExpressionsChanged(); // macros_post_update(); /* 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(); // user_font_apply(); /* Update menus with new recent values */ // menu_recent_read_finished(); }