summaryrefslogtreecommitdiffstats
path: root/strings/apr_cpystrn.c
diff options
context:
space:
mode:
Diffstat (limited to 'strings/apr_cpystrn.c')
-rw-r--r--strings/apr_cpystrn.c315
1 files changed, 315 insertions, 0 deletions
diff --git a/strings/apr_cpystrn.c b/strings/apr_cpystrn.c
new file mode 100644
index 0000000..fb96025
--- /dev/null
+++ b/strings/apr_cpystrn.c
@@ -0,0 +1,315 @@
+/* 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
+