2003-11-12 00:52:45 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* path.c
|
|
|
|
* portable path handling routines
|
|
|
|
*
|
2004-08-29 06:13:13 +02:00
|
|
|
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
|
2003-11-12 00:52:45 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2004-08-29 07:07:03 +02:00
|
|
|
* $PostgreSQL: pgsql/src/port/path.c,v 1.33 2004/08/29 05:07:02 momjian Exp $
|
2003-11-12 00:52:45 +01:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
2003-04-04 22:42:13 +02:00
|
|
|
|
|
|
|
#include "c.h"
|
2004-05-21 22:56:50 +02:00
|
|
|
|
2003-04-04 22:42:13 +02:00
|
|
|
#include <ctype.h>
|
|
|
|
|
2004-05-21 22:56:50 +02:00
|
|
|
#include "pg_config_paths.h"
|
|
|
|
|
|
|
|
|
2004-05-17 16:35:34 +02:00
|
|
|
#ifndef WIN32
|
2004-08-29 07:07:03 +02:00
|
|
|
#define IS_DIR_SEP(ch) ((ch) == '/')
|
2004-05-17 16:35:34 +02:00
|
|
|
#else
|
2004-08-29 07:07:03 +02:00
|
|
|
#define IS_DIR_SEP(ch) ((ch) == '/' || (ch) == '\\')
|
2004-06-11 00:26:24 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef WIN32
|
2004-08-29 07:07:03 +02:00
|
|
|
#define IS_PATH_SEP(ch) ((ch) == ':')
|
2004-06-11 00:26:24 +02:00
|
|
|
#else
|
2004-08-29 07:07:03 +02:00
|
|
|
#define IS_PATH_SEP(ch) ((ch) == ';')
|
2004-05-17 16:35:34 +02:00
|
|
|
#endif
|
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
const static char *relative_path(const char *bin_path, const char *other_path);
|
2004-07-11 23:34:04 +02:00
|
|
|
static void make_relative(const char *my_exec_path, const char *p, char *ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
static void trim_directory(char *path);
|
|
|
|
static void trim_trailing_separator(char *path);
|
|
|
|
|
|
|
|
/* Move to last of consecutive separators or to null byte */
|
|
|
|
#define MOVE_TO_SEP_END(p) \
|
|
|
|
{ \
|
2004-06-11 00:26:24 +02:00
|
|
|
while (IS_DIR_SEP((p)[0]) && (IS_DIR_SEP((p)[1]) || !(p)[1])) \
|
2004-05-17 16:35:34 +02:00
|
|
|
(p)++; \
|
|
|
|
}
|
|
|
|
|
2004-06-11 00:26:24 +02:00
|
|
|
/*
|
|
|
|
* first_dir_separator
|
|
|
|
*/
|
|
|
|
char *
|
|
|
|
first_dir_separator(const char *filename)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
for (p = (char *) filename; *p; p++)
|
2004-06-11 00:26:24 +02:00
|
|
|
if (IS_DIR_SEP(*p))
|
|
|
|
return p;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2003-04-04 22:42:13 +02:00
|
|
|
/*
|
|
|
|
* first_path_separator
|
|
|
|
*/
|
2003-08-04 02:43:34 +02:00
|
|
|
char *
|
|
|
|
first_path_separator(const char *filename)
|
2003-04-04 22:42:13 +02:00
|
|
|
{
|
2004-05-17 16:35:34 +02:00
|
|
|
char *p;
|
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
for (p = (char *) filename; *p; p++)
|
2004-06-11 00:26:24 +02:00
|
|
|
if (IS_PATH_SEP(*p))
|
2004-05-17 16:35:34 +02:00
|
|
|
return p;
|
|
|
|
return NULL;
|
2003-04-04 22:42:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2004-06-11 00:26:24 +02:00
|
|
|
* last_dir_separator
|
2003-04-04 22:42:13 +02:00
|
|
|
*/
|
2003-08-04 02:43:34 +02:00
|
|
|
char *
|
2004-06-11 00:26:24 +02:00
|
|
|
last_dir_separator(const char *filename)
|
2003-04-04 22:42:13 +02:00
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
char *p,
|
|
|
|
*ret = NULL;
|
2004-05-17 16:35:34 +02:00
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
for (p = (char *) filename; *p; p++)
|
2004-06-11 00:26:24 +02:00
|
|
|
if (IS_DIR_SEP(*p))
|
2004-05-17 16:35:34 +02:00
|
|
|
ret = p;
|
|
|
|
return ret;
|
2003-04-04 22:42:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-08-12 20:32:52 +02:00
|
|
|
/*
|
2004-08-12 21:03:44 +02:00
|
|
|
* make_native_path - on WIN32, change / to \ in the path
|
|
|
|
*
|
|
|
|
* This is required because WIN32 COPY is an internal CMD.EXE
|
|
|
|
* command and doesn't process forward slashes in the same way
|
|
|
|
* as external commands. Quoting the first argument to COPY
|
|
|
|
* does not convert forward to backward slashes, but COPY does
|
|
|
|
* properly process quoted forward slashes in the second argument.
|
|
|
|
*
|
|
|
|
* COPY works with quoted forward slashes in the first argument
|
|
|
|
* only if the current directory is the same as the directory
|
|
|
|
* of the first argument.
|
2004-08-12 20:32:52 +02:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
make_native_path(char *filename)
|
|
|
|
{
|
|
|
|
#ifdef WIN32
|
2004-08-29 07:07:03 +02:00
|
|
|
char *p;
|
|
|
|
|
2004-08-12 20:32:52 +02:00
|
|
|
for (p = filename; *p; p++)
|
|
|
|
if (*p == '/')
|
|
|
|
*p = '\\';
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-03-09 05:49:02 +01:00
|
|
|
/*
|
2004-07-12 21:15:14 +02:00
|
|
|
* Make all paths look like Unix
|
2004-03-09 05:49:02 +01:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
canonicalize_path(char *path)
|
|
|
|
{
|
2004-05-17 16:35:34 +02:00
|
|
|
#ifdef WIN32
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-07-12 21:15:14 +02:00
|
|
|
/*
|
|
|
|
* The Windows command processor will accept suitably quoted paths
|
|
|
|
* with forward slashes, but barfs badly with mixed forward and back
|
|
|
|
* slashes.
|
|
|
|
*/
|
2004-03-09 05:49:02 +01:00
|
|
|
char *p;
|
|
|
|
|
|
|
|
for (p = path; *p; p++)
|
|
|
|
{
|
|
|
|
if (*p == '\\')
|
|
|
|
*p = '/';
|
|
|
|
}
|
2004-07-12 21:27:31 +02:00
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
/*
|
|
|
|
* In Win32, if you do: prog.exe "a b" "\c\d\" the system will pass
|
|
|
|
* \c\d" as argv[2].
|
2004-07-12 21:15:14 +02:00
|
|
|
*/
|
2004-08-29 07:07:03 +02:00
|
|
|
if (p > path && *(p - 1) == '"')
|
|
|
|
*(p - 1) = '/';
|
2004-05-17 16:35:34 +02:00
|
|
|
#endif
|
|
|
|
|
2004-07-12 21:15:14 +02:00
|
|
|
/*
|
2004-08-29 07:07:03 +02:00
|
|
|
* Removing the trailing slash on a path means we never get ugly
|
|
|
|
* double slashes. Also, Win32 can't stat() a directory with a
|
|
|
|
* trailing slash. Don't remove a leading slash, though.
|
2004-07-12 21:15:14 +02:00
|
|
|
*/
|
2004-05-17 16:35:34 +02:00
|
|
|
trim_trailing_separator(path);
|
2004-08-09 22:20:47 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove any trailing uses of "." or "..", too.
|
|
|
|
*/
|
|
|
|
for (;;)
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
int len = strlen(path);
|
2004-08-09 22:20:47 +02:00
|
|
|
|
|
|
|
if (len >= 2 && strcmp(path + len - 2, "/.") == 0)
|
|
|
|
{
|
|
|
|
trim_directory(path);
|
|
|
|
trim_trailing_separator(path);
|
|
|
|
}
|
|
|
|
else if (len >= 3 && strcmp(path + len - 3, "/..") == 0)
|
|
|
|
{
|
|
|
|
trim_directory(path);
|
|
|
|
trim_directory(path);
|
|
|
|
trim_trailing_separator(path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2004-03-09 05:49:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-04-04 22:42:13 +02:00
|
|
|
/*
|
|
|
|
* Extracts the actual name of the program as called.
|
|
|
|
*/
|
2004-05-12 15:38:49 +02:00
|
|
|
const char *
|
|
|
|
get_progname(const char *argv0)
|
2003-04-04 22:42:13 +02:00
|
|
|
{
|
2004-06-11 00:26:24 +02:00
|
|
|
if (!last_dir_separator(argv0))
|
2003-04-04 22:42:13 +02:00
|
|
|
return argv0;
|
|
|
|
else
|
2004-06-11 00:26:24 +02:00
|
|
|
return last_dir_separator(argv0) + 1;
|
2003-04-04 22:42:13 +02:00
|
|
|
}
|
2004-05-11 23:57:15 +02:00
|
|
|
|
2004-05-17 16:35:34 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* get_share_path
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_share_path(const char *my_exec_path, char *ret_path)
|
|
|
|
{
|
2004-05-25 22:47:41 +02:00
|
|
|
const char *p;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
if ((p = relative_path(PGBINDIR, PGSHAREDIR)))
|
2004-07-11 23:34:04 +02:00
|
|
|
make_relative(my_exec_path, p, ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
else
|
2004-05-21 22:56:50 +02:00
|
|
|
StrNCpy(ret_path, PGSHAREDIR, MAXPGPATH);
|
2004-07-11 23:34:04 +02:00
|
|
|
canonicalize_path(ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get_etc_path
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_etc_path(const char *my_exec_path, char *ret_path)
|
|
|
|
{
|
2004-05-25 22:47:41 +02:00
|
|
|
const char *p;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
if ((p = relative_path(PGBINDIR, SYSCONFDIR)))
|
2004-07-11 23:34:04 +02:00
|
|
|
make_relative(my_exec_path, p, ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
else
|
|
|
|
StrNCpy(ret_path, SYSCONFDIR, MAXPGPATH);
|
2004-07-11 23:34:04 +02:00
|
|
|
canonicalize_path(ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get_include_path
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_include_path(const char *my_exec_path, char *ret_path)
|
|
|
|
{
|
2004-05-25 22:47:41 +02:00
|
|
|
const char *p;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
if ((p = relative_path(PGBINDIR, INCLUDEDIR)))
|
2004-07-11 23:34:04 +02:00
|
|
|
make_relative(my_exec_path, p, ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
else
|
|
|
|
StrNCpy(ret_path, INCLUDEDIR, MAXPGPATH);
|
2004-07-11 23:34:04 +02:00
|
|
|
canonicalize_path(ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get_pkginclude_path
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_pkginclude_path(const char *my_exec_path, char *ret_path)
|
|
|
|
{
|
2004-05-25 22:47:41 +02:00
|
|
|
const char *p;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
if ((p = relative_path(PGBINDIR, PKGINCLUDEDIR)))
|
2004-07-11 23:34:04 +02:00
|
|
|
make_relative(my_exec_path, p, ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
else
|
|
|
|
StrNCpy(ret_path, PKGINCLUDEDIR, MAXPGPATH);
|
2004-07-11 23:34:04 +02:00
|
|
|
canonicalize_path(ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2004-08-01 08:56:39 +02:00
|
|
|
/*
|
|
|
|
* get_includeserver_path
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_includeserver_path(const char *my_exec_path, char *ret_path)
|
|
|
|
{
|
|
|
|
const char *p;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-01 08:56:39 +02:00
|
|
|
if ((p = relative_path(PGBINDIR, INCLUDEDIRSERVER)))
|
|
|
|
make_relative(my_exec_path, p, ret_path);
|
|
|
|
else
|
|
|
|
StrNCpy(ret_path, INCLUDEDIRSERVER, MAXPGPATH);
|
|
|
|
canonicalize_path(ret_path);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get_lib_path
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_lib_path(const char *my_exec_path, char *ret_path)
|
|
|
|
{
|
|
|
|
const char *p;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-01 08:56:39 +02:00
|
|
|
if ((p = relative_path(PGBINDIR, LIBDIR)))
|
|
|
|
make_relative(my_exec_path, p, ret_path);
|
|
|
|
else
|
|
|
|
StrNCpy(ret_path, LIBDIR, MAXPGPATH);
|
|
|
|
canonicalize_path(ret_path);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2004-05-17 16:35:34 +02:00
|
|
|
/*
|
|
|
|
* get_pkglib_path
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_pkglib_path(const char *my_exec_path, char *ret_path)
|
|
|
|
{
|
2004-05-25 22:47:41 +02:00
|
|
|
const char *p;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
if ((p = relative_path(PGBINDIR, PKGLIBDIR)))
|
2004-07-11 23:34:04 +02:00
|
|
|
make_relative(my_exec_path, p, ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
else
|
|
|
|
StrNCpy(ret_path, PKGLIBDIR, MAXPGPATH);
|
2004-07-11 23:34:04 +02:00
|
|
|
canonicalize_path(ret_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2004-05-25 03:00:30 +02:00
|
|
|
/*
|
|
|
|
* get_locale_path
|
|
|
|
*
|
|
|
|
* Return locale path, either relative to /bin or hardcoded
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get_locale_path(const char *my_exec_path, char *ret_path)
|
|
|
|
{
|
2004-05-25 22:47:41 +02:00
|
|
|
const char *p;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
if ((p = relative_path(PGBINDIR, LOCALEDIR)))
|
2004-07-11 23:34:04 +02:00
|
|
|
make_relative(my_exec_path, p, ret_path);
|
2004-05-25 03:00:30 +02:00
|
|
|
else
|
|
|
|
StrNCpy(ret_path, LOCALEDIR, MAXPGPATH);
|
2004-07-11 23:34:04 +02:00
|
|
|
canonicalize_path(ret_path);
|
2004-05-25 03:00:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2004-06-03 02:07:38 +02:00
|
|
|
* set_pglocale_pgservice
|
2004-05-25 03:00:30 +02:00
|
|
|
*
|
2004-06-03 02:07:38 +02:00
|
|
|
* Set application-specific locale and service directory
|
2004-05-25 03:00:30 +02:00
|
|
|
*
|
|
|
|
* This function takes an argv[0] rather than a full path.
|
|
|
|
*/
|
|
|
|
void
|
2004-06-03 02:07:38 +02:00
|
|
|
set_pglocale_pgservice(const char *argv0, const char *app)
|
2004-05-25 03:00:30 +02:00
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
char path[MAXPGPATH];
|
|
|
|
char my_exec_path[MAXPGPATH];
|
|
|
|
char env_path[MAXPGPATH + sizeof("PGSYSCONFDIR=")]; /* longer than
|
|
|
|
* PGLOCALEDIR */
|
2004-05-25 03:00:30 +02:00
|
|
|
|
2004-05-25 03:42:08 +02:00
|
|
|
/* don't set LC_ALL in the backend */
|
|
|
|
if (strcmp(app, "postgres") != 0)
|
|
|
|
setlocale(LC_ALL, "");
|
|
|
|
|
2004-05-25 03:00:30 +02:00
|
|
|
if (find_my_exec(argv0, my_exec_path) < 0)
|
|
|
|
return;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-06-03 02:07:38 +02:00
|
|
|
#ifdef ENABLE_NLS
|
2004-05-25 20:18:29 +02:00
|
|
|
get_locale_path(my_exec_path, path);
|
2004-05-25 03:00:30 +02:00
|
|
|
bindtextdomain(app, path);
|
|
|
|
textdomain(app);
|
2004-06-03 02:07:38 +02:00
|
|
|
|
2004-07-11 00:58:42 +02:00
|
|
|
if (getenv("PGLOCALEDIR") == NULL)
|
2004-06-03 02:07:38 +02:00
|
|
|
{
|
|
|
|
/* set for libpq to use */
|
2004-07-11 00:58:42 +02:00
|
|
|
snprintf(env_path, sizeof(env_path), "PGLOCALEDIR=%s", path);
|
2004-08-13 16:47:23 +02:00
|
|
|
canonicalize_path(env_path + 12);
|
2004-07-11 00:58:42 +02:00
|
|
|
putenv(strdup(env_path));
|
2004-06-03 02:07:38 +02:00
|
|
|
}
|
2004-05-25 03:00:30 +02:00
|
|
|
#endif
|
2004-06-03 02:07:38 +02:00
|
|
|
|
2004-07-11 00:58:42 +02:00
|
|
|
if (getenv("PGSYSCONFDIR") == NULL)
|
2004-06-03 02:07:38 +02:00
|
|
|
{
|
|
|
|
get_etc_path(my_exec_path, path);
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-06-03 02:07:38 +02:00
|
|
|
/* set for libpq to use */
|
2004-07-11 00:58:42 +02:00
|
|
|
snprintf(env_path, sizeof(env_path), "PGSYSCONFDIR=%s", path);
|
2004-08-13 16:47:23 +02:00
|
|
|
canonicalize_path(env_path + 13);
|
2004-07-11 00:58:42 +02:00
|
|
|
putenv(strdup(env_path));
|
2004-06-03 02:07:38 +02:00
|
|
|
}
|
2004-05-25 03:00:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-08-18 04:59:12 +02:00
|
|
|
/*
|
|
|
|
* get_include_path
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
get_home_path(char *ret_path)
|
|
|
|
{
|
|
|
|
if (getenv(HOMEDIR) == NULL)
|
|
|
|
{
|
|
|
|
*ret_path = '\0';
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
StrNCpy(ret_path, getenv(HOMEDIR), MAXPGPATH);
|
|
|
|
canonicalize_path(ret_path);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2004-07-11 23:34:04 +02:00
|
|
|
/*
|
|
|
|
* make_relative - adjust path to be relative to bin/
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
make_relative(const char *my_exec_path, const char *p, char *ret_path)
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
char path[MAXPGPATH];
|
2004-07-11 23:34:04 +02:00
|
|
|
|
|
|
|
StrNCpy(path, my_exec_path, MAXPGPATH);
|
|
|
|
trim_directory(path);
|
|
|
|
trim_directory(path);
|
|
|
|
snprintf(ret_path, MAXPGPATH, "%s/%s", path, p);
|
|
|
|
}
|
|
|
|
|
2004-05-25 03:00:30 +02:00
|
|
|
|
2004-05-17 16:35:34 +02:00
|
|
|
/*
|
|
|
|
* relative_path
|
|
|
|
*
|
|
|
|
* Do the supplied paths differ only in their last component?
|
|
|
|
*/
|
2004-05-25 22:47:41 +02:00
|
|
|
static const char *
|
|
|
|
relative_path(const char *bin_path, const char *other_path)
|
2004-05-17 16:35:34 +02:00
|
|
|
{
|
2004-05-25 22:47:41 +02:00
|
|
|
const char *other_sep = other_path;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-05-17 16:35:34 +02:00
|
|
|
#ifdef WIN32
|
|
|
|
/* Driver letters match? */
|
2004-05-25 22:47:41 +02:00
|
|
|
if (isalpha(*bin_path) && bin_path[1] == ':' &&
|
|
|
|
(!isalpha(*other_path) || !other_path[1] == ':'))
|
|
|
|
return NULL;
|
|
|
|
if ((!isalpha(*bin_path) || !bin_path[1] == ':') &&
|
|
|
|
(isalpha(*other_path) && other_path[1] == ':'))
|
|
|
|
return NULL;
|
|
|
|
if (isalpha(*bin_path) && bin_path[1] == ':' &&
|
|
|
|
isalpha(*other_path) && other_path[1] == ':')
|
2004-05-17 16:35:34 +02:00
|
|
|
{
|
2004-05-25 22:47:41 +02:00
|
|
|
if (toupper(*bin_path) != toupper(*other_path))
|
|
|
|
return NULL;
|
|
|
|
bin_path += 2;
|
|
|
|
other_path += 2;
|
|
|
|
other_sep = other_path + 1; /* past separator */
|
2004-05-17 16:35:34 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
/* Move past adjacent slashes like //, and trailing ones */
|
2004-05-25 22:47:41 +02:00
|
|
|
MOVE_TO_SEP_END(bin_path);
|
|
|
|
MOVE_TO_SEP_END(other_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
|
|
|
|
/* One of the paths is done? */
|
2004-05-25 22:47:41 +02:00
|
|
|
if (!*bin_path || !*other_path)
|
2004-05-17 16:35:34 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Win32 filesystem is case insensitive */
|
2004-06-11 00:26:24 +02:00
|
|
|
if ((!IS_DIR_SEP(*bin_path) || !IS_DIR_SEP(*other_path)) &&
|
2004-05-17 16:35:34 +02:00
|
|
|
#ifndef WIN32
|
2004-07-11 00:58:42 +02:00
|
|
|
*bin_path != *other_path
|
2004-05-17 16:35:34 +02:00
|
|
|
#else
|
2004-08-29 07:07:03 +02:00
|
|
|
toupper((unsigned char) *bin_path) != toupper((unsigned char) *other_path)
|
2004-05-17 16:35:34 +02:00
|
|
|
#endif
|
2004-07-11 00:58:42 +02:00
|
|
|
)
|
|
|
|
break;
|
2004-05-17 16:35:34 +02:00
|
|
|
|
2004-06-11 00:26:24 +02:00
|
|
|
if (IS_DIR_SEP(*other_path))
|
2004-08-29 07:07:03 +02:00
|
|
|
other_sep = other_path + 1; /* past separator */
|
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
bin_path++;
|
|
|
|
other_path++;
|
2004-05-17 16:35:34 +02:00
|
|
|
}
|
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
/* identical? */
|
|
|
|
if (!*bin_path && !*other_path)
|
|
|
|
return NULL;
|
2004-05-17 16:35:34 +02:00
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
/* advance past directory name */
|
2004-06-11 00:26:24 +02:00
|
|
|
while (!IS_DIR_SEP(*bin_path) && *bin_path)
|
2004-05-25 22:47:41 +02:00
|
|
|
bin_path++;
|
2004-05-17 16:35:34 +02:00
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
MOVE_TO_SEP_END(bin_path);
|
2004-05-17 16:35:34 +02:00
|
|
|
|
2004-05-25 22:47:41 +02:00
|
|
|
/* Is bin done? */
|
|
|
|
if (!*bin_path)
|
|
|
|
return other_path;
|
2004-05-17 16:35:34 +02:00
|
|
|
else
|
2004-05-25 22:47:41 +02:00
|
|
|
return NULL;
|
2004-05-17 16:35:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* trim_directory
|
|
|
|
*
|
|
|
|
* Trim trailing directory from path
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
trim_directory(char *path)
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
char *p;
|
|
|
|
|
2004-05-17 16:35:34 +02:00
|
|
|
if (path[0] == '\0')
|
|
|
|
return;
|
|
|
|
|
2004-06-11 00:26:24 +02:00
|
|
|
for (p = path + strlen(path) - 1; IS_DIR_SEP(*p) && p > path; p--)
|
2004-05-17 16:35:34 +02:00
|
|
|
;
|
2004-06-11 00:26:24 +02:00
|
|
|
for (; !IS_DIR_SEP(*p) && p > path; p--)
|
2004-05-17 16:35:34 +02:00
|
|
|
;
|
|
|
|
*p = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* trim_trailing_separator
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
trim_trailing_separator(char *path)
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
char *p = path + strlen(path);
|
2004-07-11 04:59:42 +02:00
|
|
|
|
|
|
|
#ifdef WIN32
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-07-11 23:34:04 +02:00
|
|
|
/*
|
2004-08-29 07:07:03 +02:00
|
|
|
* Skip over network and drive specifiers for win32. Set 'path' to
|
|
|
|
* point to the last character we must keep.
|
2004-07-11 23:34:04 +02:00
|
|
|
*/
|
2004-08-29 07:07:03 +02:00
|
|
|
if (strlen(path) >= 2)
|
|
|
|
{
|
|
|
|
if (IS_DIR_SEP(path[0]) && IS_DIR_SEP(path[1]))
|
|
|
|
{
|
|
|
|
path += 2;
|
2004-07-11 04:59:42 +02:00
|
|
|
while (*path && !IS_DIR_SEP(*path))
|
|
|
|
path++;
|
|
|
|
}
|
2004-08-29 07:07:03 +02:00
|
|
|
else if (isalpha(path[0]) && path[1] == ':')
|
|
|
|
{
|
|
|
|
path++;
|
|
|
|
if (IS_DIR_SEP(path[1]))
|
|
|
|
path++;
|
|
|
|
}
|
|
|
|
}
|
2004-07-11 04:59:42 +02:00
|
|
|
#endif
|
|
|
|
|
2004-05-17 16:35:34 +02:00
|
|
|
/* trim off trailing slashes */
|
|
|
|
if (p > path)
|
2004-07-11 00:58:42 +02:00
|
|
|
for (p--; p > path && IS_DIR_SEP(*p); p--)
|
2004-05-17 16:35:34 +02:00
|
|
|
*p = '\0';
|
|
|
|
}
|