| /* 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_strings.h" |
| #include "apr_lib.h" |
| #include <string.h> |
| #include <ctype.h> |
| |
| #ifdef NETWARE |
| #include <unistd.h> |
| #include <fsio.h> |
| #endif |
| |
| /* WinNT accepts several odd forms of a 'root' path. Under Unicode |
| * calls (ApiFunctionW) the //?/C:/foo or //?/UNC/mach/share/foo forms |
| * are accepted. Ansi and Unicode functions both accept the //./C:/foo |
| * form under WinNT/2K. Since these forms are handled in the utf-8 to |
| * unicode translation phase, we don't want the user confused by them, so |
| * we will accept them but always return the canonical C:/ or //mach/share/ |
| * |
| * OS2 appears immune from the nonsense :) |
| */ |
| |
| APR_DECLARE(apr_status_t) apr_filepath_root(const char **rootpath, |
| const char **inpath, |
| apr_int32_t flags, |
| apr_pool_t *p) |
| { |
| const char *testpath = *inpath; |
| char *newpath; |
| #ifdef NETWARE |
| char seperator[2] = { 0, 0}; |
| char server[APR_PATH_MAX+1]; |
| char volume[APR_PATH_MAX+1]; |
| char file[APR_PATH_MAX+1]; |
| char *volsep = NULL; |
| int elements; |
| |
| if (inpath && *inpath) |
| volsep = strchr (*inpath, ':'); |
| else |
| return APR_EBADPATH; |
| |
| if (strlen(*inpath) > APR_PATH_MAX) { |
| return APR_EBADPATH; |
| } |
| |
| seperator[0] = (flags & APR_FILEPATH_NATIVE) ? '\\' : '/'; |
| |
| /* Allocate and initialize each of the segment buffers |
| */ |
| server[0] = volume[0] = file[0] = '\0'; |
| |
| /* If we don't have a volume separator then don't bother deconstructing |
| the path since we won't use the deconstructed information anyway. |
| */ |
| if (volsep) { |
| /* Split the inpath into its separate parts. */ |
| deconstruct(testpath, server, volume, NULL, file, NULL, &elements, PATH_UNDEF); |
| |
| /* If we got a volume part then continue splitting out the root. |
| Otherwise we either have an incomplete or relative path |
| */ |
| if (volume && strlen(volume) > 0) { |
| newpath = apr_pcalloc(p, strlen(server)+strlen(volume)+5); |
| construct(newpath, server, volume, NULL, NULL, NULL, PATH_NETWARE); |
| |
| /* NetWare doesn't add the root slash so we need to add it manually. |
| */ |
| strcat(newpath, seperator); |
| *rootpath = newpath; |
| |
| /* Skip the inpath pointer down to the first non-root character |
| */ |
| newpath = volsep; |
| do { |
| ++newpath; |
| } while (*newpath && ((*newpath == '/') || (*newpath == '\\'))); |
| *inpath = newpath; |
| |
| /* Need to handle APR_FILEPATH_TRUENAME checking here. */ |
| |
| return APR_SUCCESS; |
| } |
| else |
| return APR_EBADPATH; |
| } |
| else if ((**inpath == '/') || (**inpath == '\\')) { |
| /* if we have a root path without a volume then just split |
| in same manner as unix although this path will be |
| incomplete. |
| */ |
| *rootpath = apr_pstrdup(p, seperator); |
| do { |
| ++(*inpath); |
| } while ((**inpath == '/') || (**inpath == '\\')); |
| } |
| else |
| return APR_ERELATIVE; |
| |
| return APR_EINCOMPLETE; |
| |
| #else /* ndef(NETWARE) */ |
| |
| char seperator[2]; |
| const char *delim1; |
| const char *delim2; |
| |
| seperator[0] = (flags & APR_FILEPATH_NATIVE) ? '\\' : '/'; |
| seperator[1] = 0; |
| |
| if (testpath[0] == '/' || testpath[0] == '\\') { |
| if (testpath[1] == '/' || testpath[1] == '\\') { |
| |
| #ifdef WIN32 /* //server/share isn't the only // delimited syntax */ |
| if ((testpath[2] == '?' || testpath[2] == '.') |
| && (testpath[3] == '/' || testpath[3] == '\\')) { |
| if (IS_FNCHAR(testpath[4]) && testpath[5] == ':') |
| { |
| apr_status_t rv; |
| testpath += 4; |
| /* given '//?/C: or //./C: let us try this |
| * all over again from the drive designator |
| */ |
| rv = apr_filepath_root(rootpath, &testpath, flags, p); |
| if (!rv || rv == APR_EINCOMPLETE) |
| *inpath = testpath; |
| return rv; |
| } |
| else if (strncasecmp(testpath + 4, "UNC", 3) == 0 |
| && (testpath[7] == '/' || testpath[7] == '\\') |
| && (testpath[2] == '?')) { |
| /* given '//?/UNC/machine/share, a little magic |
| * at the end makes this all work out by using |
| * 'C/machine' as the starting point and replacing |
| * the UNC delimiters with \'s, including the 'C' |
| */ |
| testpath += 6; |
| } |
| else |
| /* This must not be a path to a file, but rather |
| * a volume or device. Die for now. |
| */ |
| return APR_EBADPATH; |
| } |
| #endif /* WIN32 (non - //server/share syntax) */ |
| |
| /* Evaluate path of '//[machine/[share[/]]]' */ |
| delim1 = testpath + 2; |
| do { |
| /* Protect against //X/ where X is illegal */ |
| if (*delim1 && !IS_FNCHAR(*(delim1++))) |
| return APR_EBADPATH; |
| } while (*delim1 && *delim1 != '/' && *delim1 != '\\'); |
| |
| if (*delim1) { |
| apr_status_t rv; |
| delim2 = delim1 + 1; |
| while (*delim2 && *delim2 != '/' && *delim2 != '\\') { |
| /* Protect against //machine/X/ where X is illegal */ |
| if (!IS_FNCHAR(*(delim2++))) |
| return APR_EBADPATH; |
| } |
| |
| /* Copy the '//machine/[share[/]]' path, always providing |
| * an extra byte for the trailing slash. |
| */ |
| newpath = apr_pstrmemdup(p, testpath, delim2 - testpath + 1); |
| |
| if (delim2 == delim1 + 1) { |
| /* We found simply \\machine\, so give up already |
| */ |
| *rootpath = newpath; |
| *inpath = delim2; |
| return APR_EINCOMPLETE; |
| } |
| |
| if (flags & APR_FILEPATH_TRUENAME) { |
| /* Validate the \\Machine\Share\ designation, |
| * Win32 will argue about slashed in UNC paths, |
| * so use backslashes till we finish testing, |
| * and add the trailing backslash [required]. |
| * apr_pstrmemdup above guarentees us the new |
| * trailing null character. |
| */ |
| newpath[0] = '\\'; |
| newpath[1] = '\\'; |
| newpath[delim1 - testpath] = '\\'; |
| newpath[delim2 - testpath] = '\\'; |
| |
| rv = filepath_root_test(newpath, p); |
| if (rv) |
| return rv; |
| rv = filepath_root_case(&newpath, newpath, p); |
| if (rv) |
| return rv; |
| newpath[0] = seperator[0]; |
| newpath[1] = seperator[0]; |
| newpath[delim1 - testpath] = seperator[0]; |
| newpath[delim2 - testpath] = (*delim2 ? seperator[0] : '\0'); |
| } |
| else { |
| /* Give back the caller's own choice of delimiters |
| */ |
| newpath[0] = testpath[0]; |
| newpath[1] = testpath[1]; |
| newpath[delim1 - testpath] = *delim1; |
| newpath[delim2 - testpath] = *delim2; |
| } |
| |
| /* If this root included the trailing / or \ designation |
| * then lop off multiple trailing slashes and give back |
| * appropriate delimiters. |
| */ |
| if (*delim2) { |
| *inpath = delim2 + 1; |
| while (**inpath == '/' || **inpath == '\\') |
| ++*inpath; |
| } |
| else { |
| *inpath = delim2; |
| } |
| |
| *rootpath = newpath; |
| return APR_SUCCESS; |
| } |
| |
| /* Have path of '\\[machine]', if the machine is given, |
| * append same trailing slash as the leading slash |
| */ |
| delim1 = strchr(testpath, '\0'); |
| if (delim1 > testpath + 2) { |
| newpath = apr_pstrndup(p, testpath, delim1 - testpath + 1); |
| if (flags & APR_FILEPATH_TRUENAME) |
| newpath[delim1 - testpath] = seperator[0]; |
| else |
| newpath[delim1 - testpath] = newpath[0]; |
| newpath[delim1 - testpath + 1] = '\0'; |
| } |
| else { |
| newpath = apr_pstrndup(p, testpath, delim1 - testpath); |
| } |
| if (flags & APR_FILEPATH_TRUENAME) { |
| newpath[0] = seperator[0]; |
| newpath[1] = seperator[0]; |
| } |
| *rootpath = newpath; |
| *inpath = delim1; |
| return APR_EINCOMPLETE; |
| } |
| |
| /* Left with a path of '/', what drive are we asking about? |
| */ |
| *inpath = testpath + 1; |
| newpath = apr_palloc(p, 2); |
| if (flags & APR_FILEPATH_TRUENAME) |
| newpath[0] = seperator[0]; |
| else |
| newpath[0] = testpath[0]; |
| newpath[1] = '\0'; |
| *rootpath = newpath; |
| return APR_EINCOMPLETE; |
| } |
| |
| /* Evaluate path of 'd:[/]' */ |
| if (IS_FNCHAR(*testpath) && testpath[1] == ':') |
| { |
| apr_status_t rv; |
| /* Validate that D:\ drive exists, test must be rooted |
| * Note that posix/win32 insists a drive letter is upper case, |
| * so who are we to argue with a 'feature'. |
| * It is a safe fold, since only A-Z is legal, and has no |
| * side effects of legal mis-mapped non-us-ascii codes. |
| */ |
| newpath = apr_palloc(p, 4); |
| newpath[0] = testpath[0]; |
| newpath[1] = testpath[1]; |
| newpath[2] = seperator[0]; |
| newpath[3] = '\0'; |
| if (flags & APR_FILEPATH_TRUENAME) { |
| newpath[0] = apr_toupper(newpath[0]); |
| rv = filepath_root_test(newpath, p); |
| if (rv) |
| return rv; |
| } |
| /* Just give back the root the user handed to us. |
| */ |
| if (testpath[2] != '/' && testpath[2] != '\\') { |
| newpath[2] = '\0'; |
| *rootpath = newpath; |
| *inpath = testpath + 2; |
| return APR_EINCOMPLETE; |
| } |
| |
| /* strip off remaining slashes that designate the root, |
| * give the caller back their original choice of slash |
| * unless this is TRUENAME'ed |
| */ |
| *inpath = testpath + 3; |
| while (**inpath == '/' || **inpath == '\\') |
| ++*inpath; |
| if (!(flags & APR_FILEPATH_TRUENAME)) |
| newpath[2] = testpath[2]; |
| *rootpath = newpath; |
| return APR_SUCCESS; |
| } |
| |
| /* Nothing interesting */ |
| return APR_ERELATIVE; |
| |
| #endif /* ndef(NETWARE) */ |
| } |
| |
| |
| APR_DECLARE(apr_status_t) apr_filepath_merge(char **newpath, |
| const char *basepath, |
| const char *addpath, |
| apr_int32_t flags, |
| apr_pool_t *p) |
| { |
| char path[APR_PATH_MAX]; /* isn't null term */ |
| const char *baseroot = NULL; |
| const char *addroot; |
| apr_size_t rootlen; /* the length of the root portion of path, d:/ is 3 */ |
| apr_size_t baselen; /* the length of basepath (excluding baseroot) */ |
| apr_size_t keptlen; /* the length of the retained basepath (incl root) */ |
| apr_size_t pathlen; /* the length of the result path */ |
| apr_size_t segend; /* the end of the current segment */ |
| apr_size_t seglen; /* the length of the segment (excl trailing chars) */ |
| apr_status_t basetype = 0; /* from parsing the basepath's baseroot */ |
| apr_status_t addtype; /* from parsing the addpath's addroot */ |
| apr_status_t rv; |
| #ifndef NETWARE |
| int fixunc = 0; /* flag to complete an incomplete UNC basepath */ |
| #endif |
| |
| /* Treat null as an empty path, otherwise split addroot from the addpath |
| */ |
| if (!addpath) { |
| addpath = addroot = ""; |
| addtype = APR_ERELATIVE; |
| } |
| else { |
| /* This call _should_ test the path |
| */ |
| addtype = apr_filepath_root(&addroot, &addpath, |
| APR_FILEPATH_TRUENAME |
| | (flags & APR_FILEPATH_NATIVE), |
| p); |
| if (addtype == APR_SUCCESS) { |
| addtype = APR_EABSOLUTE; |
| } |
| else if (addtype == APR_ERELATIVE) { |
| addroot = ""; |
| } |
| else if (addtype != APR_EINCOMPLETE) { |
| /* apr_filepath_root was incomprehensible so fail already |
| */ |
| return addtype; |
| } |
| } |
| |
| /* If addpath is (even partially) rooted, then basepath is |
| * unused. Ths violates any APR_FILEPATH_SECUREROOTTEST |
| * and APR_FILEPATH_NOTABSOLUTE flags specified. |
| */ |
| if (addtype == APR_EABSOLUTE || addtype == APR_EINCOMPLETE) |
| { |
| if (flags & APR_FILEPATH_SECUREROOTTEST) |
| return APR_EABOVEROOT; |
| if (flags & APR_FILEPATH_NOTABSOLUTE) |
| return addtype; |
| } |
| |
| /* Optimized tests before we query the current working path |
| */ |
| if (!basepath) { |
| |
| /* 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 (addtype == APR_EABSOLUTE && !(flags & APR_FILEPATH_NOTABOVEROOT)) { |
| basepath = baseroot = ""; |
| basetype = APR_ERELATIVE; |
| } |
| |
| /* If APR_FILEPATH_NOTABSOLUTE is specified, the caller |
| * requires an absolutely relative result, So do not retrieve |
| * the working path. |
| */ |
| if (addtype == APR_ERELATIVE && (flags & APR_FILEPATH_NOTABSOLUTE)) { |
| basepath = baseroot = ""; |
| basetype = APR_ERELATIVE; |
| } |
| } |
| |
| if (!basepath) |
| { |
| /* 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. |
| * We must grab the current path of the designated drive |
| * if addroot is given in drive-relative form (e.g. d:foo) |
| */ |
| char *getpath; |
| #ifndef NETWARE |
| if (addtype == APR_EINCOMPLETE && addroot[1] == ':') |
| rv = filepath_drive_get(&getpath, addroot[0], flags, p); |
| else |
| #endif |
| rv = apr_filepath_get(&getpath, flags, p); |
| if (rv != APR_SUCCESS) |
| return rv; |
| basepath = getpath; |
| } |
| |
| if (!baseroot) { |
| /* This call should _not_ test the path |
| */ |
| basetype = apr_filepath_root(&baseroot, &basepath, |
| (flags & APR_FILEPATH_NATIVE), p); |
| if (basetype == APR_SUCCESS) { |
| basetype = APR_EABSOLUTE; |
| } |
| else if (basetype == APR_ERELATIVE) { |
| baseroot = ""; |
| } |
| else if (basetype != APR_EINCOMPLETE) { |
| /* apr_filepath_root was incomprehensible so fail already |
| */ |
| return basetype; |
| } |
| } |
| baselen = strlen(basepath); |
| |
| /* If APR_FILEPATH_NOTABSOLUTE is specified, the caller |
| * requires an absolutely relative result. If the given |
| * basepath is not relative then fail. |
| */ |
| if ((flags & APR_FILEPATH_NOTABSOLUTE) && basetype != APR_ERELATIVE) |
| return basetype; |
| |
| /* The Win32 nightmare on unc street... start combining for |
| * many possible root combinations. |
| */ |
| if (addtype == APR_EABSOLUTE) |
| { |
| /* Ignore the given root path, and start with the addroot |
| */ |
| if ((flags & APR_FILEPATH_NOTABOVEROOT) |
| && strncmp(baseroot, addroot, strlen(baseroot))) |
| return APR_EABOVEROOT; |
| keptlen = 0; |
| rootlen = pathlen = strlen(addroot); |
| memcpy(path, addroot, pathlen); |
| } |
| else if (addtype == APR_EINCOMPLETE) |
| { |
| /* There are several types of incomplete paths, |
| * incomplete UNC paths (//foo/ or //), |
| * drives without rooted paths (d: as in d:foo), |
| * and simple roots (/ as in /foo). |
| * Deal with these in significantly different manners... |
| */ |
| #ifndef NETWARE |
| if ((addroot[0] == '/' || addroot[0] == '\\') && |
| (addroot[1] == '/' || addroot[1] == '\\')) |
| { |
| /* Ignore the given root path if the incomplete addpath is UNC, |
| * (note that the final result will be incomplete). |
| */ |
| if (flags & APR_FILEPATH_NOTRELATIVE) |
| return addtype; |
| if ((flags & APR_FILEPATH_NOTABOVEROOT) |
| && strncmp(baseroot, addroot, strlen(baseroot))) |
| return APR_EABOVEROOT; |
| fixunc = 1; |
| keptlen = 0; |
| rootlen = pathlen = strlen(addroot); |
| memcpy(path, addroot, pathlen); |
| } |
| else |
| #endif |
| if ((addroot[0] == '/' || addroot[0] == '\\') && !addroot[1]) |
| { |
| /* Bring together the drive or UNC root from the baseroot |
| * if the addpath is a simple root and basepath is rooted, |
| * otherwise disregard the basepath entirely. |
| */ |
| if (basetype != APR_EABSOLUTE && (flags & APR_FILEPATH_NOTRELATIVE)) |
| return basetype; |
| if (basetype != APR_ERELATIVE) { |
| #ifndef NETWARE |
| if (basetype == APR_INCOMPLETE |
| && (baseroot[0] == '/' || baseroot[0] == '\\') |
| && (baseroot[1] == '/' || baseroot[1] == '\\')) |
| fixunc = 1; |
| #endif |
| keptlen = rootlen = pathlen = strlen(baseroot); |
| memcpy(path, baseroot, pathlen); |
| } |
| else { |
| if (flags & APR_FILEPATH_NOTABOVEROOT) |
| return APR_EABOVEROOT; |
| keptlen = 0; |
| rootlen = pathlen = strlen(addroot); |
| memcpy(path, addroot, pathlen); |
| } |
| } |
| #ifdef NETWARE |
| else if (filepath_has_drive(addroot, DRIVE_ONLY, p)) |
| { |
| /* If the addroot is a drive (without a volume root) |
| * use the basepath _if_ it matches this drive letter! |
| * Otherwise we must discard the basepath. |
| */ |
| if (!filepath_compare_drive(addroot, baseroot, p) && |
| filepath_has_drive(baseroot, 0, p)) { |
| #else |
| else if (addroot[0] && addroot[1] == ':' && !addroot[2]) |
| { |
| /* If the addroot is a drive (without a volume root) |
| * use the basepath _if_ it matches this drive letter! |
| * Otherwise we must discard the basepath. |
| */ |
| if (addroot[0] == baseroot[0] && baseroot[1] == ':') { |
| #endif |
| /* Base the result path on the basepath |
| */ |
| if (basetype != APR_EABSOLUTE && (flags & APR_FILEPATH_NOTRELATIVE)) |
| return basetype; |
| rootlen = strlen(baseroot); |
| keptlen = pathlen = rootlen + baselen; |
| if (keptlen >= sizeof(path)) |
| return APR_ENAMETOOLONG; |
| memcpy(path, baseroot, rootlen); |
| memcpy(path + rootlen, basepath, baselen); |
| } |
| else { |
| if (flags & APR_FILEPATH_NOTRELATIVE) |
| return addtype; |
| if (flags & APR_FILEPATH_NOTABOVEROOT) |
| return APR_EABOVEROOT; |
| keptlen = 0; |
| rootlen = pathlen = strlen(addroot); |
| memcpy(path, addroot, pathlen); |
| } |
| } |
| else { |
| /* Now this is unexpected, we aren't aware of any other |
| * incomplete path forms! Fail now. |
| */ |
| return APR_EBADPATH; |
| } |
| } |
| else { /* addtype == APR_ERELATIVE */ |
| /* If both paths are relative, fail early |
| */ |
| if (basetype != APR_EABSOLUTE && (flags & APR_FILEPATH_NOTRELATIVE)) |
| return basetype; |
| |
| #ifndef NETWARE |
| /* An incomplete UNC path must be completed |
| */ |
| if (basetype == APR_INCOMPLETE |
| && (baseroot[0] == '/' || baseroot[0] == '\\') |
| && (baseroot[1] == '/' || baseroot[1] == '\\')) |
| fixunc = 1; |
| #endif |
| |
| /* Base the result path on the basepath |
| */ |
| rootlen = strlen(baseroot); |
| keptlen = pathlen = rootlen + baselen; |
| if (keptlen >= sizeof(path)) |
| return APR_ENAMETOOLONG; |
| memcpy(path, baseroot, rootlen); |
| memcpy(path + rootlen, basepath, baselen); |
| } |
| |
| /* '/' terminate the given root path unless it's already terminated |
| * or is an incomplete drive root. Correct the trailing slash unless |
| * we have an incomplete UNC path still to fix. |
| */ |
| if (pathlen && path[pathlen - 1] != ':') { |
| if (path[pathlen - 1] != '/' && path[pathlen - 1] != '\\') { |
| if (pathlen + 1 >= sizeof(path)) |
| return APR_ENAMETOOLONG; |
| |
| path[pathlen++] = ((flags & APR_FILEPATH_NATIVE) ? '\\' : '/'); |
| } |
| /* XXX: wrong, but gotta figure out what I intended; |
| * else if (!fixunc) |
| * path[pathlen++] = ((flags & APR_FILEPATH_NATIVE) ? '\\' : '/'); |
| */ |
| } |
| |
| while (*addpath) |
| { |
| /* Parse each segment, find the closing '/' |
| */ |
| seglen = 0; |
| while (addpath[seglen] && addpath[seglen] != '/' |
| && addpath[seglen] != '\\') |
| ++seglen; |
| |
| /* Truncate all trailing spaces and all but the first two dots */ |
| segend = seglen; |
| while (seglen && (addpath[seglen - 1] == ' ' |
| || addpath[seglen - 1] == '.')) { |
| if (seglen > 2 || addpath[seglen - 1] != '.' || addpath[0] != '.') |
| --seglen; |
| else |
| break; |
| } |
| |
| if (seglen == 0 || (seglen == 1 && addpath[0] == '.')) |
| { |
| /* NOTE: win32 _hates_ '/ /' and '/. /' (yes, with spaces in there) |
| * so eliminate all preconceptions that it is valid. |
| */ |
| if (seglen < segend) |
| return APR_EBADPATH; |
| |
| #ifndef NETWARE |
| /* This isn't legal unless the unc path is completed |
| */ |
| if (fixunc) |
| return APR_EBADPATH; |
| #endif |
| |
| /* Otherwise, this is a noop segment (/ or ./) so ignore it |
| */ |
| } |
| else if (seglen == 2 && addpath[0] == '.' && addpath[1] == '.') |
| { |
| /* NOTE: win32 _hates_ '/.. /' (yes, with a space in there) |
| * and '/..../', some functions treat it as ".", and some |
| * fail! Eliminate all preconceptions that they are valid. |
| */ |
| if (seglen < segend && (seglen != 3 || addpath[2] != '.')) |
| return APR_EBADPATH; |
| |
| #ifndef NETWARE |
| /* This isn't legal unless the unc path is completed |
| */ |
| if (fixunc) |
| return APR_EBADPATH; |
| #endif |
| |
| /* backpath (../) when an absolute path is given */ |
| if (rootlen && (pathlen <= rootlen)) |
| { |
| /* 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. |
| */ |
| } |
| else if (pathlen == 0 |
| || (pathlen >= 3 |
| && (pathlen == 3 |
| || path[pathlen - 4] == ':' |
| || path[pathlen - 4] == '/' |
| || path[pathlen - 4] == '\\') |
| && path[pathlen - 3] == '.' |
| && path[pathlen - 2] == '.' |
| && (path[pathlen - 1] == '/' |
| || path[pathlen - 1] == '\\'))) |
| { |
| /* Verified path is empty, exactly "..[/\]", or ends |
| * in "[:/\]..[/\]" - these patterns we will not back |
| * over since they aren't 'prior segements'. |
| * |
| * If APR_FILEPATH_SECUREROOTTEST.was given, die now. |
| */ |
| if (flags & APR_FILEPATH_SECUREROOTTEST) |
| return APR_EABOVEROOT; |
| |
| /* Otherwise append another backpath. |
| */ |
| if (pathlen + 3 >= sizeof(path)) |
| return APR_ENAMETOOLONG; |
| path[pathlen++] = '.'; |
| path[pathlen++] = '.'; |
| if (addpath[segend]) { |
| path[pathlen++] = ((flags & APR_FILEPATH_NATIVE) |
| ? '\\' : ((flags & APR_FILEPATH_TRUENAME) |
| ? '/' : addpath[segend])); |
| } |
| /* The 'root' part of this path now includes the ../ path, |
| * because that backpath will not be parsed by the truename |
| * code below. |
| */ |
| keptlen = pathlen; |
| } |
| else |
| { |
| /* otherwise crop the prior segment |
| */ |
| do { |
| --pathlen; |
| } while (pathlen && path[pathlen - 1] != '/' |
| && 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 /* not empty or dots */ |
| { |
| #ifndef NETWARE |
| if (fixunc) { |
| const char *testpath = path; |
| const char *testroot; |
| apr_status_t testtype; |
| apr_size_t i = (addpath[segend] != '\0'); |
| |
| /* This isn't legal unless the unc path is complete! |
| */ |
| if (seglen < segend) |
| return APR_EBADPATH; |
| if (pathlen + seglen + 1 >= sizeof(path)) |
| return APR_ENAMETOOLONG; |
| memcpy(path + pathlen, addpath, seglen + i); |
| |
| /* Always add the trailing slash to a UNC segment |
| */ |
| path[pathlen + seglen] = ((flags & APR_FILEPATH_NATIVE) |
| ? '\\' : '/'); |
| pathlen += seglen + 1; |
| |
| /* Recanonicalize the UNC root with the new UNC segment, |
| * and if we succeed, reset this test and the rootlen, |
| * and replace our path with the canonical UNC root path |
| */ |
| path[pathlen] = '\0'; |
| /* This call _should_ test the path |
| */ |
| testtype = apr_filepath_root(&testroot, &testpath, |
| APR_FILEPATH_TRUENAME |
| | (flags & APR_FILEPATH_NATIVE), |
| p); |
| if (testtype == APR_SUCCESS) { |
| rootlen = pathlen = (testpath - path); |
| memcpy(path, testroot, pathlen); |
| fixunc = 0; |
| } |
| else if (testtype != APR_EINCOMPLETE) { |
| /* apr_filepath_root was very unexpected so fail already |
| */ |
| return testtype; |
| } |
| } |
| else |
| #endif |
| { |
| /* An actual segment, append it to the destination path |
| */ |
| apr_size_t i = (addpath[segend] != '\0'); |
| if (pathlen + seglen + i >= sizeof(path)) |
| return APR_ENAMETOOLONG; |
| memcpy(path + pathlen, addpath, seglen + i); |
| if (i) |
| path[pathlen + seglen] = ((flags & APR_FILEPATH_NATIVE) |
| ? '\\' : '/'); |
| pathlen += seglen + i; |
| } |
| } |
| |
| /* Skip over trailing slash to the next segment |
| */ |
| if (addpath[segend]) |
| ++segend; |
| |
| addpath += segend; |
| } |
| |
| /* keptlen will be the baselen unless the addpath contained |
| * backpath elements. If so, and APR_FILEPATH_NOTABOVEROOT |
| * is specified (APR_FILEPATH_SECUREROOTTEST was caught above), |
| * compare the string beyond the root to assure the result path |
| * is still within given basepath. Note that the root path |
| * segment is thoroughly tested prior to path parsing. |
| */ |
| if ((flags & APR_FILEPATH_NOTABOVEROOT) && baselen) { |
| if (memcmp(basepath, path + rootlen, baselen) != 0) |
| return APR_EABOVEROOT; |
| |
| /* Ahem... if we have a basepath without a trailing slash, |
| * we better be sure that /foo wasn't replaced with /foobar! |
| */ |
| if (basepath[baselen - 1] != '/' && basepath[baselen - 1] != '\\' |
| && path[rootlen + baselen] && path[rootlen + baselen] != '/' |
| && path[rootlen + baselen] != '\\') |
| return APR_EABOVEROOT; |
| } |
| |
| if (addpath && (flags & APR_FILEPATH_TRUENAME)) { |
| /* We can always skip the root, it's already true-named. */ |
| if (rootlen > keptlen) |
| keptlen = rootlen; |
| if ((path[keptlen] == '/') || (path[keptlen] == '\\')) { |
| /* By rights, keptlen may grown longer than pathlen. |
| * we wont' use it again (in that case) so we don't care. |
| */ |
| ++keptlen; |
| } |
| /* Go through all the new segments */ |
| while (keptlen < pathlen) { |
| apr_finfo_t finfo; |
| char saveslash = 0; |
| seglen = 0; |
| /* find any slash and set it aside for a minute. */ |
| for (seglen = 0; keptlen + seglen < pathlen; ++seglen) { |
| if ((path[keptlen + seglen] == '/') || |
| (path[keptlen + seglen] == '\\')) { |
| saveslash = path[keptlen + seglen]; |
| break; |
| } |
| } |
| /* Null term for stat! */ |
| path[keptlen + seglen] = '\0'; |
| if ((rv = apr_stat(&finfo, path, |
| APR_FINFO_LINK | APR_FINFO_TYPE | APR_FINFO_NAME, p)) |
| == APR_SUCCESS) { |
| apr_size_t namelen = strlen(finfo.name); |
| |
| #if defined(OS2) /* only has case folding, never aliases that change the length */ |
| |
| if (memcmp(finfo.name, path + keptlen, seglen) != 0) { |
| memcpy(path + keptlen, finfo.name, namelen); |
| } |
| #else /* WIN32 || NETWARE; here there be aliases that gire and gimble and change length */ |
| |
| if ((namelen != seglen) || |
| (memcmp(finfo.name, path + keptlen, seglen) != 0)) |
| { |
| if (namelen <= seglen) { |
| memcpy(path + keptlen, finfo.name, namelen); |
| if ((namelen < seglen) && saveslash) { |
| memmove(path + keptlen + namelen + 1, |
| path + keptlen + seglen + 1, |
| pathlen - keptlen - seglen); |
| pathlen += namelen - seglen; |
| seglen = namelen; |
| } |
| } |
| else { /* namelen > seglen */ |
| if (pathlen + namelen - seglen >= sizeof(path)) |
| return APR_ENAMETOOLONG; |
| if (saveslash) { |
| memmove(path + keptlen + namelen + 1, |
| path + keptlen + seglen + 1, |
| pathlen - keptlen - seglen); |
| } |
| memcpy(path + keptlen, finfo.name, namelen); |
| pathlen += namelen - seglen; |
| seglen = namelen; |
| } |
| } |
| #endif /* !OS2 (Whatever that alias was we're over it) */ |
| |
| /* That's it, the rest is path info. |
| * I don't know how we aught to handle this. Should |
| * we define a new error to indicate 'more info'? |
| * Should we split out the rest of the path? |
| */ |
| if ((finfo.filetype != APR_DIR) && |
| (finfo.filetype != APR_LNK) && saveslash) |
| rv = APR_ENOTDIR; |
| #ifdef XXX_FIGURE_THIS_OUT |
| { |
| /* the example inserts a null between the end of |
| * the filename and the next segment, and increments |
| * the path length so we would return both segments. |
| */ |
| if (saveslash) { |
| keptlen += seglen; |
| path[keptlen] = saveslash; |
| if (pathlen + 1 >= sizeof(path)) |
| return APR_ENAMETOOLONG; |
| memmove(path + keptlen + 1, |
| path + keptlen, |
| pathlen - keptlen); |
| path[keptlen] = '\0'; |
| ++pathlen; |
| break; |
| } |
| } |
| #endif |
| } |
| |
| /* put back the '/' */ |
| if (saveslash) { |
| path[keptlen + seglen] = saveslash; |
| ++seglen; |
| } |
| keptlen += seglen; |
| |
| if (rv != APR_SUCCESS) { |
| if (APR_STATUS_IS_ENOENT(rv)) |
| break; |
| if (APR_STATUS_IS_EPATHWILD(rv)) |
| /* This path included wildcards. The path elements |
| * that did not contain wildcards are canonicalized, |
| * so we will return the path, although later elements |
| * don't necessarily exist, and aren't canonical. |
| */ |
| break; |
| else if (APR_STATUS_IS_ENOTDIR(rv)) |
| /* This is a little more serious, we just added a name |
| * onto a filename (think http's PATH_INFO) |
| * If the caller is foolish enough to do this, we expect |
| * the've already canonicalized the root) that they knew |
| * what they are doing :( |
| */ |
| break; |
| else |
| return rv; |
| } |
| } |
| } |
| |
| *newpath = apr_pmemdup(p, path, pathlen + 1); |
| (*newpath)[pathlen] = '\0'; |
| 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 APR_HAS_UNICODE_FS |
| IF_WIN_OS_IS_UNICODE |
| { |
| *style = APR_FILEPATH_ENCODING_UTF8; |
| return APR_SUCCESS; |
| } |
| #endif |
| |
| *style = APR_FILEPATH_ENCODING_LOCALE; |
| return APR_SUCCESS; |
| } |
