epan/filesystem.h

   1 /* filesystem.h
   2  * Filesystem utility definitions
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifndef FILESYSTEM_H
  26 #define FILESYSTEM_H
  27
  28 /*
  29  * Default profile name.
  30  */
  31 #define DEFAULT_PROFILE      "Default"
  32
  33
  34 /*
  35  * Get the pathname of the directory from which the executable came,
  36  * and save it for future use.  Returns NULL on success, and a
  37  * g_mallocated string containing an error on failure.
  38  */
  39 extern char *init_progfile_dir(const char *arg0, int (*main)(int, char **));
  40
  41 /*
  42  * Get the directory in which the program resides.
  43  */
  44 extern const char *get_progfile_dir(void);
  45
  46 /*
  47  * Get the directory in which plugins are stored; this must not be called
  48  * before init_progfile_dir() is called, as they might be stored in a
  49  * subdirectory of the program file directory.
  50  */
  51 extern const char *get_plugin_dir(void);
  52
  53 /*
  54  * Get the directory in which python plugins are stored; this must not be
  55  * called before init_progfile_dir() is called, as they might be stored in a
  56  * subdirectory of the program file directory.
  57  */
  58 extern const char *get_wspython_dir(void);
  59
  60 /*
  61  * Get the flag indicating whether we're running from a build
  62  * directory.
  63  */
  64 extern gboolean running_in_build_directory(void);
  65
  66 /*
  67  * Get the directory in which global configuration files are
  68  * stored.
  69  */
  70 extern const char *get_datafile_dir(void);
  71
  72 /*
  73  * Construct the path name of a global configuration file, given the
  74  * file name.
  75  *
  76  * The returned file name was g_malloc()'d so it must be g_free()d when the
  77  * caller is done with it.
  78  */
  79 extern char *get_datafile_path(const char *filename);
  80
  81 /*
  82  * Get the directory in which files that, at least on UNIX, are
  83  * system files (such as "/etc/ethers") are stored; on Windows,
  84  * there's no "/etc" directory, so we get them from the Wireshark
  85  * global configuration and data file directory.
  86  */
  87 extern const char *get_systemfile_dir(void);
  88
  89 /*
  90  * Set the configuration profile name to be used for storing
  91  * personal configuration files.
  92  */
  93 extern void set_profile_name(const gchar *profilename);
  94
  95 /*
  96  * Get the current configuration profile name used for storing
  97  * personal configuration files.
  98  */
  99 extern const char *get_profile_name(void);
 100
 101 /*
 102  * Get the directory used to store configuration profile directories.
 103  */
 104 extern const char *get_profiles_dir(void);
 105
 106 /*
 107  * Check if given configuration profile exists.
 108  */
 109 extern gboolean profile_exists(const gchar *profilename);
 110
 111 /*
 112  * Create a directory for the given configuration profile.
 113  * If we attempted to create it, and failed, return -1 and
 114  * set "*pf_dir_path_return" to the pathname of the directory we failed
 115  * to create (it's g_mallocated, so our caller should free it); otherwise,
 116  * return 0.
 117  */
 118 extern int create_persconffile_profile(const char *profilename,
 119                                        char **pf_dir_path_return);
 120
 121 /*
 122  * Delete the directory for the given configuration profile.
 123  * If we attempted to delete it, and failed, return -1 and
 124  * set "*pf_dir_path_return" to the pathname of the directory we failed
 125  * to delete (it's g_mallocated, so our caller should free it); otherwise,
 126  * return 0.
 127  */
 128 extern int delete_persconffile_profile(const char *profilename,
 129                                        char **pf_dir_path_return);
 130
 131 /*
 132  * Rename the directory for the given confinguration profile.
 133  */
 134 extern int rename_persconffile_profile(const char *fromname, const char *toname,
 135                                        char **pf_from_dir_path_return,
 136                                        char **pf_to_dir_path_return);
 137
 138 /*
 139  * Create the directory that holds personal configuration files, if
 140  * necessary.  If we attempted to create it, and failed, return -1 and
 141  * set "*pf_dir_path_return" to the pathname of the directory we failed
 142  * to create (it's g_mallocated, so our caller should free it); otherwise,
 143  * return 0.
 144  */
 145 extern int create_persconffile_dir(char **pf_dir_path_return);
 146
 147 /*
 148  * Construct the path name of a personal configuration file, given the
 149  * file name.  If using configuration profiles this directory will be
 150  * used if "from_profile" is TRUE.
 151  *
 152  * On Win32, if "for_writing" is FALSE, we check whether the file exists
 153  * and, if not, construct a path name relative to the ".wireshark"
 154  * subdirectory of the user's home directory, and check whether that
 155  * exists; if it does, we return that, so that configuration files
 156  * from earlier versions can be read.
 157  *
 158  * The returned file name was g_malloc()'d so it must be g_free()d when the
 159  * caller is done with it.
 160  */
 161 extern char *get_persconffile_path(const char *filename, gboolean from_profile,
 162                                    gboolean for_writing);
 163
 164 /*
 165  * Get the (default) directory in which personal data is stored.
 166  *
 167  * On Win32, this is the "My Documents" folder in the personal profile.
 168  * On UNIX this is simply the current directory.
 169  */
 170 extern char *get_persdatafile_dir(void);
 171
 172 /*
 173  * Construct the path name of a file in $TMP/%TEMP% directory.
 174  * Or "/tmp/<filename>" (C:\<filename>) if that fails.
 175  *
 176  * Return value is g_malloced so the caller should g_free it.
 177  */
 178 extern char *get_tempfile_path(const char *filename);
 179
 180 /*
 181  * process command line option belonging to the filesystem settings
 182  */
 183 extern int filesystem_opt(int opt, const char *optstr);
 184
 185 /*
 186  * Return an error message for UNIX-style errno indications on open or
 187  * create operations.
 188  */
 189 extern const char *file_open_error_message(int err, gboolean for_writing);
 190
 191 /*
 192  * Return an error message for UNIX-style errno indications on write
 193  * operations.
 194  */
 195 extern const char *file_write_error_message(int err);
 196
 197 /*
 198  * Given a pathname, return the last component.
 199  */
 200 extern const char *get_basename(const char *);
 201
 202 /*
 203  * Given a pathname, return a string containing everything but the
 204  * last component.  NOTE: this overwrites the pathname handed into
 205  * it....
 206  */
 207 extern char *get_dirname(char *);
 208
 209 /*
 210  * Given a pathname, return:
 211  *
 212  *      the errno, if an attempt to "stat()" the file fails;
 213  *
 214  *      EISDIR, if the attempt succeeded and the file turned out
 215  *      to be a directory;
 216  *
 217  *      0, if the attempt succeeded and the file turned out not
 218  *      to be a directory.
 219  */
 220 extern int test_for_directory(const char *);
 221
 222 /*
 223  * Given a pathname, return:
 224  *
 225  *      the errno, if an attempt to "stat()" the file fails;
 226  *
 227  *      ESPIPE, if the attempt succeeded and the file turned out
 228  *      to be a FIFO;
 229  *
 230  *      0, if the attempt succeeded and the file turned out not
 231  *      to be a FIFO.
 232  */
 233 extern int test_for_fifo(const char *);
 234
 235 /* Delete a file */
 236 extern gboolean deletefile (const char *path);
 237
 238 /*
 239  * Check, if file is existing.
 240  */
 241 extern gboolean file_exists(const char *fname);
 242
 243 /*
 244  * Check if two filenames are identical (with absolute and relative paths).
 245  */
 246 extern gboolean files_identical(const char *fname1, const char *fname2);
 247
 248 /*
 249  * Copy a file in binary mode, for those operating systems that care about
 250  * such things.  This should be OK for all files, even text files, as
 251  * we'll copy the raw bytes, and we don't look at the bytes as we copy
 252  * them.
 253  *
 254  * Returns TRUE on success, FALSE on failure. If a failure, it also
 255  * displays a simple dialog window with the error message.
 256  */
 257 extern gboolean copy_file_binary_mode(const char *from_filename,
 258     const char *to_filename);
 259
 260 #ifdef _WIN32
 261 /*
 262  * utf8 version of getenv, needed to get win32 filename paths
 263  */
 264 extern char *getenv_utf8(const char *varname);
 265 #endif
 266
 267 #endif /* FILESYSTEM_H */