2000-09-28 03:16:29 +00:00
|
|
|
/* filesystem.h
|
|
|
|
* Filesystem utility definitions
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2000-09-28 03:16:29 +00:00
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2000-09-28 03:16:29 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2000-09-28 03:16:29 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2000-09-28 03:16:29 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2000-09-28 03:16:29 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef FILESYSTEM_H
|
|
|
|
#define FILESYSTEM_H
|
|
|
|
|
2008-01-24 17:06:22 +00:00
|
|
|
/*
|
|
|
|
* Default profile name.
|
|
|
|
*/
|
|
|
|
#define DEFAULT_PROFILE "Default"
|
|
|
|
|
|
|
|
|
Add a routine to attempt to get the absolute pathname of the executable
file, strip off the last component to get the pathname of the directory
containing the executable file, and save it for future use. On Windows,
you can get that from the OS, but, on UN*X, you have to look at argv[0]
and derive the absolute path from that (argv[0] is not guaranteed to be
an absolute path, or even a path at all). (In addition, if you're
running from the build directory, you might have to strip off a ".libs/"
added to argv[0] as an artifact of the libtoolizing script.)
Use that in the About dialog, and use it to construct the path of
dumpcap.
Don't put quotes into the path of dumpcap; you don't have to quote
strings with spaces in them when handing them to execvp and, in fact,
you *mustn't* quote them, as the quotes will be treated as part of the
pathname.
svn path=/trunk/; revision=17267
2006-02-12 03:15:29 +00:00
|
|
|
/*
|
|
|
|
* Get the pathname of the directory from which the executable came,
|
2006-05-01 06:51:14 +00:00
|
|
|
* and save it for future use. Returns NULL on success, and a
|
|
|
|
* g_mallocated string containing an error on failure.
|
Add a routine to attempt to get the absolute pathname of the executable
file, strip off the last component to get the pathname of the directory
containing the executable file, and save it for future use. On Windows,
you can get that from the OS, but, on UN*X, you have to look at argv[0]
and derive the absolute path from that (argv[0] is not guaranteed to be
an absolute path, or even a path at all). (In addition, if you're
running from the build directory, you might have to strip off a ".libs/"
added to argv[0] as an artifact of the libtoolizing script.)
Use that in the About dialog, and use it to construct the path of
dumpcap.
Don't put quotes into the path of dumpcap; you don't have to quote
strings with spaces in them when handing them to execvp and, in fact,
you *mustn't* quote them, as the quotes will be treated as part of the
pathname.
svn path=/trunk/; revision=17267
2006-02-12 03:15:29 +00:00
|
|
|
*/
|
2009-03-22 06:53:17 +00:00
|
|
|
extern char *init_progfile_dir(const char *arg0, int (*main)(int, char **));
|
Add a routine to attempt to get the absolute pathname of the executable
file, strip off the last component to get the pathname of the directory
containing the executable file, and save it for future use. On Windows,
you can get that from the OS, but, on UN*X, you have to look at argv[0]
and derive the absolute path from that (argv[0] is not guaranteed to be
an absolute path, or even a path at all). (In addition, if you're
running from the build directory, you might have to strip off a ".libs/"
added to argv[0] as an artifact of the libtoolizing script.)
Use that in the About dialog, and use it to construct the path of
dumpcap.
Don't put quotes into the path of dumpcap; you don't have to quote
strings with spaces in them when handing them to execvp and, in fact,
you *mustn't* quote them, as the quotes will be treated as part of the
pathname.
svn path=/trunk/; revision=17267
2006-02-12 03:15:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the directory in which the program resides.
|
|
|
|
*/
|
|
|
|
extern const char *get_progfile_dir(void);
|
2002-06-23 21:33:09 +00:00
|
|
|
|
Add a WIRESHARK_RUN_FROM_BUILD_DIRECTORY environment variable on UN*X;
if set, and if the program isn't running with additional privileges,
it'll treat the directory in which the program is found as the data
directory.
If, on Windows, the version-number subdirectory of {data
directory}\plugins doesn't exist (which is assumed to mean that the
program is being run from the build directory), or if, on UN*X,
WIRESHARK_RUN_FROM_BUILD_DIRECTORY is set, the plugin directory is the
"plugins" subdirectory of the data directory, and all subdirectories of
that directory are scanned for plugins, as the "plugins" subdirectory of
the build directory contains subdirectories for the plugins; this means
that if we're running from the build directory, we'll find the plugins
we built in the build tree.
When generating the wireshark-filter man page, run tshark with
WIRESHARK_RUN_FROM_BUILD_DIRECTORY set, so it uses the plugins from the
build to generate the list of filters.
svn path=/trunk/; revision=20261
2007-01-02 06:49:40 +00:00
|
|
|
/*
|
2007-05-25 20:03:26 +00:00
|
|
|
* Get the directory in which plugins are stored; this must not be called
|
|
|
|
* before init_progfile_dir() is called, as they might be stored in a
|
|
|
|
* subdirectory of the program file directory.
|
Add a WIRESHARK_RUN_FROM_BUILD_DIRECTORY environment variable on UN*X;
if set, and if the program isn't running with additional privileges,
it'll treat the directory in which the program is found as the data
directory.
If, on Windows, the version-number subdirectory of {data
directory}\plugins doesn't exist (which is assumed to mean that the
program is being run from the build directory), or if, on UN*X,
WIRESHARK_RUN_FROM_BUILD_DIRECTORY is set, the plugin directory is the
"plugins" subdirectory of the data directory, and all subdirectories of
that directory are scanned for plugins, as the "plugins" subdirectory of
the build directory contains subdirectories for the plugins; this means
that if we're running from the build directory, we'll find the plugins
we built in the build tree.
When generating the wireshark-filter man page, run tshark with
WIRESHARK_RUN_FROM_BUILD_DIRECTORY set, so it uses the plugins from the
build to generate the list of filters.
svn path=/trunk/; revision=20261
2007-01-02 06:49:40 +00:00
|
|
|
*/
|
|
|
|
extern const char *get_plugin_dir(void);
|
|
|
|
|
2009-05-29 21:10:40 +00:00
|
|
|
/*
|
|
|
|
* Get the directory in which python plugins are stored; this must not be
|
|
|
|
* called before init_progfile_dir() is called, as they might be stored in a
|
|
|
|
* subdirectory of the program file directory.
|
|
|
|
*/
|
|
|
|
extern const char *get_wspython_dir(void);
|
|
|
|
|
Add a WIRESHARK_RUN_FROM_BUILD_DIRECTORY environment variable on UN*X;
if set, and if the program isn't running with additional privileges,
it'll treat the directory in which the program is found as the data
directory.
If, on Windows, the version-number subdirectory of {data
directory}\plugins doesn't exist (which is assumed to mean that the
program is being run from the build directory), or if, on UN*X,
WIRESHARK_RUN_FROM_BUILD_DIRECTORY is set, the plugin directory is the
"plugins" subdirectory of the data directory, and all subdirectories of
that directory are scanned for plugins, as the "plugins" subdirectory of
the build directory contains subdirectories for the plugins; this means
that if we're running from the build directory, we'll find the plugins
we built in the build tree.
When generating the wireshark-filter man page, run tshark with
WIRESHARK_RUN_FROM_BUILD_DIRECTORY set, so it uses the plugins from the
build to generate the list of filters.
svn path=/trunk/; revision=20261
2007-01-02 06:49:40 +00:00
|
|
|
/*
|
|
|
|
* Get the flag indicating whether we're running from a build
|
|
|
|
* directory.
|
|
|
|
*/
|
|
|
|
extern gboolean running_in_build_directory(void);
|
|
|
|
|
2007-01-14 22:25:22 +00:00
|
|
|
/*
|
|
|
|
* Get the directory in which global configuration files are
|
|
|
|
* stored.
|
|
|
|
*/
|
|
|
|
extern const char *get_datafile_dir(void);
|
|
|
|
|
2003-05-15 07:44:54 +00:00
|
|
|
/*
|
|
|
|
* Construct the path name of a global configuration file, given the
|
|
|
|
* file name.
|
2008-02-26 18:58:12 +00:00
|
|
|
*
|
|
|
|
* The returned file name was g_malloc()'d so it must be g_free()d when the
|
|
|
|
* caller is done with it.
|
2003-05-15 07:44:54 +00:00
|
|
|
*/
|
2003-11-18 19:20:36 +00:00
|
|
|
extern char *get_datafile_path(const char *filename);
|
2003-05-15 07:44:54 +00:00
|
|
|
|
2009-10-23 17:52:18 +00:00
|
|
|
/*
|
|
|
|
* Get the personal plugin dir.
|
|
|
|
*/
|
|
|
|
extern char *get_plugins_pers_dir(void);
|
|
|
|
|
2001-10-21 21:48:00 +00:00
|
|
|
/*
|
|
|
|
* Get the directory in which files that, at least on UNIX, are
|
|
|
|
* system files (such as "/etc/ethers") are stored; on Windows,
|
2006-05-28 19:49:07 +00:00
|
|
|
* there's no "/etc" directory, so we get them from the Wireshark
|
2001-10-21 21:48:00 +00:00
|
|
|
* global configuration and data file directory.
|
|
|
|
*/
|
Add a routine to attempt to get the absolute pathname of the executable
file, strip off the last component to get the pathname of the directory
containing the executable file, and save it for future use. On Windows,
you can get that from the OS, but, on UN*X, you have to look at argv[0]
and derive the absolute path from that (argv[0] is not guaranteed to be
an absolute path, or even a path at all). (In addition, if you're
running from the build directory, you might have to strip off a ".libs/"
added to argv[0] as an artifact of the libtoolizing script.)
Use that in the About dialog, and use it to construct the path of
dumpcap.
Don't put quotes into the path of dumpcap; you don't have to quote
strings with spaces in them when handing them to execvp and, in fact,
you *mustn't* quote them, as the quotes will be treated as part of the
pathname.
svn path=/trunk/; revision=17267
2006-02-12 03:15:29 +00:00
|
|
|
extern const char *get_systemfile_dir(void);
|
2001-10-21 21:48:00 +00:00
|
|
|
|
2008-01-14 16:40:23 +00:00
|
|
|
/*
|
|
|
|
* Set the configuration profile name to be used for storing
|
|
|
|
* personal configuration files.
|
|
|
|
*/
|
|
|
|
extern void set_profile_name(const gchar *profilename);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the current configuration profile name used for storing
|
|
|
|
* personal configuration files.
|
|
|
|
*/
|
|
|
|
extern const char *get_profile_name(void);
|
|
|
|
|
2010-10-01 16:29:37 +00:00
|
|
|
/*
|
|
|
|
* Check if current profile is default profile.
|
|
|
|
*/
|
|
|
|
extern gboolean is_default_profile(void);
|
|
|
|
|
2008-01-14 16:40:23 +00:00
|
|
|
/*
|
|
|
|
* Get the directory used to store configuration profile directories.
|
|
|
|
*/
|
|
|
|
extern const char *get_profiles_dir(void);
|
|
|
|
|
2009-12-21 12:32:31 +00:00
|
|
|
/*
|
|
|
|
* Store filenames used for personal config files so we know which
|
|
|
|
* files to copy when duplicate a configuration profile.
|
|
|
|
*/
|
|
|
|
extern void profile_store_persconffiles(gboolean store);
|
|
|
|
|
2008-01-14 16:40:23 +00:00
|
|
|
/*
|
|
|
|
* Check if given configuration profile exists.
|
|
|
|
*/
|
|
|
|
extern gboolean profile_exists(const gchar *profilename);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a directory for the given configuration profile.
|
|
|
|
* If we attempted to create it, and failed, return -1 and
|
|
|
|
* set "*pf_dir_path_return" to the pathname of the directory we failed
|
|
|
|
* to create (it's g_mallocated, so our caller should free it); otherwise,
|
|
|
|
* return 0.
|
|
|
|
*/
|
|
|
|
extern int create_persconffile_profile(const char *profilename,
|
|
|
|
char **pf_dir_path_return);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Delete the directory for the given configuration profile.
|
|
|
|
* If we attempted to delete it, and failed, return -1 and
|
|
|
|
* set "*pf_dir_path_return" to the pathname of the directory we failed
|
|
|
|
* to delete (it's g_mallocated, so our caller should free it); otherwise,
|
|
|
|
* return 0.
|
|
|
|
*/
|
|
|
|
extern int delete_persconffile_profile(const char *profilename,
|
|
|
|
char **pf_dir_path_return);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rename the directory for the given confinguration profile.
|
|
|
|
*/
|
|
|
|
extern int rename_persconffile_profile(const char *fromname, const char *toname,
|
|
|
|
char **pf_from_dir_path_return,
|
|
|
|
char **pf_to_dir_path_return);
|
|
|
|
|
2009-12-21 12:32:31 +00:00
|
|
|
/*
|
|
|
|
* Copy files in one profile to the other.
|
|
|
|
*/
|
|
|
|
extern int copy_persconffile_profile(const char *toname, const char *fromname,
|
|
|
|
char **pf_filename_return,
|
|
|
|
char **pf_to_dir_path_return,
|
|
|
|
char **pf_from_dir_path_return);
|
|
|
|
|
2001-10-23 05:01:02 +00:00
|
|
|
/*
|
|
|
|
* Create the directory that holds personal configuration files, if
|
|
|
|
* necessary. If we attempted to create it, and failed, return -1 and
|
2001-10-24 06:13:07 +00:00
|
|
|
* set "*pf_dir_path_return" to the pathname of the directory we failed
|
|
|
|
* to create (it's g_mallocated, so our caller should free it); otherwise,
|
2001-10-23 05:01:02 +00:00
|
|
|
* return 0.
|
|
|
|
*/
|
Add a routine to attempt to get the absolute pathname of the executable
file, strip off the last component to get the pathname of the directory
containing the executable file, and save it for future use. On Windows,
you can get that from the OS, but, on UN*X, you have to look at argv[0]
and derive the absolute path from that (argv[0] is not guaranteed to be
an absolute path, or even a path at all). (In addition, if you're
running from the build directory, you might have to strip off a ".libs/"
added to argv[0] as an artifact of the libtoolizing script.)
Use that in the About dialog, and use it to construct the path of
dumpcap.
Don't put quotes into the path of dumpcap; you don't have to quote
strings with spaces in them when handing them to execvp and, in fact,
you *mustn't* quote them, as the quotes will be treated as part of the
pathname.
svn path=/trunk/; revision=17267
2006-02-12 03:15:29 +00:00
|
|
|
extern int create_persconffile_dir(char **pf_dir_path_return);
|
2001-10-23 05:01:02 +00:00
|
|
|
|
2001-10-24 07:18:39 +00:00
|
|
|
/*
|
|
|
|
* Construct the path name of a personal configuration file, given the
|
2008-01-14 16:40:23 +00:00
|
|
|
* file name. If using configuration profiles this directory will be
|
|
|
|
* used if "from_profile" is TRUE.
|
2001-10-24 07:18:39 +00:00
|
|
|
*
|
|
|
|
* On Win32, if "for_writing" is FALSE, we check whether the file exists
|
2006-05-28 19:49:07 +00:00
|
|
|
* and, if not, construct a path name relative to the ".wireshark"
|
2001-10-24 07:18:39 +00:00
|
|
|
* subdirectory of the user's home directory, and check whether that
|
|
|
|
* exists; if it does, we return that, so that configuration files
|
|
|
|
* from earlier versions can be read.
|
2008-02-26 18:58:12 +00:00
|
|
|
*
|
|
|
|
* The returned file name was g_malloc()'d so it must be g_free()d when the
|
|
|
|
* caller is done with it.
|
2001-10-24 07:18:39 +00:00
|
|
|
*/
|
2008-01-14 16:40:23 +00:00
|
|
|
extern char *get_persconffile_path(const char *filename, gboolean from_profile,
|
|
|
|
gboolean for_writing);
|
2001-10-24 07:18:39 +00:00
|
|
|
|
2007-01-14 22:25:22 +00:00
|
|
|
/*
|
|
|
|
* Get the (default) directory in which personal data is stored.
|
|
|
|
*
|
|
|
|
* On Win32, this is the "My Documents" folder in the personal profile.
|
|
|
|
* On UNIX this is simply the current directory.
|
|
|
|
*/
|
2010-03-02 00:06:20 +00:00
|
|
|
extern const char *get_persdatafile_dir(void);
|
2007-01-14 22:25:22 +00:00
|
|
|
|
2003-11-02 23:12:35 +00:00
|
|
|
/*
|
|
|
|
* Construct the path name of a file in $TMP/%TEMP% directory.
|
|
|
|
* Or "/tmp/<filename>" (C:\<filename>) if that fails.
|
|
|
|
*
|
2009-02-11 01:54:09 +00:00
|
|
|
* Return value is g_malloced so the caller should g_free it.
|
2003-11-02 23:12:35 +00:00
|
|
|
*/
|
2003-11-18 19:20:36 +00:00
|
|
|
extern char *get_tempfile_path(const char *filename);
|
2003-11-02 23:12:35 +00:00
|
|
|
|
2007-03-14 02:55:54 +00:00
|
|
|
/*
|
|
|
|
* process command line option belonging to the filesystem settings
|
|
|
|
*/
|
2008-06-23 20:31:21 +00:00
|
|
|
extern int filesystem_opt(int opt, const char *optstr);
|
2007-03-14 02:55:54 +00:00
|
|
|
|
2004-01-24 01:44:29 +00:00
|
|
|
/*
|
2004-01-24 02:01:44 +00:00
|
|
|
* Return an error message for UNIX-style errno indications on open or
|
|
|
|
* create operations.
|
2004-01-24 01:44:29 +00:00
|
|
|
*/
|
Add a routine to attempt to get the absolute pathname of the executable
file, strip off the last component to get the pathname of the directory
containing the executable file, and save it for future use. On Windows,
you can get that from the OS, but, on UN*X, you have to look at argv[0]
and derive the absolute path from that (argv[0] is not guaranteed to be
an absolute path, or even a path at all). (In addition, if you're
running from the build directory, you might have to strip off a ".libs/"
added to argv[0] as an artifact of the libtoolizing script.)
Use that in the About dialog, and use it to construct the path of
dumpcap.
Don't put quotes into the path of dumpcap; you don't have to quote
strings with spaces in them when handing them to execvp and, in fact,
you *mustn't* quote them, as the quotes will be treated as part of the
pathname.
svn path=/trunk/; revision=17267
2006-02-12 03:15:29 +00:00
|
|
|
extern const char *file_open_error_message(int err, gboolean for_writing);
|
2004-01-24 01:44:29 +00:00
|
|
|
|
2004-01-24 02:01:44 +00:00
|
|
|
/*
|
|
|
|
* Return an error message for UNIX-style errno indications on write
|
|
|
|
* operations.
|
|
|
|
*/
|
Add a routine to attempt to get the absolute pathname of the executable
file, strip off the last component to get the pathname of the directory
containing the executable file, and save it for future use. On Windows,
you can get that from the OS, but, on UN*X, you have to look at argv[0]
and derive the absolute path from that (argv[0] is not guaranteed to be
an absolute path, or even a path at all). (In addition, if you're
running from the build directory, you might have to strip off a ".libs/"
added to argv[0] as an artifact of the libtoolizing script.)
Use that in the About dialog, and use it to construct the path of
dumpcap.
Don't put quotes into the path of dumpcap; you don't have to quote
strings with spaces in them when handing them to execvp and, in fact,
you *mustn't* quote them, as the quotes will be treated as part of the
pathname.
svn path=/trunk/; revision=17267
2006-02-12 03:15:29 +00:00
|
|
|
extern const char *file_write_error_message(int err);
|
2004-01-24 02:01:44 +00:00
|
|
|
|
2007-01-14 22:25:22 +00:00
|
|
|
/*
|
|
|
|
* Given a pathname, return the last component.
|
|
|
|
*/
|
|
|
|
extern const char *get_basename(const char *);
|
|
|
|
|
2010-08-10 11:36:18 +00:00
|
|
|
/*
|
|
|
|
* Given a pathname, return a pointer to the last pathname separator
|
|
|
|
* character in the pathname, or NULL if the pathname contains no
|
|
|
|
* separators.
|
|
|
|
*/
|
|
|
|
extern char *find_last_pathname_separator(const char *path);
|
|
|
|
|
2007-01-14 22:25:22 +00:00
|
|
|
/*
|
|
|
|
* Given a pathname, return a string containing everything but the
|
|
|
|
* last component. NOTE: this overwrites the pathname handed into
|
|
|
|
* it....
|
|
|
|
*/
|
|
|
|
extern char *get_dirname(char *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a pathname, return:
|
|
|
|
*
|
|
|
|
* the errno, if an attempt to "stat()" the file fails;
|
|
|
|
*
|
|
|
|
* EISDIR, if the attempt succeeded and the file turned out
|
|
|
|
* to be a directory;
|
|
|
|
*
|
|
|
|
* 0, if the attempt succeeded and the file turned out not
|
|
|
|
* to be a directory.
|
|
|
|
*/
|
|
|
|
extern int test_for_directory(const char *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a pathname, return:
|
|
|
|
*
|
|
|
|
* the errno, if an attempt to "stat()" the file fails;
|
|
|
|
*
|
|
|
|
* ESPIPE, if the attempt succeeded and the file turned out
|
|
|
|
* to be a FIFO;
|
|
|
|
*
|
|
|
|
* 0, if the attempt succeeded and the file turned out not
|
|
|
|
* to be a FIFO.
|
|
|
|
*/
|
|
|
|
extern int test_for_fifo(const char *);
|
|
|
|
|
|
|
|
/* Delete a file */
|
|
|
|
extern gboolean deletefile (const char *path);
|
|
|
|
|
2005-04-12 21:12:19 +00:00
|
|
|
/*
|
|
|
|
* Check, if file is existing.
|
|
|
|
*/
|
|
|
|
extern gboolean file_exists(const char *fname);
|
|
|
|
|
|
|
|
/*
|
2009-02-15 21:47:57 +00:00
|
|
|
* Check if two filenames are identical (with absolute and relative paths).
|
2005-04-12 21:12:19 +00:00
|
|
|
*/
|
|
|
|
extern gboolean files_identical(const char *fname1, const char *fname2);
|
|
|
|
|
2009-02-15 21:47:57 +00:00
|
|
|
/*
|
|
|
|
* Copy a file in binary mode, for those operating systems that care about
|
|
|
|
* such things. This should be OK for all files, even text files, as
|
|
|
|
* we'll copy the raw bytes, and we don't look at the bytes as we copy
|
|
|
|
* them.
|
|
|
|
*
|
|
|
|
* Returns TRUE on success, FALSE on failure. If a failure, it also
|
|
|
|
* displays a simple dialog window with the error message.
|
|
|
|
*/
|
|
|
|
extern gboolean copy_file_binary_mode(const char *from_filename,
|
|
|
|
const char *to_filename);
|
|
|
|
|
2008-08-02 12:20:38 +00:00
|
|
|
#ifdef _WIN32
|
2006-01-12 22:32:29 +00:00
|
|
|
/*
|
|
|
|
* utf8 version of getenv, needed to get win32 filename paths
|
|
|
|
*/
|
Add a routine to attempt to get the absolute pathname of the executable
file, strip off the last component to get the pathname of the directory
containing the executable file, and save it for future use. On Windows,
you can get that from the OS, but, on UN*X, you have to look at argv[0]
and derive the absolute path from that (argv[0] is not guaranteed to be
an absolute path, or even a path at all). (In addition, if you're
running from the build directory, you might have to strip off a ".libs/"
added to argv[0] as an artifact of the libtoolizing script.)
Use that in the About dialog, and use it to construct the path of
dumpcap.
Don't put quotes into the path of dumpcap; you don't have to quote
strings with spaces in them when handing them to execvp and, in fact,
you *mustn't* quote them, as the quotes will be treated as part of the
pathname.
svn path=/trunk/; revision=17267
2006-02-12 03:15:29 +00:00
|
|
|
extern char *getenv_utf8(const char *varname);
|
2006-01-12 22:32:29 +00:00
|
|
|
#endif
|
|
|
|
|
2000-12-22 22:26:19 +00:00
|
|
|
#endif /* FILESYSTEM_H */
|