/* 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.

*/

/*

* util.c: string utility things

*

* 3/21/93 Rob McCool

* 1995-96 Many changes by the Apache Software Foundation

*

*/

/* Debugging aid:

* #define DEBUG to trace all cfg_open*()/cfg_closefile() calls

* #define DEBUG_CFG_LINES to trace every line read from the config files

*/

#include "apr.h"

#include "apr_strings.h"

#include "apr_lib.h"

#define APR_WANT_STDIO

#define APR_WANT_STRFUNC

#include "apr_want.h"

#if APR_HAVE_UNISTD_H

#include <unistd.h>

#endif

#if APR_HAVE_NETDB_H

#include <netdb.h> /* for gethostbyname() */

#endif

#define CORE_PRIVATE

#include "ap_config.h"

#include "apr_base64.h"

#include "httpd.h"

#include "http_main.h"

#include "http_log.h"

#include "http_protocol.h"

#include "http_config.h"

#include "util_ebcdic.h"

#ifdef HAVE_PWD_H

#include <pwd.h>

#endif

#ifdef HAVE_GRP_H

#include <grp.h>

#endif

/* A bunch of functions in util.c scan strings looking for certain characters.

* To make that more efficient we encode a lookup table. The test_char_table

* is generated automatically by gen_test_char.c.

*/

#include "test_char.h"

/* we assume the folks using this ensure 0 <= c < 256... which means

* you need a cast to (unsigned char) first, you can't just plug a

* char in here and get it to work, because if char is signed then it

* will first be sign extended.

*/

#define TEST_CHAR(c, f) (test_char_table[(unsigned)(c)] & (f))

/* Win32/NetWare/OS2 need to check for both forward and back slashes

* in ap_getparents() and ap_escape_url.

*/

#ifdef CASE_BLIND_FILESYSTEM

#define IS_SLASH(s) ((s == '/') || (s == '\\'))

#else

#define IS_SLASH(s) (s == '/')

#endif

/* same as APR_SIZE_MAX which doesn't appear until APR 1.3 */

#define UTIL_SIZE_MAX (~((apr_size_t)0))

/*

* Examine a field value (such as a media-/content-type) string and return

* it sans any parameters; e.g., strip off any ';charset=foo' and the like.

*/

AP_DECLARE(char *) ap_field_noparam(apr_pool_t *p, const char *intype)

{

const char *semi;

if (intype == NULL) return NULL;

semi = ap_strchr_c(intype, ';');

if (semi == NULL) {

return apr_pstrdup(p, intype);

}

else {

while ((semi > intype) && apr_isspace(semi[-1])) {

semi--;

}

return apr_pstrndup(p, intype, semi - intype);

}

}

AP_DECLARE(char *) ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt,

int gmt)

{

apr_size_t retcode;

char ts[MAX_STRING_LEN];

char tf[MAX_STRING_LEN];

apr_time_exp_t xt;

if (gmt) {

const char *f;

char *strp;

apr_time_exp_gmt(&xt, t);

/* Convert %Z to "GMT" and %z to "+0000";

* on hosts that do not have a time zone string in struct tm,

* strftime must assume its argument is local time.

*/

for(strp = tf, f = fmt; strp < tf + sizeof(tf) - 6 && (*strp = *f)

; f++, strp++) {

if (*f != '%') continue;

switch (f[1]) {

case '%':

*++strp = *++f;

break;

case 'Z':

*strp++ = 'G';

*strp++ = 'M';

*strp = 'T';

f++;

break;

case 'z': /* common extension */

*strp++ = '+';

*strp++ = '0';

*strp++ = '0';

*strp++ = '0';

*strp = '0';

f++;

break;

}

}

*strp = '\0';

fmt = tf;

}

else {

apr_time_exp_lt(&xt, t);

}

/* check return code? */

apr_strftime(ts, &retcode, MAX_STRING_LEN, fmt, &xt);

ts[MAX_STRING_LEN - 1] = '\0';

return apr_pstrdup(p, ts);

}

/* Roy owes Rob beer. */

/* Rob owes Roy dinner. */

/* These legacy comments would make a lot more sense if Roy hadn't

* replaced the old later_than() routine with util_date.c.

*

* Well, okay, they still wouldn't make any sense.

*/

