#include "testutil.h"
#include "apr_file_io.h"
#include "apr_file_info.h"
#include "apr_errno.h"
#include "apr_general.h"
#include "apr_pools.h"
#include "apr_lib.h"
#include "apr_strings.h"
#if defined(WIN32)
#include <direct.h>
#endif
#if defined(WIN32) || defined(OS2)
#define ABS_ROOT "C:/"
#elif defined(NETWARE)
#define ABS_ROOT "SYS:/"
#else
#define ABS_ROOT "/"
#endif
static void merge_aboveroot(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
char errmsg[256];
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo", ABS_ROOT"bar", APR_FILEPATH_NOTABOVEROOT,
p);
apr_strerror(rv, errmsg, sizeof(errmsg));
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EABOVEROOT(rv));
ABTS_PTR_EQUAL(tc, NULL, dstpath);
ABTS_STR_EQUAL(tc, "The given path was above the root path", errmsg);
}
static void merge_belowroot(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo", ABS_ROOT"foo/bar",
APR_FILEPATH_NOTABOVEROOT, p);
ABTS_PTR_NOTNULL(tc, dstpath);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, ABS_ROOT"foo/bar", dstpath);
}
static void merge_noflag(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo", ABS_ROOT"foo/bar", 0, p);
ABTS_PTR_NOTNULL(tc, dstpath);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, ABS_ROOT"foo/bar", dstpath);
}
static void merge_dotdot(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo/bar", "../baz", 0, p);
ABTS_PTR_NOTNULL(tc, dstpath);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, ABS_ROOT"foo/baz", dstpath);
rv = apr_filepath_merge(&dstpath, "", "../test", 0, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "../test", dstpath);
rv = apr_filepath_merge(&dstpath, "", "../test", APR_FILEPATH_TRUENAME, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "../test", dstpath);
}
static void merge_dotdot_dotdot_dotdot(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
rv = apr_filepath_merge(&dstpath, "",
"../../..", APR_FILEPATH_TRUENAME, p);
ABTS_PTR_NOTNULL(tc, dstpath);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "../../..", dstpath);
rv = apr_filepath_merge(&dstpath, "",
"../../../", APR_FILEPATH_TRUENAME, p);
ABTS_PTR_NOTNULL(tc, dstpath);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "../../../", dstpath);
}
static void merge_secure(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo/bar", "../bar/baz", 0, p);
ABTS_PTR_NOTNULL(tc, dstpath);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, ABS_ROOT"foo/bar/baz", dstpath);
}
static void merge_notrel(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo/bar", "../baz",
APR_FILEPATH_NOTRELATIVE, p);
ABTS_PTR_NOTNULL(tc, dstpath);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, ABS_ROOT"foo/baz", dstpath);
}
static void merge_notrelfail(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
char errmsg[256];
rv = apr_filepath_merge(&dstpath, "foo/bar", "../baz",
APR_FILEPATH_NOTRELATIVE, p);
apr_strerror(rv, errmsg, sizeof(errmsg));
ABTS_PTR_EQUAL(tc, NULL, dstpath);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ERELATIVE(rv));
ABTS_STR_EQUAL(tc, "The given path is relative", errmsg);
}
static void merge_notabsfail(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
char errmsg[256];
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo/bar", "../baz",
APR_FILEPATH_NOTABSOLUTE, p);
apr_strerror(rv, errmsg, sizeof(errmsg));
ABTS_PTR_EQUAL(tc, NULL, dstpath);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EABSOLUTE(rv));
ABTS_STR_EQUAL(tc, "The given path is absolute", errmsg);
}
static void merge_notabs(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
rv = apr_filepath_merge(&dstpath, "foo/bar", "../baz",
APR_FILEPATH_NOTABSOLUTE, p);
ABTS_PTR_NOTNULL(tc, dstpath);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "foo/baz", dstpath);
}
#if defined (WIN32)
static void merge_lowercasedrive(abts_case *tc, void *data)
{
char current_dir[1024];
char current_dir_on_C[1024];
char *dir_on_c;
char *testdir;
apr_status_t rv;
ABTS_PTR_NOTNULL(tc, _getcwd(current_dir, sizeof(current_dir)));
ABTS_PTR_NOTNULL(tc, _getdcwd(3, current_dir_on_C,
sizeof(current_dir_on_C)));
dir_on_c = apr_pstrdup(p, current_dir_on_C);
dir_on_c[0] = (char)tolower(dir_on_c[0]);
chdir(dir_on_c);
rv = apr_filepath_merge(&testdir, NULL, "C:hi",
APR_FILEPATH_NOTRELATIVE, p);
chdir("C:\\");
chdir(current_dir_on_C);
chdir(current_dir);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
#endif
static void root_absolute(abts_case *tc, void *data)
{
apr_status_t rv;
const char *root = NULL;
const char *path = ABS_ROOT"foo/bar";
rv = apr_filepath_root(&root, &path, 0, p);
ABTS_PTR_NOTNULL(tc, root);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, ABS_ROOT, root);
}
static void root_relative(abts_case *tc, void *data)
{
apr_status_t rv;
const char *root = NULL;
const char *path = "foo/bar";
char errmsg[256];
rv = apr_filepath_root(&root, &path, 0, p);
apr_strerror(rv, errmsg, sizeof(errmsg));
ABTS_PTR_EQUAL(tc, NULL, root);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ERELATIVE(rv));
ABTS_STR_EQUAL(tc, "The given path is relative", errmsg);
}
static void root_from_slash(abts_case *tc, void *data)
{
apr_status_t rv;
const char *root = NULL;
const char *path = "//";
rv = apr_filepath_root(&root, &path, APR_FILEPATH_TRUENAME, p);
#if defined(WIN32) || defined(OS2)
ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
ABTS_STR_EQUAL(tc, "//", root);
#else
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "/", root);
#endif
ABTS_STR_EQUAL(tc, "", path);
}
static void root_from_cwd_and_back(abts_case *tc, void *data)
{
apr_status_t rv;
const char *root = NULL;
const char *path = "//";
char *origpath;
char *testpath;
#if defined(WIN32) || defined(OS2) || defined(NETWARE)
int hadfailed;
#endif
ABTS_INT_EQUAL(tc, APR_SUCCESS, apr_filepath_get(&origpath, 0, p));
path = origpath;
rv = apr_filepath_root(&root, &path, APR_FILEPATH_TRUENAME, p);
#if defined(WIN32) || defined(OS2)
hadfailed = tc->failed;
ABTS_INT_EQUAL(tc, toupper(origpath[0]), root[0]);
ABTS_INT_EQUAL(tc, ':', root[1]);
ABTS_INT_EQUAL(tc, '/', root[2]);
ABTS_INT_EQUAL(tc, 0, root[3]);
ABTS_STR_EQUAL(tc, origpath + 3, path);
#elif defined(NETWARE)
ABTS_INT_EQUAL(tc, origpath[0], root[0]);
{
char *pt = strchr(root, ':');
ABTS_PTR_NOTNULL(tc, pt);
ABTS_INT_EQUAL(tc, ':', pt[0]);
ABTS_INT_EQUAL(tc, '/', pt[1]);
ABTS_INT_EQUAL(tc, 0, pt[2]);
pt = strchr(origpath, ':');
ABTS_PTR_NOTNULL(tc, pt);
ABTS_STR_EQUAL(tc, (pt+2), path);
}
#else
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "/", root);
ABTS_STR_EQUAL(tc, origpath + 1, path);
#endif
rv = apr_filepath_merge(&testpath, root, path,
APR_FILEPATH_TRUENAME
| APR_FILEPATH_NOTABOVEROOT
| APR_FILEPATH_NOTRELATIVE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
#if defined(WIN32) || defined(OS2) || defined(NETWARE)
hadfailed = tc->failed;
#endif
ABTS_STR_EQUAL(tc, origpath, testpath);
#if defined(WIN32) || defined(OS2) || defined(NETWARE)
if (!hadfailed) tc->failed = 0;
#endif
}
abts_suite *testnames(abts_suite *suite)
{
suite = ADD_SUITE(suite)
abts_run_test(suite, merge_aboveroot, NULL);
abts_run_test(suite, merge_belowroot, NULL);
abts_run_test(suite, merge_noflag, NULL);
abts_run_test(suite, merge_dotdot, NULL);
abts_run_test(suite, merge_secure, NULL);
abts_run_test(suite, merge_notrel, NULL);
abts_run_test(suite, merge_notrelfail, NULL);
abts_run_test(suite, merge_notabs, NULL);
abts_run_test(suite, merge_notabsfail, NULL);
abts_run_test(suite, merge_dotdot_dotdot_dotdot, NULL);
#if defined(WIN32)
abts_run_test(suite, merge_lowercasedrive, NULL);
#endif
abts_run_test(suite, root_absolute, NULL);
abts_run_test(suite, root_relative, NULL);
abts_run_test(suite, root_from_slash, NULL);
abts_run_test(suite, root_from_cwd_and_back, NULL);
return suite;
}