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

 *   (4) If src is NULL, null terminate dst (empty string copy)

 *

 * 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 = dst, *end;

    if (dst_size == 0) {

        return (dst);

    }

    if (src) {

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

    if (sdup == NULL)

        return NULL;

    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