/* Match = 0, NoMatch = 1, Abort = -1

* Based loosely on sections of wildmat.c by Rich Salz

* Hmmm... shouldn't this really go component by component?

*/

AP_DECLARE(int) ap_strcmp_match(const char *str, const char *expected)

{

int x, y;

for (x = 0, y = 0; expected[y]; ++y, ++x) {

if ((!str[x]) && (expected[y] != '*'))

return -1;

if (expected[y] == '*') {

while (expected[++y] == '*');

if (!expected[y])

return 0;

while (str[x]) {

int ret;

if ((ret = ap_strcmp_match(&str[x++], &expected[y])) != 1)

return ret;

}

return -1;

}

else if ((expected[y] != '?') && (str[x] != expected[y]))

return 1;

}

return (str[x] != '\0');

}

AP_DECLARE(int) ap_strcasecmp_match(const char *str, const char *expected)

{

int x, y;

for (x = 0, y = 0; expected[y]; ++y, ++x) {

if (!str[x] && expected[y] != '*')

return -1;

if (expected[y] == '*') {

while (expected[++y] == '*');

if (!expected[y])

return 0;

while (str[x]) {

int ret;

if ((ret = ap_strcasecmp_match(&str[x++], &expected[y])) != 1)

return ret;

}

return -1;

}

else if (expected[y] != '?'

&& apr_tolower(str[x]) != apr_tolower(expected[y]))

return 1;

}

return (str[x] != '\0');

}

/* We actually compare the canonical root to this root, (but we don't

* waste time checking the case), since every use of this function in

* httpd-2.1 tests if the path is 'proper', meaning we've already passed

* it through apr_filepath_merge, or we haven't.

*/

AP_DECLARE(int) ap_os_is_path_absolute(apr_pool_t *p, const char *dir)

{

const char *newpath;

const char *ourdir = dir;

if (apr_filepath_root(&newpath, &dir, 0, p) != APR_SUCCESS

|| strncmp(newpath, ourdir, strlen(newpath)) != 0) {

return 0;

}

return 1;

}

AP_DECLARE(int) ap_is_matchexp(const char *str)

{

register int x;

for (x = 0; str[x]; x++)

if ((str[x] == '*') || (str[x] == '?'))

return 1;

return 0;

}

/*

* Here's a pool-based interface to the POSIX-esque ap_regcomp().

* Note that we return ap_regex_t instead of being passed one.

* The reason is that if you use an already-used ap_regex_t structure,

* the memory that you've already allocated gets forgotten, and

* regfree() doesn't clear it. So we don't allow it.

*/

static apr_status_t regex_cleanup(void *preg)

{

ap_regfree((ap_regex_t *) preg);

return APR_SUCCESS;

}

AP_DECLARE(ap_regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,

int cflags)

{

ap_regex_t *preg = apr_palloc(p, sizeof *preg);

if (ap_regcomp(preg, pattern, cflags)) {

return NULL;

}

apr_pool_cleanup_register(p, (void *) preg, regex_cleanup,

apr_pool_cleanup_null);

return preg;

}

AP_DECLARE(void) ap_pregfree(apr_pool_t *p, ap_regex_t *reg)

{

ap_regfree(reg);

apr_pool_cleanup_kill(p, (void *) reg, regex_cleanup);

}

/*

* Similar to standard strstr() but we ignore case in this version.

* Based on the strstr() implementation further below.

*/

AP_DECLARE(char *) ap_strcasestr(const char *s1, const char *s2)

