contrib/apr/strings/apr_cpystrn.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "apr.h"
  18 #include "apr_strings.h"
  19 #include "apr_private.h"
  20 #include "apr_lib.h"
  21
  22 #if APR_HAVE_SYS_TYPES_H
  23 #include <sys/types.h>
  24 #endif
  25 #if APR_HAVE_STRING_H
  26 #include <string.h>
  27 #endif
  28 #if APR_HAVE_CTYPE_H
  29 #include <ctype.h>
  30 #endif
  31
  32 /*
  33  * Apache's "replacement" for the strncpy() function. We roll our
  34  * own to implement these specific changes:
  35  *   (1) strncpy() doesn't always null terminate and we want it to.
  36  *   (2) strncpy() null fills, which is bogus, esp. when copy 8byte
  37  *       strings into 8k blocks.
  38  *   (3) Instead of returning the pointer to the beginning of
  39  *       the destination string, we return a pointer to the
  40  *       terminating '\0' to allow us to "check" for truncation
  41  *   (4) If src is NULL, null terminate dst (empty string copy)
  42  *
  43  * apr_cpystrn() follows the same call structure as strncpy().
  44  */
  45
  46 APR_DECLARE(char *) apr_cpystrn(char *dst, const char *src, apr_size_t dst_size)
  47 {
  48
  49     char *d = dst, *end;
  50
  51     if (dst_size == 0) {
  52         return (dst);
  53     }
  54
  55     if (src) {
  56         end = dst + dst_size - 1;
  57
  58         for (; d < end; ++d, ++src) {
  59             if (!(*d = *src)) {
  60                 return (d);
  61             }
  62         }
  63     }
  64
  65     *d = '\0';  /* always null terminate */
  66
  67     return (d);
  68 }
  69
  70
  71 /*
  72  * This function provides a way to parse a generic argument string
  73  * into a standard argv[] form of argument list. It respects the
  74  * usual "whitespace" and quoteing rules. In the future this could
  75  * be expanded to include support for the apr_call_exec command line
  76  * string processing (including converting '+' to ' ' and doing the
  77  * url processing. It does not currently support this function.
  78  *
  79  *    token_context: Context from which pool allocations will occur.
  80  *    arg_str:       Input argument string for conversion to argv[].
  81  *    argv_out:      Output location. This is a pointer to an array
  82  *                   of pointers to strings (ie. &(char *argv[]).
  83  *                   This value will be allocated from the contexts
  84  *                   pool and filled in with copies of the tokens
  85  *                   found during parsing of the arg_str.
  86  */
  87 APR_DECLARE(apr_status_t) apr_tokenize_to_argv(const char *arg_str,
  88                                             char ***argv_out,
  89                                             apr_pool_t *token_context)
  90 {
  91     const char *cp;
  92     const char *ct;
  93     char *cleaned, *dirty;
  94     int escaped;
  95     int isquoted, numargs = 0, argnum;
  96
  97 #define SKIP_WHITESPACE(cp) \
  98     for ( ; *cp == ' ' || *cp == '\t'; ) { \
  99         cp++; \
 100     };
 101
 102 #define CHECK_QUOTATION(cp,isquoted) \
 103     isquoted = 0; \
 104     if (*cp == '"') { \
 105         isquoted = 1; \
 106         cp++; \
 107     } \
 108     else if (*cp == '\'') { \
 109         isquoted = 2; \
 110         cp++; \
 111     }
 112
 113 /* DETERMINE_NEXTSTRING:
 114  * At exit, cp will point to one of the following:  NULL, SPACE, TAB or QUOTE.
 115  * NULL implies the argument string has been fully traversed.
 116  */
 117 #define DETERMINE_NEXTSTRING(cp,isquoted) \
 118     for ( ; *cp != '\0'; cp++) { \
 119         if (   (*cp == '\\' && (*(cp+1) == ' ' || *(cp+1) == '\t' || \
 120                                 *(cp+1) == '"' || *(cp+1) == '\''))) { \
 121             cp++; \
 122             continue; \
 123         } \
 124         if (   (!isquoted && (*cp == ' ' || *cp == '\t')) \
 125             || (isquoted == 1 && *cp == '"') \
 126             || (isquoted == 2 && *cp == '\'')                 ) { \
 127             break; \
 128         } \
 129     }
 130
 131 /* REMOVE_ESCAPE_CHARS:
 132  * Compresses the arg string to remove all of the '\' escape chars.
 133  * The final argv strings should not have any extra escape chars in it.
 134  */
 135 #define REMOVE_ESCAPE_CHARS(cleaned, dirty, escaped) \
 136     escaped = 0; \
 137     while(*dirty) { \
 138         if (!escaped && *dirty == '\\') { \
 139             escaped = 1; \
 140         } \
 141         else { \
 142             escaped = 0; \
 143             *cleaned++ = *dirty; \
 144         } \
 145         ++dirty; \
 146     } \
 147     *cleaned = 0;        /* last line of macro... */
 148
 149     cp = arg_str;
 150     SKIP_WHITESPACE(cp);
 151     ct = cp;
 152
 153     /* This is ugly and expensive, but if anyone wants to figure a
 154      * way to support any number of args without counting and
 155      * allocating, please go ahead and change the code.
 156      *
 157      * Must account for the trailing NULL arg.
 158      */
 159     numargs = 1;
 160     while (*ct != '\0') {
 161         CHECK_QUOTATION(ct, isquoted);
 162         DETERMINE_NEXTSTRING(ct, isquoted);
 163         if (*ct != '\0') {
 164             ct++;
 165         }
 166         numargs++;
 167         SKIP_WHITESPACE(ct);
 168     }
 169     *argv_out = apr_palloc(token_context, numargs * sizeof(char*));
 170
 171     /*  determine first argument */
 172     for (argnum = 0; argnum < (numargs-1); argnum++) {
 173         SKIP_WHITESPACE(cp);
 174         CHECK_QUOTATION(cp, isquoted);
 175         ct = cp;
 176         DETERMINE_NEXTSTRING(cp, isquoted);
 177         cp++;
 178         (*argv_out)[argnum] = apr_palloc(token_context, cp - ct);
 179         apr_cpystrn((*argv_out)[argnum], ct, cp - ct);
 180         cleaned = dirty = (*argv_out)[argnum];
 181         REMOVE_ESCAPE_CHARS(cleaned, dirty, escaped);
 182     }
 183     (*argv_out)[argnum] = NULL;
 184
 185     return APR_SUCCESS;
 186 }
 187
 188 /* Filepath_name_get returns the final element of the pathname.
 189  * Using the current platform's filename syntax.
 190  *   "/foo/bar/gum" -> "gum"
 191  *   "/foo/bar/gum/" -> ""
 192  *   "gum" -> "gum"
 193  *   "wi\\n32\\stuff" -> "stuff
 194  *
 195  * Corrected Win32 to accept "a/b\\stuff", "a:stuff"
 196  */
 197
 198 APR_DECLARE(const char *) apr_filepath_name_get(const char *pathname)
 199 {
 200     const char path_separator = '/';
 201     const char *s = strrchr(pathname, path_separator);
 202
 203 #ifdef WIN32
 204     const char path_separator_win = '\\';
 205     const char drive_separator_win = ':';
 206     const char *s2 = strrchr(pathname, path_separator_win);
 207
 208     if (s2 > s) s = s2;
 209
 210     if (!s) s = strrchr(pathname, drive_separator_win);
 211 #endif
 212
 213     return s ? ++s : pathname;
 214 }
 215
 216 /* length of dest assumed >= length of src
 217  * collapse in place (src == dest) is legal.
 218  * returns terminating null ptr to dest string.
 219  */
 220 APR_DECLARE(char *) apr_collapse_spaces(char *dest, const char *src)
 221 {
 222     while (*src) {
 223         if (!apr_isspace(*src))
 224             *dest++ = *src;
 225         ++src;
 226     }
 227     *dest = 0;
 228     return (dest);
 229 }
 230
 231 #if !APR_HAVE_STRDUP
 232 char *strdup(const char *str)
 233 {
 234     char *sdup;
 235     size_t len = strlen(str) + 1;
 236
 237     sdup = (char *) malloc(len);
 238     memcpy(sdup, str, len);
 239
 240     return sdup;
 241 }
 242 #endif
 243
 244 /* The following two routines were donated for SVR4 by Andreas Vogel */
 245 #if (!APR_HAVE_STRCASECMP && !APR_HAVE_STRICMP)
 246 int strcasecmp(const char *a, const char *b)
 247 {
 248     const char *p = a;
 249     const char *q = b;
 250     for (p = a, q = b; *p && *q; p++, q++) {
 251         int diff = apr_tolower(*p) - apr_tolower(*q);
 252         if (diff)
 253             return diff;
 254     }
 255     if (*p)
 256         return 1;               /* p was longer than q */
 257     if (*q)
 258         return -1;              /* p was shorter than q */
 259     return 0;                   /* Exact match */
 260 }
 261
 262 #endif
 263
 264 #if (!APR_HAVE_STRNCASECMP && !APR_HAVE_STRNICMP)
 265 int strncasecmp(const char *a, const char *b, size_t n)
 266 {
 267     const char *p = a;
 268     const char *q = b;
 269
 270     for (p = a, q = b; /*NOTHING */ ; p++, q++) {
 271         int diff;
 272         if (p == a + n)
 273             return 0;           /*   Match up to n characters */
 274         if (!(*p && *q))
 275             return *p - *q;
 276         diff = apr_tolower(*p) - apr_tolower(*q);
 277         if (diff)
 278             return diff;
 279     }
 280     /*NOTREACHED */
 281 }
 282 #endif
 283
 284 /* The following routine was donated for UTS21 by dwd@bell-labs.com */
 285 #if (!APR_HAVE_STRSTR)
 286 char *strstr(char *s1, char *s2)
 287 {
 288     char *p1, *p2;
 289     if (*s2 == '\0') {
 290         /* an empty s2 */
 291         return(s1);
 292     }
 293     while((s1 = strchr(s1, *s2)) != NULL) {
 294         /* found first character of s2, see if the rest matches */
 295         p1 = s1;
 296         p2 = s2;
 297         while (*++p1 == *++p2) {
 298             if (*p1 == '\0') {
 299                 /* both strings ended together */
 300                 return(s1);
 301             }
 302         }
 303         if (*p2 == '\0') {
 304             /* second string ended, a match */
 305             break;
 306         }
 307         /* didn't find a match here, try starting at next character in s1 */
 308         s1++;
 309     }
 310     return(s1);
 311 }
 312 #endif
 313