315 lines
10 KiB
C
315 lines
10 KiB
C
|
/* Licensed to the Apache Software Foundation (ASF) under one or more
|
||
|
|
* contributor license agreements. See the NOTICE file distributed with
|
||
|
|
* this work for additional information regarding copyright ownership.
|
||
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
||
|
|
* (the "License"); you may not use this file except in compliance with
|
||
|
|
* the License. You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "apr.h"
|
||
|
|
#include "apr_private.h"
|
||
|
|
#include "apr_arch_file_io.h"
|
||
|
|
#include "apr_file_io.h"
|
||
|
|
#include "apr_strings.h"
|
||
|
|
#define APR_WANT_STRFUNC
|
||
|
|
#include "apr_want.h"
|
||
|
|
#if APR_HAVE_UNISTD_H
|
||
|
|
#include <unistd.h>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* Win32 malpropism that can go away once everyone believes this
|
||
|
|
* code is golden, and I'm not testing it anymore :-)
|
||
|
|
*/
|
||
|
|
#if APR_HAVE_DIRENT_H
|
||
|
|
#include <dirent.h>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* Any OS that requires/refuses trailing slashes should be dealt with here.
|
||
|
|
*/
|
||
|
|
APR_DECLARE(apr_status_t) apr_filepath_get(char **defpath, apr_int32_t flags,
|
||
|
|
apr_pool_t *p)
|
||
|
|
{
|
||
|
|
char path[APR_PATH_MAX];
|
||
|
|
|
||
|
|
if (!getcwd(path, sizeof(path))) {
|
||
|
|
if (errno == ERANGE)
|
||
|
|
return APR_ENAMETOOLONG;
|
||
|
|
else
|
||
|
|
return errno;
|
||
|
|
}
|
||
|
|
*defpath = apr_pstrdup(p, path);
|
||
|
|
|
||
|
|
return APR_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* Any OS that requires/refuses trailing slashes should be dealt with here
|
||
|
|
*/
|
||
|
|
APR_DECLARE(apr_status_t) apr_filepath_set(const char *path, apr_pool_t *p)
|
||
|
|
{
|
||
|
|
if (chdir(path) != 0)
|
||
|
|
return errno;
|
||
|
|
|
||
|
|
return APR_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
APR_DECLARE(apr_status_t) apr_filepath_root(const char **rootpath,
|
||
|
|
const char **inpath,
|
||
|
|
apr_int32_t flags,
|
||
|
|
apr_pool_t *p)
|
||
|
|
{
|
||
|
|
if (**inpath == '/') {
|
||
|
|
*rootpath = apr_pstrdup(p, "/");
|
||
|
|
do {
|
||
|
|
++(*inpath);
|
||
|
|
} while (**inpath == '/');
|
||
|
|
|
||
|
|
return APR_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
return APR_ERELATIVE;
|
||
|
|
}
|
||
|
|
|
||
|
|
APR_DECLARE(apr_status_t) apr_filepath_merge(char **newpath,
|
||
|
|
const char *rootpath,
|
||
|
|
const char *addpath,
|
||
|
|
apr_int32_t flags,
|
||
|
|
apr_pool_t *p)
|
||
|
|
{
|
||
|
|
char *path;
|
||
|
|
apr_size_t rootlen; /* is the length of the src rootpath */
|
||
|
|
apr_size_t maxlen; /* maximum total path length */
|
||
|
|
apr_size_t keptlen; /* is the length of the retained rootpath */
|
||
|
|
apr_size_t pathlen; /* is the length of the result path */
|
||
|
|
apr_size_t seglen; /* is the end of the current segment */
|
||
|
|
apr_status_t rv;
|
||
|
|
|
||
|
|
/* Treat null as an empty path.
|
||
|
|
*/
|
||
|
|
if (!addpath)
|
||
|
|
addpath = "";
|
||
|
|
|
||
|
|
if (addpath[0] == '/') {
|
||
|
|
/* If addpath is rooted, then rootpath is unused.
|
||
|
|
* Ths violates any APR_FILEPATH_SECUREROOTTEST and
|
||
|
|
* APR_FILEPATH_NOTABSOLUTE flags specified.
|
||
|
|
*/
|
||
|
|
if (flags & APR_FILEPATH_SECUREROOTTEST)
|
||
|
|
return APR_EABOVEROOT;
|
||
|
|
if (flags & APR_FILEPATH_NOTABSOLUTE)
|
||
|
|
return APR_EABSOLUTE;
|
||
|
|
|
||
|
|
/* If APR_FILEPATH_NOTABOVEROOT wasn't specified,
|
||
|
|
* we won't test the root again, it's ignored.
|
||
|
|
* Waste no CPU retrieving the working path.
|
||
|
|
*/
|
||
|
|
if (!rootpath && !(flags & APR_FILEPATH_NOTABOVEROOT))
|
||
|
|
rootpath = "";
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
/* If APR_FILEPATH_NOTABSOLUTE is specified, the caller
|
||
|
|
* requires a relative result. If the rootpath is
|
||
|
|
* ommitted, we do not retrieve the working path,
|
||
|
|
* if rootpath was supplied as absolute then fail.
|
||
|
|
*/
|
||
|
|
if (flags & APR_FILEPATH_NOTABSOLUTE) {
|
||
|
|
if (!rootpath)
|
||
|
|
rootpath = "";
|
||
|
|
else if (rootpath[0] == '/')
|
||
|
|
return APR_EABSOLUTE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!rootpath) {
|
||
|
|
/* Start with the current working path. This is bass akwards,
|
||
|
|
* but required since the compiler (at least vc) doesn't like
|
||
|
|
* passing the address of a char const* for a char** arg.
|
||
|
|
*/
|
||
|
|
char *getpath;
|
||
|
|
rv = apr_filepath_get(&getpath, flags, p);
|
||
|
|
rootpath = getpath;
|
||
|
|
if (rv != APR_SUCCESS)
|
||
|
|
return errno;
|
||
|
|
|
||
|
|
/* XXX: Any kernel subject to goofy, uncanonical results
|
||
|
|
* must run the rootpath against the user's given flags.
|
||
|
|
* Simplest would be a recursive call to apr_filepath_merge
|
||
|
|
* with an empty (not null) rootpath and addpath of the cwd.
|
||
|
|
*/
|
||
|
|
}
|
||
|
|
|
||
|
|
rootlen = strlen(rootpath);
|
||
|
|
maxlen = rootlen + strlen(addpath) + 4; /* 4 for slashes at start, after
|
||
|
|
* root, and at end, plus trailing
|
||
|
|
* null */
|
||
|
|
if (maxlen > APR_PATH_MAX) {
|
||
|
|
return APR_ENAMETOOLONG;
|
||
|
|
}
|
||
|
|
path = (char *)apr_palloc(p, maxlen);
|
||
|
|
|
||
|
|
if (addpath[0] == '/') {
|
||
|
|
/* Ignore the given root path, strip off leading
|
||
|
|
* '/'s to a single leading '/' from the addpath,
|
||
|
|
* and leave addpath at the first non-'/' character.
|
||
|
|
*/
|
||
|
|
keptlen = 0;
|
||
|
|
while (addpath[0] == '/')
|
||
|
|
++addpath;
|
||
|
|
path[0] = '/';
|
||
|
|
pathlen = 1;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
/* If both paths are relative, fail early
|
||
|
|
*/
|
||
|
|
if (rootpath[0] != '/' && (flags & APR_FILEPATH_NOTRELATIVE))
|
||
|
|
return APR_ERELATIVE;
|
||
|
|
|
||
|
|
/* Base the result path on the rootpath
|
||
|
|
*/
|
||
|
|
keptlen = rootlen;
|
||
|
|
memcpy(path, rootpath, rootlen);
|
||
|
|
|
||
|
|
/* Always '/' terminate the given root path
|
||
|
|
*/
|
||
|
|
if (keptlen && path[keptlen - 1] != '/') {
|
||
|
|
path[keptlen++] = '/';
|
||
|
|
}
|
||
|
|
pathlen = keptlen;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (*addpath) {
|
||
|
|
/* Parse each segment, find the closing '/'
|
||
|
|
*/
|
||
|
|
const char *next = addpath;
|
||
|
|
while (*next && (*next != '/')) {
|
||
|
|
++next;
|
||
|
|
}
|
||
|
|
seglen = next - addpath;
|
||
|
|
|
||
|
|
if (seglen == 0 || (seglen == 1 && addpath[0] == '.')) {
|
||
|
|
/* noop segment (/ or ./) so skip it
|
||
|
|
*/
|
||
|
|
}
|
||
|
|
else if (seglen == 2 && addpath[0] == '.' && addpath[1] == '.') {
|
||
|
|
/* backpath (../) */
|
||
|
|
if (pathlen == 1 && path[0] == '/') {
|
||
|
|
/* Attempt to move above root. Always die if the
|
||
|
|
* APR_FILEPATH_SECUREROOTTEST flag is specified.
|
||
|
|
*/
|
||
|
|
if (flags & APR_FILEPATH_SECUREROOTTEST) {
|
||
|
|
return APR_EABOVEROOT;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Otherwise this is simply a noop, above root is root.
|
||
|
|
* Flag that rootpath was entirely replaced.
|
||
|
|
*/
|
||
|
|
keptlen = 0;
|
||
|
|
}
|
||
|
|
else if (pathlen == 0
|
||
|
|
|| (pathlen == 3
|
||
|
|
&& !memcmp(path + pathlen - 3, "../", 3))
|
||
|
|
|| (pathlen > 3
|
||
|
|
&& !memcmp(path + pathlen - 4, "/../", 4))) {
|
||
|
|
/* Path is already backpathed or empty, if the
|
||
|
|
* APR_FILEPATH_SECUREROOTTEST.was given die now.
|
||
|
|
*/
|
||
|
|
if (flags & APR_FILEPATH_SECUREROOTTEST) {
|
||
|
|
return APR_EABOVEROOT;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Otherwise append another backpath, including
|
||
|
|
* trailing slash if present.
|
||
|
|
*/
|
||
|
|
memcpy(path + pathlen, "../", *next ? 3 : 2);
|
||
|
|
pathlen += *next ? 3 : 2;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
/* otherwise crop the prior segment
|
||
|
|
*/
|
||
|
|
do {
|
||
|
|
--pathlen;
|
||
|
|
} while (pathlen && path[pathlen - 1] != '/');
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Now test if we are above where we started and back up
|
||
|
|
* the keptlen offset to reflect the added/altered path.
|
||
|
|
*/
|
||
|
|
if (pathlen < keptlen) {
|
||
|
|
if (flags & APR_FILEPATH_SECUREROOTTEST) {
|
||
|
|
return APR_EABOVEROOT;
|
||
|
|
}
|
||
|
|
keptlen = pathlen;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
/* An actual segment, append it to the destination path
|
||
|
|
*/
|
||
|
|
if (*next) {
|
||
|
|
seglen++;
|
||
|
|
}
|
||
|
|
memcpy(path + pathlen, addpath, seglen);
|
||
|
|
pathlen += seglen;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Skip over trailing slash to the next segment
|
||
|
|
*/
|
||
|
|
if (*next) {
|
||
|
|
++next;
|
||
|
|
}
|
||
|
|
|
||
|
|
addpath = next;
|
||
|
|
}
|
||
|
|
path[pathlen] = '\0';
|
||
|
|
|
||
|
|
/* keptlen will be the rootlen unless the addpath contained
|
||
|
|
* backpath elements. If so, and APR_FILEPATH_NOTABOVEROOT
|
||
|
|
* is specified (APR_FILEPATH_SECUREROOTTEST was caught above),
|
||
|
|
* compare the original root to assure the result path is
|
||
|
|
* still within given root path.
|
||
|
|
*/
|
||
|
|
if ((flags & APR_FILEPATH_NOTABOVEROOT) && keptlen < rootlen) {
|
||
|
|
if (strncmp(rootpath, path, rootlen)) {
|
||
|
|
return APR_EABOVEROOT;
|
||
|
|
}
|
||
|
|
if (rootpath[rootlen - 1] != '/'
|
||
|
|
&& path[rootlen] && path[rootlen] != '/') {
|
||
|
|
return APR_EABOVEROOT;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
*newpath = path;
|
||
|
|
return APR_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
APR_DECLARE(apr_status_t) apr_filepath_list_split(apr_array_header_t **pathelts,
|
||
|
|
const char *liststr,
|
||
|
|
apr_pool_t *p)
|
||
|
|
{
|
||
|
|
return apr_filepath_list_split_impl(pathelts, liststr, ':', p);
|
||
|
|
}
|
||
|
|
|
||
|
|
APR_DECLARE(apr_status_t) apr_filepath_list_merge(char **liststr,
|
||
|
|
apr_array_header_t *pathelts,
|
||
|
|
apr_pool_t *p)
|
||
|
|
{
|
||
|
|
return apr_filepath_list_merge_impl(liststr, pathelts, ':', p);
|
||
|
|
}
|
||
|
|
|
||
|
|
APR_DECLARE(apr_status_t) apr_filepath_encoding(int *style, apr_pool_t *p)
|
||
|
|
{
|
||
|
|
#if defined(DARWIN)
|
||
|
|
*style = APR_FILEPATH_ENCODING_UTF8;
|
||
|
|
#else
|
||
|
|
*style = APR_FILEPATH_ENCODING_LOCALE;
|
||
|
|
#endif
|
||
|
|
return APR_SUCCESS;
|
||
|
|
}
|