{

char *p1, *p2;

if (*s2 == '\0') {

/* an empty s2 */

return((char *)s1);

}

while(1) {

for ( ; (*s1 != '\0') && (apr_tolower(*s1) != apr_tolower(*s2)); s1++);

if (*s1 == '\0') {

return(NULL);

}

/* found first character of s2, see if the rest matches */

p1 = (char *)s1;

p2 = (char *)s2;

for (++p1, ++p2; apr_tolower(*p1) == apr_tolower(*p2); ++p1, ++p2) {

if (*p1 == '\0') {

/* both strings ended together */

return((char *)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((char *)s1);

}

/*

* Returns an offsetted pointer in bigstring immediately after

* prefix. Returns bigstring if bigstring doesn't start with

* prefix or if prefix is longer than bigstring while still matching.

* NOTE: pointer returned is relative to bigstring, so we

* can use standard pointer comparisons in the calling function

* (eg: test if ap_stripprefix(a,b) == a)

*/

AP_DECLARE(const char *) ap_stripprefix(const char *bigstring,

const char *prefix)

{

const char *p1;

if (*prefix == '\0')

return bigstring;

p1 = bigstring;

while (*p1 && *prefix) {

if (*p1++ != *prefix++)

return bigstring;

}

if (*prefix == '\0')

return p1;

/* hit the end of bigstring! */

return bigstring;

}

/* This function substitutes for $0-$9, filling in regular expression

* submatches. Pass it the same nmatch and pmatch arguments that you

* passed ap_regexec(). pmatch should not be greater than the maximum number

* of subexpressions - i.e. one more than the re_nsub member of ap_regex_t.

*

* input should be the string with the $-expressions, source should be the

* string that was matched against.

*

* It returns the substituted string, or NULL on error.

*

* Parts of this code are based on Henry Spencer's regsub(), from his

* AT&T V8 regexp package.

*/

AP_DECLARE(char *) ap_pregsub(apr_pool_t *p, const char *input,

const char *source, size_t nmatch,

ap_regmatch_t pmatch[])

{

const char *src = input;

char *dest, *dst;

char c;

size_t no;

apr_size_t len;

if (!source)

return NULL;

if (!nmatch)

return apr_pstrdup(p, src);

/* First pass, find the size */

len = 0;

while ((c = *src++) != '\0') {

if (c == '&')

no = 0;

else if (c == '$' && apr_isdigit(*src))

no = *src++ - '0';

else

no = 10;

if (no > 9) { /* Ordinary character. */

if (c == '\\' && (*src == '$' || *src == '&'))

src++;

len++;

}

else if (no < nmatch && pmatch[no].rm_so < pmatch[no].rm_eo) {

if (UTIL_SIZE_MAX - len <= pmatch[no].rm_eo - pmatch[no].rm_so) {

ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL,

"integer overflow or out of memory condition." );

return NULL;

}

len += pmatch[no].rm_eo - pmatch[no].rm_so;

}

}

dest = dst = apr_pcalloc(p, len + 1);

/* Now actually fill in the string */

src = input;

while ((c = *src++) != '\0') {

if (c == '&')

no = 0;

else if (c == '$' && apr_isdigit(*src))

no = *src++ - '0';

else

no = 10;

if (no > 9) { /* Ordinary character. */

if (c == '\\' && (*src == '$' || *src == '&'))

c = *src++;

*dst++ = c;

}

else if (no < nmatch && pmatch[no].rm_so < pmatch[no].rm_eo) {

len = pmatch[no].rm_eo - pmatch[no].rm_so;

memcpy(dst, source + pmatch[no].rm_so, len);

dst += len;

}

}

*dst = '\0';

return dest;

}

/*

* Parse .. so we don't compromise security

*/

AP_DECLARE(void) ap_getparents(char *name)

{

char *next;

int l, w, first_dot;

/* Four paseses, as per RFC 1808 */

/* a) remove ./ path segments */

for (next = name; *next && (*next != '.'); next++) {

}

l = w = first_dot = next - name;

while (name[l] != '\0') {

if (name[l] == '.' && IS_SLASH(name[l + 1])

&& (l == 0 || IS_SLASH(name[l - 1])))

l += 2;

else

name[w++] = name[l++];

}

/* b) remove trailing . path, segment */

if (w == 1 && name[0] == '.')

w--;

else if (w > 1 && name[w - 1] == '.' && IS_SLASH(name[w - 2]))

w--;

name[w] = '\0';

/* c) remove all xx/../ segments. (including leading ../ and /../) */

l = first_dot;

while (name[l] != '\0') {

if (name[l] == '.' && name[l + 1] == '.' && IS_SLASH(name[l + 2])

&& (l == 0 || IS_SLASH(name[l - 1]))) {

register int m = l + 3, n;

l = l - 2;

if (l >= 0) {

while (l >= 0 && !IS_SLASH(name[l]))

l--;

l++;

}

else

l = 0;

n = l;

while ((name[n] = name[m]))

(++n, ++m);

}

else

++l;

}

/* d) remove trailing xx/.. segment. */

if (l == 2 && name[0] == '.' && name[1] == '.')

name[0] = '\0';

else if (l > 2 && name[l - 1] == '.' && name[l - 2] == '.'

&& IS_SLASH(name[l - 3])) {

l = l - 4;

if (l >= 0) {

while (l >= 0 && !IS_SLASH(name[l]))

l--;

l++;

}

else

l = 0;

name[l] = '\0';

}

}

AP_DECLARE(void) ap_no2slash(char *name)

{

char *d, *s;

s = d = name;

#ifdef HAVE_UNC_PATHS

/* Check for UNC names. Leave leading two slashes. */

if (s[0] == '/' && s[1] == '/')

*d++ = *s++;

#endif

while (*s) {

if ((*d++ = *s) == '/') {

do {

++s;

} while (*s == '/');

}

else {

++s;

}

}

*d = '\0';

}

/*

* copy at most n leading directories of s into d

* d should be at least as large as s plus 1 extra byte

* assumes n > 0

* the return value is the ever useful pointer to the trailing \0 of d

*

* MODIFIED FOR HAVE_DRIVE_LETTERS and NETWARE environments,

* so that if n == 0, "/" is returned in d with n == 1

* and s == "e:/test.html", "e:/" is returned in d

* *** See also directory_walk in modules/http/http_request.c

* examples:

* /a/b, 0 ==> / (true for all platforms)

* /a/b, 1 ==> /

* /a/b, 2 ==> /a/

* /a/b, 3 ==> /a/b/

* /a/b, 4 ==> /a/b/

*

* c:/a/b 0 ==> /

* c:/a/b 1 ==> c:/

* c:/a/b 2 ==> c:/a/

* c:/a/b 3 ==> c:/a/b

* c:/a/b 4 ==> c:/a/b

*/

AP_DECLARE(char *) ap_make_dirstr_prefix(char *d, const char *s, int n)

{

if (n < 1) {

*d = '/';

*++d = '\0';

return (d);

}

for (;;) {

if (*s == '\0' || (*s == '/' && (--n) == 0)) {

*d = '/';

break;

}

*d++ = *s++;

}

*++d = 0;

return (d);

}

/*

* return the parent directory name including trailing / of the file s

*/

AP_DECLARE(char *) ap_make_dirstr_parent(apr_pool_t *p, const char *s)

{

const char *last_slash = ap_strrchr_c(s, '/');

char *d;

int l;

if (last_slash == NULL) {

return apr_pstrdup(p, "");

}

l = (last_slash - s) + 1;

d = apr_palloc(p, l + 1);

memcpy(d, s, l);

d[l] = 0;

return (d);

}

AP_DECLARE(int) ap_count_dirs(const char *path)

{

register int x, n;

for (x = 0, n = 0; path[x]; x++)

if (path[x] == '/')

n++;

return n;

}

AP_DECLARE(char *) ap_getword_nc(apr_pool_t *atrans, char **line, char stop)

{

return ap_getword(atrans, (const char **) line, stop);

}

AP_DECLARE(char *) ap_getword(apr_pool_t *atrans, const char **line, char stop)

{

const char *pos = *line;

int len;

char *res;

while ((*pos != stop) && *pos) {

++pos;

}

len = pos - *line;

res = (char *)apr_palloc(atrans, len + 1);

memcpy(res, *line, len);

res[len] = 0;

if (stop) {

while (*pos == stop) {

++pos;

}

}

*line = pos;

return res;

}

AP_DECLARE(char *) ap_getword_white_nc(apr_pool_t *atrans, char **line)

{

return ap_getword_white(atrans, (const char **) line);

}

AP_DECLARE(char *) ap_getword_white(apr_pool_t *atrans, const char **line)

{

const char *pos = *line;

int len;

char *res;

while (!apr_isspace(*pos) && *pos) {

++pos;

}

len = pos - *line;

res = (char *)apr_palloc(atrans, len + 1);

memcpy(res, *line, len);

res[len] = 0;

while (apr_isspace(*pos)) {

++pos;

}

*line = pos;

return res;

}

AP_DECLARE(char *) ap_getword_nulls_nc(apr_pool_t *atrans, char **line,

char stop)

{

return ap_getword_nulls(atrans, (const char **) line, stop);

}

AP_DECLARE(char *) ap_getword_nulls(apr_pool_t *atrans, const char **line,

char stop)

{

const char *pos = ap_strchr_c(*line, stop);

char *res;

if (!pos) {

res = apr_pstrdup(atrans, *line);

*line += strlen(*line);

return res;

}

res = apr_pstrndup(atrans, *line, pos - *line);

++pos;

*line = pos;

return res;

}

/* Get a word, (new) config-file style --- quoted strings and backslashes

* all honored

*/

static char *substring_conf(apr_pool_t *p, const char *start, int len,

char quote)

{

char *result = apr_palloc(p, len + 2);

char *resp = result;

int i;

for (i = 0; i < len; ++i) {

if (start[i] == '\\' && (start[i + 1] == '\\'

|| (quote && start[i + 1] == quote)))

*resp++ = start[++i];

else

*resp++ = start[i];

}

*resp++ = '\0';

#if RESOLVE_ENV_PER_TOKEN

return (char *)ap_resolve_env(p,result);

#else

return result;

#endif

}

AP_DECLARE(char *) ap_getword_conf_nc(apr_pool_t *p, char **line)

{

return ap_getword_conf(p, (const char **) line);

}

AP_DECLARE(char *) ap_getword_conf(apr_pool_t *p, const char **line)

{

const char *str = *line, *strend;

char *res;

char quote;

while (*str && apr_isspace(*str))

++str;

if (!*str) {

*line = str;

return "";

}

if ((quote = *str) == '"' || quote == '\'') {

strend = str + 1;

while (*strend && *strend != quote) {

if (*strend == '\\' && strend[1] &&

(strend[1] == quote || strend[1] == '\\')) {

strend += 2;

}

else {

++strend;

}

}

res = substring_conf(p, str + 1, strend - str - 1, quote);

if (*strend == quote)

++strend;

}

else {

strend = str;

while (*strend && !apr_isspace(*strend))

++strend;

res = substring_conf(p, str, strend - str, 0);

}

while (*strend && apr_isspace(*strend))

++strend;

*line = strend;

return res;

}

/* Check a string for any ${ENV} environment variable

* construct and replace each them by the value of

* that environment variable, if it exists. If the

* environment value does not exist, leave the ${ENV}

* construct alone; it means something else.

*/

AP_DECLARE(const char *) ap_resolve_env(apr_pool_t *p, const char * word)

{

# define SMALL_EXPANSION 5

struct sll {

struct sll *next;

const char *string;

apr_size_t len;

} *result, *current, sresult[SMALL_EXPANSION];

char *res_buf, *cp;

const char *s, *e, *ep;

unsigned spc;

apr_size_t outlen;

s = ap_strchr_c(word, '$');

if (!s) {

return word;

}

/* well, actually something to do */

ep = word + strlen(word);

spc = 0;

result = current = &(sresult[spc++]);

current->next = NULL;

current->string = word;

current->len = s - word;

outlen = current->len;

do {

/* prepare next entry */

if (current->len) {

current->next = (spc < SMALL_EXPANSION)

? &(sresult[spc++])

: (struct sll *)apr_palloc(p,

sizeof(*current->next));

current = current->next;

current->next = NULL;

current->len = 0;

}

if (*s == '$') {

if (s[1] == '{' && (e = ap_strchr_c(s, '}'))) {

word = getenv(apr_pstrndup(p, s+2, e-s-2));

if (word) {

current->string = word;

current->len = strlen(word);

outlen += current->len;

}

else {

current->string = s;

current->len = e - s + 1;

outlen += current->len;

}

s = e + 1;

}

else {

current->string = s++;

current->len = 1;

++outlen;

}

}

else {

word = s;

s = ap_strchr_c(s, '$');

current->string = word;

current->len = s ? s - word : ep - word;

outlen += current->len;

}

} while (s && *s);

/* assemble result */

res_buf = cp = apr_palloc(p, outlen + 1);

do {

if (result->len) {

memcpy(cp, result->string, result->len);

cp += result->len;

}

result = result->next;

} while (result);

res_buf[outlen] = '\0';

return res_buf;

}

AP_DECLARE(int) ap_cfg_closefile(ap_configfile_t *cfp)

{

#ifdef DEBUG

ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,

"Done with config file %s", cfp->name);

#endif

return (cfp->close == NULL) ? 0 : cfp->close(cfp->param);

}

static apr_status_t cfg_close(void *param)

{

apr_file_t *cfp = (apr_file_t *) param;

return (apr_file_close(cfp));

}

static int cfg_getch(void *param)

{

char ch;

apr_file_t *cfp = (apr_file_t *) param;

if (apr_file_getc(&ch, cfp) == APR_SUCCESS)

return ch;

return (int)EOF;

}

static void *cfg_getstr(void *buf, size_t bufsiz, void *param)

{

apr_file_t *cfp = (apr_file_t *) param;

apr_status_t rv;

rv = apr_file_gets(buf, bufsiz, cfp);

if (rv == APR_SUCCESS) {

return buf;

}

return NULL;

}

/* Open a ap_configfile_t as FILE, return open ap_configfile_t struct pointer */

AP_DECLARE(apr_status_t) ap_pcfg_openfile(ap_configfile_t **ret_cfg,

apr_pool_t *p, const char *name)

{

ap_configfile_t *new_cfg;

apr_file_t *file = NULL;

apr_finfo_t finfo;

apr_status_t status;

#ifdef DEBUG

char buf[120];

#endif

if (name == NULL) {

ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL,

"Internal error: pcfg_openfile() called with NULL filename");

return APR_EBADF;

}

status = apr_file_open(&file, name, APR_READ | APR_BUFFERED,

APR_OS_DEFAULT, p);

#ifdef DEBUG

ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,

"Opening config file %s (%s)",

name, (status != APR_SUCCESS) ?

apr_strerror(status, buf, sizeof(buf)) : "successful");

#endif

if (status != APR_SUCCESS)

return status;

status = apr_file_info_get(&finfo, APR_FINFO_TYPE, file);

if (status != APR_SUCCESS)

return status;

if (finfo.filetype != APR_REG &&

#if defined(WIN32) || defined(OS2) || defined(NETWARE)

strcasecmp(apr_filepath_name_get(name), "nul") != 0) {

#else

strcmp(name, "/dev/null") != 0) {

#endif /* WIN32 || OS2 */

ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL,

"Access to file %s denied by server: not a regular file",

name);

apr_file_close(file);

return APR_EBADF;

}

