/* filesystem.c
* Filesystem utility routines
*
- * $Id: filesystem.c,v 1.12 2001/10/23 08:15:11 guy Exp $
+ * $Id$
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
- *
+ *
* 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.
- *
+ *
* 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.
- *
+ *
* 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.
#include <unistd.h>
#endif
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#include <direct.h> /* to declare "mkdir()" on Windows */
#endif
-#ifndef WIN32
+#ifndef _WIN32
#include <pwd.h>
#endif
* character in the pathname, or NULL if the pathname contains no
* separators.
*/
-char *
-find_last_pathname_separator(char *path)
+static char *
+find_last_pathname_separator(const char *path)
{
char *separator;
-#ifdef WIN32
+#ifdef _WIN32
char c;
/*
* We have to scan for '\' or '/'.
* Get to the end of the string.
*/
- separator = path + strlen(path); /* points to ending '\0' */
+ separator = strchr(path, '\0'); /* points to ending '\0' */
while (separator > path) {
c = *--separator;
if (c == '\\' || c == '/')
/*
* Given a pathname, return the last component.
*/
-char *
-get_basename(char *path)
+const char *
+get_basename(const char *path)
{
- char *filename;
+ const char *filename;
+ g_assert(path != NULL);
filename = find_last_pathname_separator(path);
if (filename == NULL) {
/*
{
char *separator;
+ g_assert(path != NULL);
separator = find_last_pathname_separator(path);
if (separator == NULL) {
/*
return 0;
}
+int
+test_for_fifo(const char *path)
+{
+ struct stat statb;
+
+ if (stat(path, &statb) < 0)
+ return errno;
+
+ if (S_ISFIFO(statb.st_mode))
+ return ESPIPE;
+ else
+ return 0;
+}
+
/*
* Get the directory in which Ethereal's global configuration and data
* files are stored.
+ *
+ * XXX - if we ever make libethereal a real library, used by multiple
+ * applications (more than just Tethereal and versions of Ethereal with
+ * various UIs), should the configuration files belong to the library
+ * (and be shared by all those applications) or to the applications?
+ *
+ * If they belong to the library, that could be done on UNIX by the
+ * configure script, but it's trickier on Windows, as you can't just
+ * use the pathname of the executable.
+ *
+ * If they belong to the application, that could be done on Windows
+ * by using the pathname of the executable, but we'd have to have it
+ * passed in as an argument, in some call, on UNIX.
+ *
+ * Note that some of those configuration files might be used by code in
+ * libethereal, some of them might be used by dissectors (would they
+ * belong to libethereal, the application, or a separate library?),
+ * and some of them might be used by other code (the Ethereal preferences
+ * file includes resolver preferences that control the behavior of code
+ * in libethereal, dissector preferences, and UI preferences, for
+ * example).
*/
const char *
get_datafile_dir(void)
{
-#ifdef WIN32
+#ifdef _WIN32
char prog_pathname[_MAX_PATH+2];
char *dir_end;
size_t datafile_dir_len;
* Now we attempt to get the full pathname of the currently running
* program, under the assumption that we're running an installed
* version of the program. If we fail, we don't change "datafile_dir",
- * and thus end up using DATAFILE_DIR.
+ * and thus end up using the default.
*
* XXX - does NSIS put the installation directory into
* "\HKEY_LOCAL_MACHINE\SOFTWARE\Ethereal\InstallDir"?
const char *
get_systemfile_dir(void)
{
-#ifdef WIN32
+#ifdef _WIN32
return get_datafile_dir();
#else
return "/etc";
/*
* Name of directory, under the user's home directory, in which
* personal configuration files are stored.
- *
+ */
+#ifdef _WIN32
+#define PF_DIR "Ethereal"
+#else
+/*
* XXX - should this be ".libepan"? For backwards-compatibility, I'll keep
* it ".ethereal" for now.
*/
#define PF_DIR ".ethereal"
+#endif
/*
* Get the directory in which personal configuration files reside;
- * it's PF_DIR, under the user's home directory.
+ * in UNIX-compatible systems, it's ".ethereal", under the user's home
+ * directory, and on Windows systems, it's "Ethereal", under %APPDATA%
+ * or, if %APPDATA% isn't set, it's "%USERPROFILE%\Application Data"
+ * (which is what %APPDATA% normally is on Windows 2000).
*/
-const char *
+static const char *
get_persconffile_dir(void)
{
-#ifndef WIN32
+#ifdef _WIN32
+ char *appdatadir;
+ char *userprofiledir;
+#else
+ char *homedir;
struct passwd *pwd;
#endif
- char *homedir;
static char *pf_dir = NULL;
/* Return the cached value, if available */
if (pf_dir != NULL)
return pf_dir;
-#ifdef WIN32
+#ifdef _WIN32
/*
- * Use %USERPROFILE%, so that configuration files are stored
- * in the user profile, rather than in the home directory.
+ * Use %APPDATA% or %USERPROFILE%, so that configuration files are
+ * stored in the user profile, rather than in the home directory.
* The Windows convention is to store configuration information
* in the user profile, and doing so means you can use
* Ethereal even if the home directory is an inaccessible
* network drive.
*/
- homedir = getenv("USERPROFILE");
- if (homedir == NULL) {
+ appdatadir = getenv("APPDATA");
+ if (appdatadir != NULL) {
/*
- * Give up and use "C:".
+ * Concatenate %APPDATA% with "\Ethereal".
*/
- homedir = "C:";
+ pf_dir = g_malloc(strlen(appdatadir) + strlen(PF_DIR) + 2);
+ sprintf(pf_dir, "%s" G_DIR_SEPARATOR_S "%s", appdatadir,
+ PF_DIR);
+ } else {
+ /*
+ * OK, %APPDATA% wasn't set, so use
+ * %USERPROFILE%\Application Data.
+ */
+ userprofiledir = getenv("USERPROFILE");
+ if (userprofiledir != NULL) {
+ pf_dir = g_malloc(strlen(userprofiledir) +
+ strlen("Application Data") + strlen(PF_DIR) + 3);
+ sprintf(pf_dir,
+ "%s" G_DIR_SEPARATOR_S "Application Data" G_DIR_SEPARATOR_S "%s",
+ userprofiledir, PF_DIR);
+ } else {
+ /*
+ * Give up and use "C:".
+ */
+ pf_dir = g_malloc(strlen("C:") + strlen(PF_DIR) + 2);
+ sprintf(pf_dir, "C:" G_DIR_SEPARATOR_S "%s", PF_DIR);
+ }
}
#else
/*
} else
homedir = "/tmp";
}
-#endif
-
pf_dir = g_malloc(strlen(homedir) + strlen(PF_DIR) + 2);
sprintf(pf_dir, "%s" G_DIR_SEPARATOR_S "%s", homedir, PF_DIR);
+#endif
+
return pf_dir;
}
/*
* Create the directory that holds personal configuration files, if
* necessary. If we attempted to create it, and failed, return -1 and
- * set "*pf_dir_path_return" to the pathname of the directory; otherwise,
+ * 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.
*/
int
-create_persconffile_dir(const char **pf_dir_path_return)
+create_persconffile_dir(char **pf_dir_path_return)
{
const char *pf_dir_path;
+#ifdef _WIN32
+ char *pf_dir_path_copy, *pf_dir_parent_path;
+ size_t pf_dir_parent_path_len;
+#endif
struct stat s_buf;
int ret;
pf_dir_path = get_persconffile_dir();
- if (stat(pf_dir_path, &s_buf) != 0) {
-#ifdef WIN32
+ if (stat(pf_dir_path, &s_buf) != 0 && errno == ENOENT) {
+#ifdef _WIN32
+ /*
+ * Does the parent directory of that directory
+ * exist? %APPDATA% may not exist even though
+ * %USERPROFILE% does.
+ *
+ * We check for the existence of the directory
+ * by first checking whether the parent directory
+ * is just a drive letter and, if it's not, by
+ * doing a "stat()" on it. If it's a drive letter,
+ * or if the "stat()" succeeds, we assume it exists.
+ */
+ pf_dir_path_copy = g_strdup(pf_dir_path);
+ pf_dir_parent_path = get_dirname(pf_dir_path_copy);
+ pf_dir_parent_path_len = strlen(pf_dir_parent_path);
+ if (pf_dir_parent_path_len > 0
+ && pf_dir_parent_path[pf_dir_parent_path_len - 1] != ':'
+ && stat(pf_dir_parent_path, &s_buf) != 0) {
+ /*
+ * No, it doesn't exist - make it first.
+ */
+ ret = mkdir(pf_dir_parent_path);
+ if (ret == -1) {
+ *pf_dir_path_return = pf_dir_parent_path;
+ return -1;
+ }
+ }
+ g_free(pf_dir_path_copy);
ret = mkdir(pf_dir_path);
#else
ret = mkdir(pf_dir_path, 0755);
ret = 0;
}
if (ret == -1)
- *pf_dir_path_return = pf_dir_path;
+ *pf_dir_path_return = g_strdup(pf_dir_path);
return ret;
}
+
+#ifdef _WIN32
+/*
+ * Returns the user's home directory on Win32.
+ */
+static const char *
+get_home_dir(void)
+{
+ static const char *home = NULL;
+ char *homedrive, *homepath;
+ char *homestring;
+ char *lastsep;
+
+ /* Return the cached value, if available */
+ if (home)
+ return home;
+
+ /*
+ * XXX - should we use USERPROFILE anywhere in this process?
+ * Is there a chance that it might be set but one or more of
+ * HOMEDRIVE or HOMEPATH isn't set?
+ */
+ homedrive = getenv("HOMEDRIVE");
+ if (homedrive != NULL) {
+ homepath = getenv("HOMEPATH");
+ if (homepath != NULL) {
+ /*
+ * This is cached, so we don't need to worry about
+ * allocating multiple ones of them.
+ */
+ homestring =
+ g_malloc(strlen(homedrive) + strlen(homepath) + 1);
+ strcpy(homestring, homedrive);
+ strcat(homestring, homepath);
+
+ /*
+ * Trim off any trailing slash or backslash.
+ */
+ lastsep = find_last_pathname_separator(homestring);
+ if (lastsep != NULL && *(lastsep + 1) == '\0') {
+ /*
+ * Last separator is the last character
+ * in the string. Nuke it.
+ */
+ *lastsep = '\0';
+ }
+ home = homestring;
+ } else
+ home = homedrive;
+ } else {
+ /*
+ * Give up and use C:.
+ */
+ home = "C:";
+ }
+
+ return home;
+}
+#endif
+
+/*
+ * Construct the path name of a personal configuration file, given the
+ * file name.
+ *
+ * On Win32, if "for_writing" is FALSE, we check whether the file exists
+ * and, if not, construct a path name relative to the ".ethereal"
+ * 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.
+ */
+char *
+get_persconffile_path(const char *filename, gboolean for_writing
+#ifndef _WIN32
+ _U_
+#endif
+)
+{
+ char *path;
+#ifdef _WIN32
+ struct stat s_buf;
+ char *old_path;
+#endif
+
+ path = (gchar *) g_malloc(strlen(get_persconffile_dir()) +
+ strlen(filename) + 2);
+ sprintf(path, "%s" G_DIR_SEPARATOR_S "%s", get_persconffile_dir(),
+ filename);
+#ifdef _WIN32
+ if (!for_writing) {
+ if (stat(path, &s_buf) != 0 && errno == ENOENT) {
+ /*
+ * OK, it's not in the personal configuration file
+ * directory; is it in the ".ethereal" subdirectory
+ * of their home directory?
+ */
+ old_path = (gchar *) g_malloc(strlen(get_home_dir()) +
+ strlen(".ethereal") + strlen(filename) + 3);
+ sprintf(old_path,
+ "%s" G_DIR_SEPARATOR_S ".ethereal" G_DIR_SEPARATOR_S "%s",
+ get_home_dir(), filename);
+ if (stat(old_path, &s_buf) == 0) {
+ /*
+ * OK, it exists; return it instead.
+ */
+ g_free(path);
+ path = old_path;
+ }
+ }
+ }
+#endif
+
+ return path;
+}
+
+/*
+ * Construct the path name of a global configuration file, given the
+ * file name.
+ */
+char *
+get_datafile_path(const char *filename)
+{
+ char *path;
+
+ path = (gchar *) g_malloc(strlen(get_datafile_dir()) +
+ strlen(filename) + 2);
+ sprintf(path, "%s" G_DIR_SEPARATOR_S "%s", get_datafile_dir(),
+ filename);
+
+ return path;
+}
+
+/* Delete a file */
+gboolean
+deletefile(const char *path)
+{
+ return unlink(path) == 0;
+}
+
+/*
+ * Construct and return the path name of a file in the
+ * appropriate temporary file directory.
+ */
+char *get_tempfile_path(const char *filename)
+{
+ char *path;
+
+ path = (gchar *) g_malloc(strlen(g_get_tmp_dir()) +
+ strlen(filename) + 2);
+ sprintf(path, "%s" G_DIR_SEPARATOR_S "%s", g_get_tmp_dir(), filename);
+
+ return path;
+}
+
+/*
+ * Return an error message for UNIX-style errno indications on open or
+ * create operations.
+ */
+char *
+file_open_error_message(int err, gboolean for_writing)
+{
+ char *errmsg;
+ static char errmsg_errno[1024+1];
+
+ switch (err) {
+
+ case ENOENT:
+ if (for_writing)
+ errmsg = "The path to the file \"%s\" doesn't exist.";
+ else
+ errmsg = "The file \"%s\" doesn't exist.";
+ break;
+
+ case EACCES:
+ if (for_writing)
+ errmsg = "You don't have permission to create or write to the file \"%s\".";
+ else
+ errmsg = "You don't have permission to read the file \"%s\".";
+ break;
+
+ case EISDIR:
+ errmsg = "\"%s\" is a directory (folder), not a file.";
+ break;
+
+ case ENOSPC:
+ errmsg = "The file \"%s\" could not be created because there is no space left on the file system.";
+ break;
+
+#ifdef EDQUOT
+ case EDQUOT:
+ errmsg = "The file \"%s\" could not be created because you are too close to, or over, your disk quota.";
+ break;
+#endif
+
+ default:
+ snprintf(errmsg_errno, sizeof(errmsg_errno),
+ "The file \"%%s\" could not be %s: %s.",
+ for_writing ? "created" : "opened",
+ strerror(err));
+ errmsg = errmsg_errno;
+ break;
+ }
+ return errmsg;
+}
+
+/*
+ * Return an error message for UNIX-style errno indications on write
+ * operations.
+ */
+char *
+file_write_error_message(int err)
+{
+ char *errmsg;
+ static char errmsg_errno[1024+1];
+
+ switch (err) {
+
+ case ENOSPC:
+ errmsg = "The file \"%s\" could not be saved because there is no space left on the file system.";
+ break;
+
+#ifdef EDQUOT
+ case EDQUOT:
+ errmsg = "The file \"%s\" could not be saved because you are too close to, or over, your disk quota.";
+ break;
+#endif
+
+ default:
+ snprintf(errmsg_errno, sizeof(errmsg_errno),
+ "An error occurred while writing to the file \"%%s\": %s.",
+ strerror(err));
+ errmsg = errmsg_errno;
+ break;
+ }
+ return errmsg;
+}
+
git.samba.org / obnox / wireshark / wip.git / blobdiff