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

#include <process.h>            /* for getpid() on Win32 */

#endif

#if APR_HAVE_NETDB_H

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

#endif

#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 "http_core.h"

#include "util_ebcdic.h"

#include "util_varbuf.h"

#ifdef HAVE_PWD_H

#include <pwd.h>

#endif

#ifdef HAVE_GRP_H

#include <grp.h>

#endif

#ifdef HAVE_SYS_LOADAVG_H

#include <sys/loadavg.h>

#endif

#include "ap_mpm.h"

/* 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 char)(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 == '\\'))

#define SLASHES "/\\"

#else

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

#define SLASHES "/"

#endif

/* we know core's module_index is 0 */

#undef APLOG_MODULE_INDEX

#define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX

/*

 * 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_pstrmemdup(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)

{

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

    int err = ap_regcomp(preg, pattern, cflags);

    if (err) {

        if (err == AP_REG_ESPACE)

            ap_abort_on_oom();

        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.

 *

 * nmatch must be <=AP_MAX_REG_MATCH (10).

 *

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

 * string that was matched against.

 *

 * It returns the substituted string, or NULL if a vbuf is used.

 * On errors, returns the orig string.

 *

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

 * AT&T V8 regexp package.

 */

static apr_status_t regsub_core(apr_pool_t *p, char **result,

                                struct ap_varbuf *vb, const char *input,

                                const char *source, apr_size_t nmatch,

                                ap_regmatch_t pmatch[], apr_size_t maxlen)

{

    const char *src = input;

    char *dst;

    char c;

    apr_size_t no;

    apr_size_t len = 0;

    AP_DEBUG_ASSERT((result && p && !vb) || (vb && !p && !result));

    if (!source || nmatch>AP_MAX_REG_MATCH)

        return APR_EINVAL;

    if (!nmatch) {

        len = strlen(src);

        if (maxlen > 0 && len >= maxlen)

            return APR_ENOMEM;

        if (!vb) {

            *result = apr_pstrmemdup(p, src, len);

            return APR_SUCCESS;

        }

        else {

            ap_varbuf_strmemcat(vb, src, len);

            return APR_SUCCESS;

        }

    }

    /* First pass, find the size */

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

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

            no = *src++ - '0';

        else

            no = AP_MAX_REG_MATCH;

        if (no >= AP_MAX_REG_MATCH) {  /* Ordinary character. */

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

                src++;

            len++;

        }

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

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

                return APR_ENOMEM;

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

        }

    }

    if (len >= maxlen && maxlen > 0)

        return APR_ENOMEM;

    if (!vb) {

        *result = dst = apr_palloc(p, len + 1);

    }

    else {

        if (vb->strlen == AP_VARBUF_UNKNOWN)

            vb->strlen = strlen(vb->buf);

        ap_varbuf_grow(vb, vb->strlen + len);

        dst = vb->buf + vb->strlen;

        vb->strlen += len;

    }

    /* Now actually fill in the string */

    src = input;

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

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

            no = *src++ - '0';

        else

            no = AP_MAX_REG_MATCH;

        if (no >= AP_MAX_REG_MATCH) {  /* Ordinary character. */

            if (c == '\\' && *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 APR_SUCCESS;

}

#ifndef AP_PREGSUB_MAXLEN

#define AP_PREGSUB_MAXLEN   (HUGE_STRING_LEN * 8)

#endif

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

                              const char *source, apr_size_t nmatch,

                              ap_regmatch_t pmatch[])

{

    char *result;

    apr_status_t rc = regsub_core(p, &result, NULL, input, source, nmatch,

                                  pmatch, AP_PREGSUB_MAXLEN);

    if (rc != APR_SUCCESS)

        result = NULL;

    return result;

}

AP_DECLARE(apr_status_t) ap_pregsub_ex(apr_pool_t *p, char **result,

                                       const char *input, const char *source,

                                       apr_size_t nmatch, ap_regmatch_t pmatch[],

                                       apr_size_t maxlen)

{

    apr_status_t rc = regsub_core(p, result, NULL, input, source, nmatch,

                                  pmatch, maxlen);

    if (rc != APR_SUCCESS)

        *result = NULL;

    return rc;

}

/*

 * 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]))) {

            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 ap_directory_walk in server/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_pstrmemdup(p, s, l);

    return (d);

}

AP_DECLARE(int) ap_count_dirs(const char *path)

{

    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 = apr_pstrmemdup(atrans, *line, len);

    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 = apr_pstrmemdup(atrans, *line, len);

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

        apr_size_t len = strlen(*line);

        res = apr_pstrmemdup(atrans, *line, len);

        *line += len;

        return res;

    }

    res = apr_pstrmemdup(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 + 1);

    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 (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 (apr_isspace(*strend))

        ++strend;

    *line = strend;

    return res;

}

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

{

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

}

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

{

    const char *str = *line, *strend;

    char *res;

    char quote;

    int count = 1;

    while (apr_isspace(*str))

        ++str;

    if (!*str) {

        *line = str;

        return "";

    }

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

        return ap_getword_conf(p, line);

    if (quote == '{') {

        strend = str + 1;

        while (*strend) {

            if (*strend == '}' && !--count)

                break;

            if (*strend == '{')

                ++count;

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

                ++strend;

            }

            ++strend;

        }

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

        if (*strend == '}')

            ++strend;

    }

    else {

        strend = str;

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

            ++strend;

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

    }

    while (apr_isspace(*strend))

        ++strend;

    *line = strend;

    return res;

}

AP_DECLARE(int) ap_cfg_closefile(ap_configfile_t *cfp)

{

#ifdef DEBUG

    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL, APLOGNO(00551)