4aa6e7782a1b693a8e4fa1d84c87dd76fe1e536dLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "apr.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "apr_strings.h"

07bceef2a9c520e24da427c7ce500ad36ad37571Lennart Poettering#include "apr_lib.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#define APR_WANT_STDIO

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#define APR_WANT_STRFUNC

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "apr_want.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#if APR_HAVE_UNISTD_H

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include <unistd.h>

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#endif

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#if APR_HAVE_NETDB_H

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

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#endif

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#define CORE_PRIVATE

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "ap_config.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "apr_base64.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "httpd.h"

8f28cbcdfe55bdaaa3e8f9c68f39b1369dd0e5ddA. Costa#include "http_main.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "http_log.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "http_protocol.h"

409dee2e44e7dc73d6bf00d782938e4cb4105f5bJan Engelhardt#include "http_config.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "util_ebcdic.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#ifdef HAVE_PWD_H

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include <pwd.h>

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#endif

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#ifdef HAVE_GRP_H

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include <grp.h>

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#endif

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering#include "test_char.h"

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

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

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart PoetteringAP_DECLARE(char *) ap_field_noparam(apr_pool_t *p, const char *intype)

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering{

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering const char *semi;

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering if (intype == NULL) return NULL;

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering semi = ap_strchr_c(intype, ';');

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering if (semi == NULL) {

8f28cbcdfe55bdaaa3e8f9c68f39b1369dd0e5ddA. Costa return apr_pstrdup(p, intype);

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering }

845c53246f73a505f12bb7f685a530045fa60a40Zbigniew Jędrzejewski-Szmek else {

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

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering semi--;

409dee2e44e7dc73d6bf00d782938e4cb4105f5bJan Engelhardt }

76e7bc8dfbb1139254c3819f448246592f17f317Lennart Poettering return apr_pstrndup(p, intype, semi - intype);

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering }

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering}

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart PoetteringAP_DECLARE(char *) ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt, int gmt)

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering{

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering apr_size_t retcode;

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering char ts[MAX_STRING_LEN];

4aa6e7782a1b693a8e4fa1d84c87dd76fe1e536dLennart Poettering char tf[MAX_STRING_LEN];

4aa6e7782a1b693a8e4fa1d84c87dd76fe1e536dLennart Poettering apr_exploded_time_t xt;

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering if (gmt) {

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering const char *f;

ee48647271132188e9ecc3507e62b6c7c7a6c9ebLennart Poettering char *strp;

apr_explode_gmt(&xt, t);

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

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_explode_localtime(&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);

}

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

{

int x, y;

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

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

return -1;

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

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

if (!exp[y])

return 0;

while (str[x]) {

int ret;

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

return ret;

}

return -1;

}

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

return 1;

}

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

}

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

{

int x, y;

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

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

return -1;

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

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

if (!exp[y])

return 0;

while (str[x]) {

int ret;

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

return ret;

}

return -1;

}

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

return 1;

}

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

}

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

{

const char *newpath;

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

|| strncmp(newpath, dir, 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;

}

static apr_status_t regex_cleanup(void *preg)

{

regfree((regex_t *) preg);

return APR_SUCCESS;

}

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

int cflags)

{

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

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

return NULL;

}

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

return preg;

}

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

{

regfree(reg);

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

}

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;

while (apr_tolower(*++p1) == apr_tolower(*++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);

}

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;

}

AP_DECLARE(int) ap_regexec(regex_t *preg, const char *string,

size_t nmatch, regmatch_t pmatch[], int eflags)

{

return regexec(preg, string, nmatch, pmatch, eflags);

}

AP_DECLARE(size_t) ap_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)

{

return regerror(errcode, preg, errbuf, errbuf_size);

}

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

size_t nmatch, regmatch_t pmatch[])

{

const char *src = input;

char *dest, *dst;

char c;

size_t no;

int 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 == '&'))

c = *src++;

len++;

}

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

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;

}

AP_DECLARE(void) ap_getparents(char *name)

{

int l, w;

/* Four paseses, as per RFC 1808 */

/* a) remove ./ path segments */

for (l = 0, w = 0; name[l] != '\0';) {

if (name[l] == '.' && name[l + 1] == '/' && (l == 0 || 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] == '.' && name[w - 2] == '/')

w--;

name[w] = '\0';

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

l = 0;

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

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

(l == 0 || name[l - 1] == '/')) {

register int m = l + 3, n;

l = l - 2;

if (l >= 0) {

while (l >= 0 && 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] == '.' && name[l - 3] == '/') {

l = l - 4;

if (l >= 0) {

while (l >= 0 && 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';

}

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);

}

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 NULL;

}

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 = 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);

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)

