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.
312 lines
8.6 KiB
C
312 lines
8.6 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_strings.h"
|
|
#include "apr_private.h"
|
|
#include "apr_lib.h"
|
|
|
|
#if APR_HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#if APR_HAVE_STRING_H
|
|
#include <string.h>
|
|
#endif
|
|
#if APR_HAVE_CTYPE_H
|
|
#include <ctype.h>
|
|
#endif
|
|
|
|
/*
|
|
* Apache's "replacement" for the strncpy() function. We roll our
|
|
* own to implement these specific changes:
|
|
* (1) strncpy() doesn't always null terminate and we want it to.
|
|
* (2) strncpy() null fills, which is bogus, esp. when copy 8byte
|
|
* strings into 8k blocks.
|
|
* (3) Instead of returning the pointer to the beginning of
|
|
* the destination string, we return a pointer to the
|
|
* terminating '\0' to allow us to "check" for truncation
|
|
*
|
|
* apr_cpystrn() follows the same call structure as strncpy().
|
|
*/
|
|
|
|
APR_DECLARE(char *) apr_cpystrn(char *dst, const char *src, apr_size_t dst_size)
|
|
{
|
|
|
|
char *d, *end;
|
|
|
|
if (dst_size == 0) {
|
|
return (dst);
|
|
}
|
|
|
|
d = dst;
|
|
end = dst + dst_size - 1;
|
|
|
|
for (; d < end; ++d, ++src) {
|
|
if (!(*d = *src)) {
|
|
return (d);
|
|
}
|
|
}
|
|
|
|
*d = '\0'; /* always null terminate */
|
|
|
|
return (d);
|
|
}
|
|
|
|
|
|
/*
|
|
* This function provides a way to parse a generic argument string
|
|
* into a standard argv[] form of argument list. It respects the
|
|
* usual "whitespace" and quoteing rules. In the future this could
|
|
* be expanded to include support for the apr_call_exec command line
|
|
* string processing (including converting '+' to ' ' and doing the
|
|
* url processing. It does not currently support this function.
|
|
*
|
|
* token_context: Context from which pool allocations will occur.
|
|
* arg_str: Input argument string for conversion to argv[].
|
|
* argv_out: Output location. This is a pointer to an array
|
|
* of pointers to strings (ie. &(char *argv[]).
|
|
* This value will be allocated from the contexts
|
|
* pool and filled in with copies of the tokens
|
|
* found during parsing of the arg_str.
|
|
*/
|
|
APR_DECLARE(apr_status_t) apr_tokenize_to_argv(const char *arg_str,
|
|
char ***argv_out,
|
|
apr_pool_t *token_context)
|
|
{
|
|
const char *cp;
|
|
const char *ct;
|
|
char *cleaned, *dirty;
|
|
int escaped;
|
|
int isquoted, numargs = 0, argnum;
|
|
|
|
#define SKIP_WHITESPACE(cp) \
|
|
for ( ; *cp == ' ' || *cp == '\t'; ) { \
|
|
cp++; \
|
|
};
|
|
|
|
#define CHECK_QUOTATION(cp,isquoted) \
|
|
isquoted = 0; \
|
|
if (*cp == '"') { \
|
|
isquoted = 1; \
|
|
cp++; \
|
|
} \
|
|
else if (*cp == '\'') { \
|
|
isquoted = 2; \
|
|
cp++; \
|
|
}
|
|
|
|
/* DETERMINE_NEXTSTRING:
|
|
* At exit, cp will point to one of the following: NULL, SPACE, TAB or QUOTE.
|
|
* NULL implies the argument string has been fully traversed.
|
|
*/
|
|
#define DETERMINE_NEXTSTRING(cp,isquoted) \
|
|
for ( ; *cp != '\0'; cp++) { \
|
|
if ( (*cp == '\\' && (*(cp+1) == ' ' || *(cp+1) == '\t' || \
|
|
*(cp+1) == '"' || *(cp+1) == '\''))) { \
|
|
cp++; \
|
|
continue; \
|
|
} \
|
|
if ( (!isquoted && (*cp == ' ' || *cp == '\t')) \
|
|
|| (isquoted == 1 && *cp == '"') \
|
|
|| (isquoted == 2 && *cp == '\'') ) { \
|
|
break; \
|
|
} \
|
|
}
|
|
|
|
/* REMOVE_ESCAPE_CHARS:
|
|
* Compresses the arg string to remove all of the '\' escape chars.
|
|
* The final argv strings should not have any extra escape chars in it.
|
|
*/
|
|
#define REMOVE_ESCAPE_CHARS(cleaned, dirty, escaped) \
|
|
escaped = 0; \
|
|
while(*dirty) { \
|
|
if (!escaped && *dirty == '\\') { \
|
|
escaped = 1; \
|
|
} \
|
|
else { \
|
|
escaped = 0; \
|
|
*cleaned++ = *dirty; \
|
|
} \
|
|
++dirty; \
|
|
} \
|
|
*cleaned = 0; /* last line of macro... */
|
|
|
|
cp = arg_str;
|
|
SKIP_WHITESPACE(cp);
|
|
ct = cp;
|
|
|
|
/* This is ugly and expensive, but if anyone wants to figure a
|
|
* way to support any number of args without counting and
|
|
* allocating, please go ahead and change the code.
|
|
*
|
|
* Must account for the trailing NULL arg.
|
|
*/
|
|
numargs = 1;
|
|
while (*ct != '\0') {
|
|
CHECK_QUOTATION(ct, isquoted);
|
|
DETERMINE_NEXTSTRING(ct, isquoted);
|
|
if (*ct != '\0') {
|
|
ct++;
|
|
}
|
|
numargs++;
|
|
SKIP_WHITESPACE(ct);
|
|
}
|
|
*argv_out = apr_palloc(token_context, numargs * sizeof(char*));
|
|
|
|
/* determine first argument */
|
|
for (argnum = 0; argnum < (numargs-1); argnum++) {
|
|
SKIP_WHITESPACE(cp);
|
|
CHECK_QUOTATION(cp, isquoted);
|
|
ct = cp;
|
|
DETERMINE_NEXTSTRING(cp, isquoted);
|
|
cp++;
|
|
(*argv_out)[argnum] = apr_palloc(token_context, cp - ct);
|
|
apr_cpystrn((*argv_out)[argnum], ct, cp - ct);
|
|
cleaned = dirty = (*argv_out)[argnum];
|
|
REMOVE_ESCAPE_CHARS(cleaned, dirty, escaped);
|
|
}
|
|
(*argv_out)[argnum] = NULL;
|
|
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
/* Filepath_name_get returns the final element of the pathname.
|
|
* Using the current platform's filename syntax.
|
|
* "/foo/bar/gum" -> "gum"
|
|
* "/foo/bar/gum/" -> ""
|
|
* "gum" -> "gum"
|
|
* "wi\\n32\\stuff" -> "stuff
|
|
*
|
|
* Corrected Win32 to accept "a/b\\stuff", "a:stuff"
|
|
*/
|
|
|
|
APR_DECLARE(const char *) apr_filepath_name_get(const char *pathname)
|
|
{
|
|
const char path_separator = '/';
|
|
const char *s = strrchr(pathname, path_separator);
|
|
|
|
#ifdef WIN32
|
|
const char path_separator_win = '\\';
|
|
const char drive_separator_win = ':';
|
|
const char *s2 = strrchr(pathname, path_separator_win);
|
|
|
|
if (s2 > s) s = s2;
|
|
|
|
if (!s) s = strrchr(pathname, drive_separator_win);
|
|
#endif
|
|
|
|
return s ? ++s : pathname;
|
|
}
|
|
|
|
/* length of dest assumed >= length of src
|
|
* collapse in place (src == dest) is legal.
|
|
* returns terminating null ptr to dest string.
|
|
*/
|
|
APR_DECLARE(char *) apr_collapse_spaces(char *dest, const char *src)
|
|
{
|
|
while (*src) {
|
|
if (!apr_isspace(*src))
|
|
*dest++ = *src;
|
|
++src;
|
|
}
|
|
*dest = 0;
|
|
return (dest);
|
|
}
|
|
|
|
#if !APR_HAVE_STRDUP
|
|
char *strdup(const char *str)
|
|
{
|
|
char *sdup;
|
|
size_t len = strlen(str) + 1;
|
|
|
|
sdup = (char *) malloc(len);
|
|
memcpy(sdup, str, len);
|
|
|
|
return sdup;
|
|
}
|
|
#endif
|
|
|
|
/* The following two routines were donated for SVR4 by Andreas Vogel */
|
|
#if (!APR_HAVE_STRCASECMP && !APR_HAVE_STRICMP)
|
|
int strcasecmp(const char *a, const char *b)
|
|
{
|
|
const char *p = a;
|
|
const char *q = b;
|
|
for (p = a, q = b; *p && *q; p++, q++) {
|
|
int diff = apr_tolower(*p) - apr_tolower(*q);
|
|
if (diff)
|
|
return diff;
|
|
}
|
|
if (*p)
|
|
return 1; /* p was longer than q */
|
|
if (*q)
|
|
return -1; /* p was shorter than q */
|
|
return 0; /* Exact match */
|
|
}
|
|
|
|
#endif
|
|
|
|
#if (!APR_HAVE_STRNCASECMP && !APR_HAVE_STRNICMP)
|
|
int strncasecmp(const char *a, const char *b, size_t n)
|
|
{
|
|
const char *p = a;
|
|
const char *q = b;
|
|
|
|
for (p = a, q = b; /*NOTHING */ ; p++, q++) {
|
|
int diff;
|
|
if (p == a + n)
|
|
return 0; /* Match up to n characters */
|
|
if (!(*p && *q))
|
|
return *p - *q;
|
|
diff = apr_tolower(*p) - apr_tolower(*q);
|
|
if (diff)
|
|
return diff;
|
|
}
|
|
/*NOTREACHED */
|
|
}
|
|
#endif
|
|
|
|
/* The following routine was donated for UTS21 by dwd@bell-labs.com */
|
|
#if (!APR_HAVE_STRSTR)
|
|
char *strstr(char *s1, char *s2)
|
|
{
|
|
char *p1, *p2;
|
|
if (*s2 == '\0') {
|
|
/* an empty s2 */
|
|
return(s1);
|
|
}
|
|
while((s1 = strchr(s1, *s2)) != NULL) {
|
|
/* found first character of s2, see if the rest matches */
|
|
p1 = s1;
|
|
p2 = s2;
|
|
while (*++p1 == *++p2) {
|
|
if (*p1 == '\0') {
|
|
/* both strings ended together */
|
|
return(s1);
|
|
}
|
|
}
|
|
if (*p2 == '\0') {
|
|
/* second string ended, a match */
|
|
break;
|
|
}
|
|
/* didn't find a match here, try starting at next character in s1 */
|
|
s1++;
|
|
}
|
|
return(s1);
|
|
}
|
|
#endif
|
|
|