apr_cpystrn.c revision 269847 
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
46APR_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 */
87APR_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
198APR_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 */
220APR_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
232char *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)
246int 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)
265int 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)
286char *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
314