/* Copyright 2000-2004 The Apache Software Foundation
		 *
		 * Licensed 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)
         125    {
		
         125        char *d, *end;
		
         125        if (dst_size == 0) {
      ######            return (dst);
		    }
		
         125        d = dst;
         125        end = dst + dst_size - 1;
		
        4497        for (; d < end; ++d, ++src) {
        2198    	if (!(*d = *src)) {
          12    	    return (d);
			}
		    }
		
         113        *d = '\0';	/* always null terminate */
		
         113        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 (   (isquoted    && (*cp     == ' ' || *cp     == '\t')) \
		            || (*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++) {
      ######            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);
      ######            SKIP_WHITESPACE(cp);
		    }
      ######        (*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)
           3    {
           3        const char path_separator = '/';
           3        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
		
           3        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