{

int pos = -1, x;

char *res;

for (x = 0; (*line)[x]; x++) {

if (apr_isspace((*line)[x])) {

pos = x;

break;

}

}

if (pos == -1) {

res = apr_pstrdup(atrans, *line);

*line += strlen(*line);

return res;

}

res = apr_palloc(atrans, pos + 1);

apr_cpystrn(res, *line, pos + 1);

while (apr_isspace((*line)[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;

}

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 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 += 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;

}

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

{

char tmp[ MAX_STRING_LEN ];

const char *s, *e;

tmp[0] = '\0';

if (!(s=ap_strchr_c(word,'$')))

return word;

do {

/* XXX - relies on strncat() to add '\0'

strncat(tmp,word,s - word);

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

const char *e2 = e;

word = e + 1;

e = getenv(s+2);

if (e) {

strcat(tmp,e);

} else {

strncat(tmp, s, e2-s);

strcat(tmp,"}");

}

} else {

/* ignore invalid strings */

word = s+1;

strcat(tmp,"$");

};

} while ((s=ap_strchr_c(word,'$')));

strcat(tmp,word);

return apr_pstrdup(p,tmp);

}

AP_DECLARE(int) ap_cfg_closefile(ap_configfile_t *cfp)

{

#ifdef DEBUG

ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 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 || (rv == APR_EOF && strcmp(buf, "")))

return buf;

return NULL;

}

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 | APLOG_NOERRNO, 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 | APLOG_NOERRNO, 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)

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

#else

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

#endif /* WIN32 || OS2 */

ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_NOERRNO, 0, NULL,

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

name);

apr_file_close(file);

return APR_EBADF;

}

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;

}

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 | APLOG_NOERRNO, 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;

}

AP_DECLARE(int) ap_cfg_getc(ap_configfile_t *cfp)

{

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

if (ch == LF)

++cfp->line_number;

return ch;

}

AP_DECLARE(int) ap_cfg_getline(char *buf, size_t bufsize, ap_configfile_t *cfp)

{

/* If a "get string" function is defined, use it */

if (cfp->getstr != NULL) {

char *src, *dst;

char *cp;

char *cbuf = buf;

size_t cbufsize = bufsize;

while (1) {

++cfp->line_number;

if (cfp->getstr(cbuf, cbufsize, cfp->param) == NULL)

return 1;

/*

cp = cbuf;

while (cp < cbuf+cbufsize && *cp != '\0')

cp++;

if (cp > cbuf && cp[-1] == LF) {

cp--;

if (cp > cbuf && cp[-1] == CR)

cp--;

if (cp > cbuf && cp[-1] == '\\') {

cp--;

if (!(cp > cbuf && cp[-1] == '\\')) {

/*

cbufsize -= (cp-cbuf);

cbuf = cp;

continue;

}

else {

/*

for ( ; cp < cbuf+cbufsize && *cp != '\0'; cp++)

cp[0] = cp[1];

}

}

}

break;

}

/*

src = buf;

while (apr_isspace(*src))

++src;

/* blast trailing whitespace */

dst = &src[strlen(src)];

while (--dst >= src && apr_isspace(*dst))

*dst = '\0';

/* Zap leading whitespace by shifting */

if (src != buf)

for (dst = buf; (*dst++ = *src++) != '\0'; )

;

#ifdef DEBUG_CFG_LINES

ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, NULL, "Read config: %s", buf);

#endif

return 0;

} else {

/* No "get string" function defined; read character by character */

register int c;

register size_t i = 0;

buf[0] = '\0';

/* skip leading whitespace */

do {

c = cfp->getch(cfp->param);

} while (c == '\t' || c == ' ');

if (c == EOF)

return 1;

if(bufsize < 2) {

/* too small, assume caller is crazy */

return 1;

}

while (1) {

if ((c == '\t') || (c == ' ')) {

buf[i++] = ' ';

while ((c == '\t') || (c == ' '))

c = cfp->getch(cfp->param);

}

if (c == CR) {

/* silently ignore CR (_assume_ that a LF follows) */

c = cfp->getch(cfp->param);

}

if (c == LF) {

/* increase line number and return on LF */

++cfp->line_number;

}

if (c == EOF || c == 0x4 || c == LF || i >= (bufsize - 2)) {

/*

if (i > 0 && buf[i-1] == '\\') {

i--;

if (!(i > 0 && buf[i-1] == '\\')) {

/* line is continued */

c = cfp->getch(cfp->param);

continue;

}

/* else nothing needs be done because

}

/* blast trailing whitespace */

while (i > 0 && apr_isspace(buf[i - 1]))

--i;

buf[i] = '\0';

#ifdef DEBUG_CFG_LINES

ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, NULL, "Read config: %s", buf);

#endif

return 0;

}

buf[i] = c;

++i;

c = cfp->getch(cfp->param);

}

}

}

AP_DECLARE(const char *) ap_size_list_item(const char **field, int *len)

{

const unsigned char *ptr = (const unsigned char *)*field;

const unsigned char *token;

int in_qpair, in_qstr, in_com;

/* Find first non-comma, non-whitespace byte */

while (*ptr == ',' || apr_isspace(*ptr))

++ptr;

token = ptr;

/* Find the end of this item, skipping over dead bits */

for (in_qpair = in_qstr = in_com = 0;

*ptr && (in_qpair || in_qstr || in_com || *ptr != ',');

++ptr) {

if (in_qpair) {

in_qpair = 0;

}

else {

switch (*ptr) {

case '\\': in_qpair = 1; /* quoted-pair */

break;

case '"' : if (!in_com) /* quoted string delim */

in_qstr = !in_qstr;

break;

case '(' : if (!in_qstr) /* comment (may nest) */

++in_com;

break;

case ')' : if (in_com) /* end comment */

--in_com;

break;

default : break;

}

}

}

if ((*len = (ptr - token)) == 0) {

*field = (const char *)ptr;

return NULL;

}

/* Advance field pointer to the next non-comma, non-white byte */

while (*ptr == ',' || apr_isspace(*ptr))

++ptr;

*field = (const char *)ptr;

return (const char *)token;

}

