2021-11-26 03:31:05 +00:00
|
|
|
/** @file
|
2000-09-28 03:16:29 +00:00
|
|
|
* Filesystem utility definitions
|
|
|
|
*
|
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
|
|
|
*
|
2018-02-07 11:26:45 +00:00
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
2000-09-28 03:16:29 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef FILESYSTEM_H
|
|
|
|
#define FILESYSTEM_H
|
|
|
|
|
2021-12-17 18:23:34 +00:00
|
|
|
#include <wireshark.h>
|
2013-03-01 23:53:11 +00:00
|
|
|
|
2010-12-01 18:25:18 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif /* __cplusplus */
|
|
|
|
|
2008-01-24 17:06:22 +00:00
|
|
|
/*
|
|
|
|
* Default profile name.
|
|
|
|
*/
|
|
|
|
#define DEFAULT_PROFILE "Default"
|
|
|
|
|
2022-02-20 20:09:34 +00:00
|
|
|
/**
|
|
|
|
* Initialize our configuration environment.
|
|
|
|
*
|
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,
|
2022-02-20 20:09:34 +00:00
|
|
|
* and save it for future use.
|
|
|
|
*
|
|
|
|
* Set our configuration namespace, which determines the top-level
|
|
|
|
* configuration directory name and environment variable prefixes.
|
|
|
|
* Default is "Wireshark".
|
|
|
|
*
|
|
|
|
* @param arg0 Executable name hint. Should be argv[0].
|
|
|
|
* @param namespace_name The namespace to use. "Wireshark" or NULL uses
|
2022-06-30 16:45:49 +00:00
|
|
|
* the Wireshark namespace. "Logray" uses the Logray namespace.
|
2022-02-20 20:09:34 +00:00
|
|
|
* @return 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
|
|
|
*/
|
2022-02-20 20:09:34 +00:00
|
|
|
WS_DLL_PUBLIC char *configuration_init(const char *arg0, const char *namespace_name);
|
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
|
|
|
|
2022-04-28 20:41:27 +00:00
|
|
|
/**
|
|
|
|
* Get the configuration namespace name.
|
2022-06-30 16:45:49 +00:00
|
|
|
* @return The namespace name. One of "Wireshark" or "Logray".
|
2022-04-28 20:41:27 +00:00
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC const char *get_configuration_namespace(void);
|
|
|
|
|
2022-06-17 22:22:26 +00:00
|
|
|
/**
|
|
|
|
* Check to see if the configuration namespace is for packet analysis
|
|
|
|
* (Wireshark) or log analysis (Logray).
|
|
|
|
* @return true if the configuration namespace is for packets.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC bool is_packet_configuration_namespace(void);
|
|
|
|
|
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
|
|
|
/*
|
2022-12-22 02:37:05 +00:00
|
|
|
* Get the directory in which the main (Wireshark, TShark, Logray, etc)
|
|
|
|
* program resides.
|
|
|
|
* Extcaps should use get_extcap_dir() to get their path.
|
|
|
|
*
|
|
|
|
* @return The main program 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
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC const char *get_progfile_dir(void);
|
2002-06-23 21:33:09 +00:00
|
|
|
|
2022-12-23 06:37:45 +00:00
|
|
|
/*
|
|
|
|
* Construct the path name of a non-extcap Wireshark executable file,
|
|
|
|
* given the program name. The executable name doesn't include ".exe";
|
|
|
|
* append it on Windows, so that callers don't have to worry about that.
|
|
|
|
*
|
|
|
|
* This presumes that all non-extcap executables are in the same directory.
|
|
|
|
*
|
|
|
|
* The returned file name was g_malloc()'d so it must be g_free()d when the
|
|
|
|
* caller is done with it.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC char *get_executable_path(const char *filename);
|
|
|
|
|
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
|
2022-02-20 20:09:34 +00:00
|
|
|
* before configuration_init() is called, as they might be stored in a
|
2007-05-25 20:03:26 +00:00
|
|
|
* 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
|
|
|
*/
|
2017-09-18 14:45:17 +00:00
|
|
|
WS_DLL_PUBLIC const char *get_plugins_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
|
|
|
|
2017-09-18 15:25:20 +00:00
|
|
|
/*
|
|
|
|
* Append VERSION_MAJOR.VERSION_MINOR to the plugin dir.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC const char *get_plugins_dir_with_version(void);
|
|
|
|
|
2017-09-10 22:38:36 +00:00
|
|
|
/*
|
|
|
|
* Get the personal plugin dir.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC const char *get_plugins_pers_dir(void);
|
|
|
|
|
2017-09-18 15:25:20 +00:00
|
|
|
/*
|
|
|
|
* Append VERSION_MAJOR.VERSION_MINOR to the plugin personal dir.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC const char *get_plugins_pers_dir_with_version(void);
|
|
|
|
|
2014-02-25 13:05:11 +00:00
|
|
|
/*
|
|
|
|
* Get the directory in which extcap hooks are stored; this must not be called
|
2022-02-20 20:09:34 +00:00
|
|
|
* before configuration_init() is called, as they might be stored in a
|
2014-02-25 13:05:11 +00:00
|
|
|
* subdirectory of the program file directory.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC const char *get_extcap_dir(void);
|
|
|
|
|
2023-01-20 14:06:59 +00:00
|
|
|
/*
|
|
|
|
* Get the personal extcap dir.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC const char *get_extcap_pers_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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC gboolean running_in_build_directory(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
|
|
|
|
2007-01-14 22:25:22 +00:00
|
|
|
/*
|
2019-07-30 08:12:30 +00:00
|
|
|
* Get the directory in which global configuration files are
|
2007-01-14 22:25:22 +00:00
|
|
|
* stored.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC const char *get_datafile_dir(void);
|
2007-01-14 22:25:22 +00:00
|
|
|
|
2003-05-15 07:44:54 +00:00
|
|
|
/*
|
2019-07-30 08:12:30 +00:00
|
|
|
* Construct the path name of a global configuration file, given the
|
2003-05-15 07:44:54 +00:00
|
|
|
* 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
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC char *get_datafile_path(const char *filename);
|
2003-05-15 07:44:54 +00:00
|
|
|
|
2023-01-18 14:12:14 +00:00
|
|
|
/*
|
|
|
|
* Get the directory in which global documentation files are
|
|
|
|
* stored.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC const char *get_doc_dir(void);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct the path name of a global documentation file, given the
|
|
|
|
* file name.
|
|
|
|
*
|
|
|
|
* The returned file name was g_malloc()'d so it must be g_free()d when the
|
|
|
|
* caller is done with it.
|
|
|
|
*/
|
2023-01-20 10:14:38 +00:00
|
|
|
WS_DLL_PUBLIC char *get_docfile_path(const char *filename);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct the path URL of a global documentation file, given the
|
|
|
|
* file name.
|
|
|
|
*
|
|
|
|
* The returned file name was g_malloc()'d so it must be g_free()d when the
|
|
|
|
* caller is done with it.
|
|
|
|
*/
|
2023-01-18 14:12:14 +00:00
|
|
|
WS_DLL_PUBLIC char *doc_file_url(const char *filename);
|
|
|
|
|
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
|
2019-07-30 08:12:30 +00:00
|
|
|
* global configuration and data file directory.
|
2001-10-21 21:48:00 +00:00
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC const char *get_systemfile_dir(void);
|
2001-10-21 21:48:00 +00:00
|
|
|
|
2008-01-14 16:40:23 +00:00
|
|
|
/*
|
2010-12-07 20:24:57 +00:00
|
|
|
* Set the configuration profile name to be used for storing
|
2008-01-14 16:40:23 +00:00
|
|
|
* personal configuration files.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC void set_profile_name(const gchar *profilename);
|
2008-01-14 16:40:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the current configuration profile name used for storing
|
|
|
|
* personal configuration files.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC const char *get_profile_name(void);
|
2008-01-14 16:40:23 +00:00
|
|
|
|
2010-10-01 16:29:37 +00:00
|
|
|
/*
|
|
|
|
* Check if current profile is default profile.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC gboolean is_default_profile(void);
|
2010-10-01 16:29:37 +00:00
|
|
|
|
2011-02-26 17:23:24 +00:00
|
|
|
/*
|
2019-07-30 08:12:30 +00:00
|
|
|
* Check if we have global profiles.
|
2011-02-26 17:23:24 +00:00
|
|
|
*/
|
2019-07-30 08:12:30 +00:00
|
|
|
WS_DLL_PUBLIC gboolean has_global_profiles(void);
|
2011-02-26 17:23:24 +00:00
|
|
|
|
2008-01-14 16:40:23 +00:00
|
|
|
/*
|
|
|
|
* Get the directory used to store configuration profile directories.
|
2017-02-18 15:46:24 +00:00
|
|
|
* Caller must free the returned string
|
2008-01-14 16:40:23 +00:00
|
|
|
*/
|
2017-02-18 15:46:24 +00:00
|
|
|
WS_DLL_PUBLIC char *get_profiles_dir(void);
|
2008-01-14 16:40:23 +00:00
|
|
|
|
2018-10-05 06:26:35 +00:00
|
|
|
/*
|
|
|
|
* Get the directory used to store configuration files for a given profile.
|
|
|
|
* Caller must free the returned string.
|
|
|
|
*/
|
2019-07-30 08:12:30 +00:00
|
|
|
WS_DLL_PUBLIC char *get_profile_dir(const char *profilename, gboolean is_global);
|
2018-10-05 06:26:35 +00:00
|
|
|
|
2017-06-20 19:12:48 +00:00
|
|
|
/*
|
|
|
|
* Create the directory used to store configuration profile directories.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC int create_profiles_dir(char **pf_dir_path_return);
|
|
|
|
|
2011-02-26 17:23:24 +00:00
|
|
|
/*
|
2019-07-30 08:12:30 +00:00
|
|
|
* Get the directory used to store global configuration profile directories.
|
2017-02-18 15:46:24 +00:00
|
|
|
* Caller must free the returned string
|
2011-02-26 17:23:24 +00:00
|
|
|
*/
|
2019-07-30 08:12:30 +00:00
|
|
|
WS_DLL_PUBLIC char *get_global_profiles_dir(void);
|
2011-02-26 17:23:24 +00:00
|
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC void profile_store_persconffiles(gboolean store);
|
2009-12-21 12:32:31 +00:00
|
|
|
|
2021-09-21 08:38:05 +00:00
|
|
|
/*
|
|
|
|
* Register a filename to the personal config files storage.
|
|
|
|
* This is for files which are not read using get_persconffile_path() during startup.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC void profile_register_persconffile(const char *filename);
|
|
|
|
|
2008-01-14 16:40:23 +00:00
|
|
|
/*
|
|
|
|
* Check if given configuration profile exists.
|
|
|
|
*/
|
2019-07-30 08:12:30 +00:00
|
|
|
WS_DLL_PUBLIC gboolean profile_exists(const gchar *profilename, gboolean global);
|
2008-01-14 16:40:23 +00:00
|
|
|
|
2010-12-07 20:24:57 +00:00
|
|
|
/*
|
2008-01-14 16:40:23 +00:00
|
|
|
* 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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC int create_persconffile_profile(const char *profilename,
|
2008-01-14 16:40:23 +00:00
|
|
|
char **pf_dir_path_return);
|
|
|
|
|
2019-08-05 08:04:22 +00:00
|
|
|
/*
|
2020-10-10 23:42:05 +00:00
|
|
|
* Returns the list of known profile config filenames
|
2019-08-05 08:04:22 +00:00
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC const GHashTable * allowed_profile_filenames(void);
|
|
|
|
|
2010-12-07 20:24:57 +00:00
|
|
|
/*
|
2008-01-14 16:40:23 +00:00
|
|
|
* 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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC int delete_persconffile_profile(const char *profilename,
|
2008-01-14 16:40:23 +00:00
|
|
|
char **pf_dir_path_return);
|
|
|
|
|
2010-12-07 20:24:57 +00:00
|
|
|
/*
|
2008-01-14 16:40:23 +00:00
|
|
|
* Rename the directory for the given confinguration profile.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC int rename_persconffile_profile(const char *fromname, const char *toname,
|
2010-12-07 20:24:57 +00:00
|
|
|
char **pf_from_dir_path_return,
|
2008-01-14 16:40:23 +00:00
|
|
|
char **pf_to_dir_path_return);
|
|
|
|
|
2010-12-07 20:24:57 +00:00
|
|
|
/*
|
2009-12-21 12:32:31 +00:00
|
|
|
* Copy files in one profile to the other.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC int copy_persconffile_profile(const char *toname, const char *fromname,
|
2019-07-30 08:12:30 +00:00
|
|
|
gboolean from_global,
|
2009-12-21 12:32:31 +00:00
|
|
|
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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC 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
|
|
|
*
|
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
|
|
|
*/
|
2013-04-09 02:48:03 +00:00
|
|
|
WS_DLL_PUBLIC char *get_persconffile_path(const char *filename, gboolean from_profile);
|
2001-10-24 07:18:39 +00:00
|
|
|
|
2013-11-19 19:45:38 +00:00
|
|
|
/*
|
|
|
|
* Set the path of the personal configuration file directory.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC void set_persconffile_dir(const char *p);
|
|
|
|
|
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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC const char *get_persdatafile_dir(void);
|
2007-01-14 22:25:22 +00:00
|
|
|
|
2010-12-07 20:24:57 +00:00
|
|
|
/*
|
2013-11-19 19:45:38 +00:00
|
|
|
* Set the path of the directory in which personal data is stored.
|
2007-03-14 02:55:54 +00:00
|
|
|
*/
|
2013-11-19 19:45:38 +00:00
|
|
|
WS_DLL_PUBLIC void set_persdatafile_dir(const char *p);
|
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
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC 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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC 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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC const char *get_basename(const char *);
|
2007-01-14 22:25:22 +00:00
|
|
|
|
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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC char *find_last_pathname_separator(const char *path);
|
2010-08-10 11:36:18 +00:00
|
|
|
|
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....
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC char *get_dirname(char *);
|
2007-01-14 22:25:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC int test_for_directory(const char *);
|
2007-01-14 22:25:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC int test_for_fifo(const char *);
|
2007-01-14 22:25:22 +00:00
|
|
|
|
2005-04-12 21:12:19 +00:00
|
|
|
/*
|
|
|
|
* Check, if file is existing.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC gboolean file_exists(const char *fname);
|
2005-04-12 21:12:19 +00:00
|
|
|
|
2018-10-10 12:33:40 +00:00
|
|
|
/*
|
|
|
|
* Check if file is existing and has text entries which does not start
|
|
|
|
* with the comment character.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC gboolean config_file_exists_with_entries(const char *fname, char comment_char);
|
|
|
|
|
2005-04-12 21:12:19 +00:00
|
|
|
/*
|
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
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC gboolean files_identical(const char *fname1, const char *fname2);
|
2005-04-12 21:12:19 +00:00
|
|
|
|
2019-09-21 18:43:18 +00:00
|
|
|
/*
|
|
|
|
* Check if file has been recreated since it was opened.
|
|
|
|
*/
|
2019-09-24 05:05:12 +00:00
|
|
|
WS_DLL_PUBLIC gboolean file_needs_reopen(int fd, const char* filename);
|
2019-09-21 18:43:18 +00:00
|
|
|
|
2021-06-06 12:10:22 +00:00
|
|
|
/*
|
|
|
|
* Write content to 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 write 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.
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC gboolean write_file_binary_mode(const char *filename,
|
|
|
|
const void *content, size_t content_len);
|
|
|
|
|
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.
|
|
|
|
*/
|
2013-03-01 23:53:11 +00:00
|
|
|
WS_DLL_PUBLIC gboolean copy_file_binary_mode(const char *from_filename,
|
2009-02-15 21:47:57 +00:00
|
|
|
const char *to_filename);
|
|
|
|
|
2016-12-09 10:46:20 +00:00
|
|
|
|
|
|
|
/*
|
2019-10-10 15:34:46 +00:00
|
|
|
* Given a filename return a filesystem URL. Relative paths are prefixed with
|
|
|
|
* the datafile directory path.
|
2016-12-09 10:46:20 +00:00
|
|
|
*
|
|
|
|
* @param filename A file name or path. Relative paths will be prefixed with
|
2019-10-10 15:34:46 +00:00
|
|
|
* the data file directory path.
|
2016-12-09 10:46:20 +00:00
|
|
|
* @return A filesystem URL for the file or NULL on failure. A non-NULL return
|
|
|
|
* value must be freed with g_free().
|
|
|
|
*/
|
2019-10-10 15:34:46 +00:00
|
|
|
WS_DLL_PUBLIC gchar* data_file_url(const gchar *filename);
|
2016-12-09 10:46:20 +00:00
|
|
|
|
2017-02-08 13:25:57 +00:00
|
|
|
/*
|
|
|
|
* Free the internal structtures
|
|
|
|
*/
|
|
|
|
WS_DLL_PUBLIC void free_progdirs(void);
|
|
|
|
|
2010-12-01 18:25:18 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif /* __cplusplus */
|
|
|
|
|
2000-12-22 22:26:19 +00:00
|
|
|
#endif /* FILESYSTEM_H */
|