#ifdef WIN32

/* Some twisted character [no pun intended] at MS decided that a

* zero width joiner as the lead wide character would be ideal for

* describing Unicode text files. This was further convoluted to

* another MSism that the same character mapped into utf-8, EF BB BF

* would signify utf-8 text files.

*

* Since MS configuration files are all protecting utf-8 encoded

* Unicode path, file and resource names, we already have the correct

* WinNT encoding. But at least eat the stupid three bytes up front.

*/

{

unsigned char buf[4];

apr_size_t len = 3;

status = apr_file_read(file, buf, &len);

if ((status != APR_SUCCESS) || (len < 3)

|| memcmp(buf, "\xEF\xBB\xBF", 3) != 0) {

apr_off_t zero = 0;

apr_file_seek(file, APR_SET, &zero);

}

}

#endif

new_cfg = apr_palloc(p, sizeof(*new_cfg));

new_cfg->param = file;

new_cfg->name = apr_pstrdup(p, name);

new_cfg->getch = (int (*)(void *)) cfg_getch;

new_cfg->getstr = (void *(*)(void *, size_t, void *)) cfg_getstr;

new_cfg->close = (int (*)(void *)) cfg_close;

new_cfg->line_number = 0;

*ret_cfg = new_cfg;

return APR_SUCCESS;

}

/* Allocate a ap_configfile_t handle with user defined functions and params */

AP_DECLARE(ap_configfile_t *) ap_pcfg_open_custom(apr_pool_t *p,

const char *descr,

void *param,

int(*getch)(void *param),

void *(*getstr) (void *buf, size_t bufsiz, void *param),

int(*close_func)(void *param))

{

ap_configfile_t *new_cfg = apr_palloc(p, sizeof(*new_cfg));

#ifdef DEBUG

ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,

"Opening config handler %s", descr);

#endif

new_cfg->param = param;

new_cfg->name = descr;

new_cfg->getch = getch;

new_cfg->getstr = getstr;

new_cfg->close = close_func;

new_cfg->line_number = 0;

return new_cfg;

}

/* Read one character from a configfile_t */

AP_DECLARE(int) ap_cfg_getc(ap_configfile_t *cfp)

{

register int ch = cfp->getch(cfp->param);

if (ch == LF)