/* Copyright 2000-2004 The Apache Software Foundation * * Licensed 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 #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 #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) 1 { 1 char path[APR_PATH_MAX]; 1 if (!getcwd(path, sizeof(path))) { ###### if (errno == ERANGE) ###### return APR_ENAMETOOLONG; else ###### return errno; } 1 *defpath = apr_pstrdup(p, path); 1 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) 2 { 2 if (chdir(path) != 0) ###### return errno; 2 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) 2 { 2 if (**inpath == '/') { 1 *rootpath = apr_pstrdup(p, "/"); 1 do { 1 ++(*inpath); 1 } while (**inpath == '/'); 1 return APR_SUCCESS; } 1 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) 11 { 11 char *path; 11 apr_size_t rootlen; /* is the length of the src rootpath */ 11 apr_size_t maxlen; /* maximum total path length */ 11 apr_size_t keptlen; /* is the length of the retained rootpath */ 11 apr_size_t pathlen; /* is the length of the result path */ 11 apr_size_t seglen; /* is the end of the current segment */ 11 apr_status_t rv; /* Treat null as an empty path. */ 11 if (!addpath) ###### addpath = ""; 11 if (addpath[0] == '/') { /* If addpath is rooted, then rootpath is unused. * Ths violates any APR_FILEPATH_SECUREROOTTEST and * APR_FILEPATH_NOTABSOLUTE flags specified. */ 3 if (flags & APR_FILEPATH_SECUREROOTTEST) ###### return APR_EABOVEROOT; 3 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. */ 3 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. */ 8 if (flags & APR_FILEPATH_NOTABSOLUTE) { 2 if (!rootpath) ###### rootpath = ""; 2 else if (rootpath[0] == '/') 1 return APR_EABSOLUTE; } } 10 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. */ } 10 rootlen = strlen(rootpath); 10 maxlen = rootlen + strlen(addpath) + 4; /* 4 for slashes at start, after * root, and at end, plus trailing * null */ 10 if (maxlen > APR_PATH_MAX) { ###### return APR_ENAMETOOLONG; } 10 path = (char *)apr_palloc(p, maxlen); 10 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. */ 3 keptlen = 0; 6 while (addpath[0] == '/') 3 ++addpath; 3 path[0] = '/'; 3 pathlen = 1; } else { /* If both paths are relative, fail early */ 7 if (rootpath[0] != '/' && (flags & APR_FILEPATH_NOTRELATIVE)) 1 return APR_ERELATIVE; /* Base the result path on the rootpath */ 6 keptlen = rootlen; 6 memcpy(path, rootpath, rootlen); /* Always '/' terminate the given root path */ 6 if (keptlen && path[keptlen - 1] != '/') { 4 path[keptlen++] = '/'; } 6 pathlen = keptlen; } 27 while (*addpath) { /* Parse each segment, find the closing '/' */ 18 const char *next = addpath; 68 while (*next && (*next != '/')) { 50 ++next; } 18 seglen = next - addpath; 18 if (seglen == 0 || (seglen == 1 && addpath[0] == '.')) { /* noop segment (/ or ./) so skip it */ } 18 else if (seglen == 2 && addpath[0] == '.' && addpath[1] == '.') { /* backpath (../) */ 6 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; } 6 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. */ 2 if (flags & APR_FILEPATH_SECUREROOTTEST) { ###### return APR_EABOVEROOT; } /* Otherwise append another backpath. */ 2 memcpy(path + pathlen, "../", 3); 2 pathlen += 3; } else { /* otherwise crop the prior segment */ 16 do { 16 --pathlen; 16 } 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. */ 6 if (pathlen < keptlen) { 4 if (flags & APR_FILEPATH_SECUREROOTTEST) { ###### return APR_EABOVEROOT; } 4 keptlen = pathlen; } } else { /* An actual segment, append it to the destination path */ 12 if (*next) { 3 seglen++; } 12 memcpy(path + pathlen, addpath, seglen); 12 pathlen += seglen; } /* Skip over trailing slash to the next segment */ 18 if (*next) { 9 ++next; } 18 addpath = next; } 9 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. */ 9 if ((flags & APR_FILEPATH_NOTABOVEROOT) && keptlen < rootlen) { 2 if (strncmp(rootpath, path, rootlen)) { 1 return APR_EABOVEROOT; } 1 if (rootpath[rootlen - 1] != '/' && path[rootlen] && path[rootlen] != '/') { ###### return APR_EABOVEROOT; } } 8 *newpath = path; 8 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_filepath_list_split(apr_array_header_t **pathelts, const char *liststr, apr_pool_t *p) 7 { 7 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) 7 { 7 return apr_filepath_list_merge_impl(liststr, pathelts, ':', p); } APR_DECLARE(apr_status_t) apr_filepath_encoding(int *style, apr_pool_t *p) ###### { ###### *style = APR_FILEPATH_ENCODING_LOCALE; ###### return APR_SUCCESS; }