AP_DECLARE(char *) ap_get_list_item(apr_pool_t *p, const char **field)

{

const char *tok_start;

const unsigned char *ptr;

unsigned char *pos;

char *token;

int addspace = 0, in_qpair = 0, in_qstr = 0, in_com = 0, tok_len = 0;

/* Find the beginning and maximum length of the list item so that

if ((tok_start = ap_size_list_item(field, &tok_len)) == NULL) {

return NULL;

}

token = apr_palloc(p, tok_len + 1);

/* Scan the token again, but this time copy only the good bytes.

for (ptr = (const unsigned char *)tok_start, pos = (unsigned char *)token;

*ptr && (in_qpair || in_qstr || in_com || *ptr != ',');

++ptr) {

if (in_qpair) {

in_qpair = 0;

*pos++ = *ptr;

}

else {

switch (*ptr) {

case '\\': in_qpair = 1;

if (addspace == 1)

*pos++ = ' ';

*pos++ = *ptr;

addspace = 0;

break;

case '"' : if (!in_com)

in_qstr = !in_qstr;

if (addspace == 1)

*pos++ = ' ';

*pos++ = *ptr;

addspace = 0;

break;

case '(' : if (!in_qstr)

++in_com;

if (addspace == 1)

*pos++ = ' ';

*pos++ = *ptr;

addspace = 0;

break;

case ')' : if (in_com)

--in_com;

*pos++ = *ptr;

addspace = 0;

break;

case ' ' :

case '\t': if (addspace)

break;

if (in_com || in_qstr)

*pos++ = *ptr;

else

addspace = 1;

break;

case '=' :

case '/' :

case ';' : if (!(in_com || in_qstr))

addspace = -1;

*pos++ = *ptr;

break;

default : if (addspace == 1)

*pos++ = ' ';

*pos++ = (in_com || in_qstr) ? *ptr

: apr_tolower(*ptr);

addspace = 0;

break;

}

}

}

*pos = '\0';

return token;

}

AP_DECLARE(int) ap_find_list_item(apr_pool_t *p, const char *line, const char *tok)

{

const unsigned char *pos;

const unsigned char *ptr = (const unsigned char *)line;

int good = 0, addspace = 0, in_qpair = 0, in_qstr = 0, in_com = 0;

if (!line || !tok)

return 0;

do { /* loop for each item in line's list */

/* Find first non-comma, non-whitespace byte */

while (*ptr == ',' || apr_isspace(*ptr))

++ptr;

if (*ptr)

good = 1; /* until proven otherwise for this item */

else

break; /* no items left and nothing good found */

/* We skip extra whitespace and any whitespace around a '=', '/',

for (pos = (const unsigned char *)tok;

*ptr && (in_qpair || in_qstr || in_com || *ptr != ',');

++ptr) {

if (in_qpair) {

in_qpair = 0;

if (good)

good = (*pos++ == *ptr);

}

else {

switch (*ptr) {

case '\\': in_qpair = 1;

if (addspace == 1)

good = good && (*pos++ == ' ');

good = good && (*pos++ == *ptr);

addspace = 0;

break;

case '"' : if (!in_com)

in_qstr = !in_qstr;

if (addspace == 1)

good = good && (*pos++ == ' ');

good = good && (*pos++ == *ptr);

addspace = 0;

break;

case '(' : if (!in_qstr)

++in_com;

if (addspace == 1)

good = good && (*pos++ == ' ');

good = good && (*pos++ == *ptr);

addspace = 0;

break;

case ')' : if (in_com)

--in_com;

good = good && (*pos++ == *ptr);

addspace = 0;

break;

case ' ' :

case '\t': if (addspace || !good)

break;

if (in_com || in_qstr)

good = (*pos++ == *ptr);

else

addspace = 1;

break;

case '=' :

case '/' :

case ';' : if (!(in_com || in_qstr))

addspace = -1;

good = good && (*pos++ == *ptr);

break;

default : if (!good)

break;

if (addspace == 1)

good = (*pos++ == ' ');

if (in_com || in_qstr)

good = good && (*pos++ == *ptr);

else

good = good && (*pos++ == apr_tolower(*ptr));

addspace = 0;

break;

}

}

}

if (good && *pos)

good = 0; /* not good if only a prefix was matched */

} while (*ptr && !good);

return good;

}

AP_DECLARE(char *) ap_get_token(apr_pool_t *p, const char **accept_line, int accept_white)

{

const char *ptr = *accept_line;

const char *tok_start;

char *token;

int tok_len;

/* Find first non-white byte */