937a200089
This is actually a fully functional build except: * All internal shared libraries are static linked to make sure there is no interference with ports (and to reduce build time). * It does not have the python/perl/etc plugin or API support. * By default, it installs as "svnlite" rather than "svn". * If WITH_SVN added in make.conf, you get "svn". * If WITHOUT_SVNLITE is in make.conf, this is completely disabled. To be absolutely clear, this is not intended for any use other than checking out freebsd source and committing, like we once did with cvs. It should be usable for small scale local repositories that don't need the python/perl plugin architecture.
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;
|
|
}
|