X-Git-Url: http://git.tuebingen.mpg.de/?p=adu.git;a=blobdiff_plain;f=string.c;h=77c90cb3bcee036565751f68ee9b3ff23726bab6;hp=0b929688a2496d5a5f57c8a9e5590b17dd5d697a;hb=5008f98a8208d96c3c777476d6df7534c6d2ca49;hpb=4c71ff7f9b6afe7c15331a1cc9e134c2db65cd73 diff --git a/string.c b/string.c index 0b92968..77c90cb 100644 --- a/string.c +++ b/string.c @@ -4,7 +4,7 @@ * Licensed under the GPL v2. For licencing details see COPYING. */ -/** \file string.c Memory allocation and string handling functions. */ +/** \file string.c \brief Memory allocation and string handling functions. */ #include "adu.h" #include "string.h" @@ -12,7 +12,7 @@ #include "error.h" /** - * Paraslash's version of realloc(). + * Adu's version of realloc(). * * \param p Pointer to the memory block, may be \p NULL. * \param size The desired new size. @@ -41,7 +41,7 @@ __must_check __malloc void *adu_realloc(void *p, size_t size) } /** - * Paraslash's version of malloc(). + * Adu's version of malloc(). * * \param size The desired new size. * @@ -66,7 +66,7 @@ __must_check __malloc void *adu_malloc(size_t size) } /** - * Paraslash's version of calloc(). + * Adu's version of calloc(). * * \param size The desired new size. * @@ -86,7 +86,7 @@ __must_check __malloc void *adu_calloc(size_t size) } /** - * Paraslash's version of strdup(). + * Adu's version of strdup(). * * \param s The string to be duplicated. * @@ -170,7 +170,7 @@ __must_check __malloc char *adu_strcat(char *a, const char *b) * Convert a string to a 64-bit signed integer value. * * \param str The string to be converted. - * \param value Result pointer. + * \param result Result pointer. * * \return Standard. * @@ -196,14 +196,14 @@ __must_check int atoi64(const char *str, int64_t *result) } /** - * Split string and return pointers to its parts. + * Split a string and return pointers to its parts. * * \param args The string to be split. * \param argv_ptr Pointer to the list of substrings. * \param delim Delimiter. * * This function modifies \a args by replacing each occurance of \a delim by - * zero. A \p NULL-terminated array of pointers to char* is allocated dynamically + * zero. A \p NULL terminated array of pointers to char* is allocated dynamically * and these pointers are initialized to point to the broken-up substrings * within \a args. A pointer to this array is returned via \a argv_ptr. * @@ -245,86 +245,131 @@ __must_check unsigned split_args(char *args, char *** const argv_ptr, const char return n; } -static int check_uid_arg(const char *arg, uint32_t *uid) -{ - const uint32_t max = ~0U; - /* - * we need an 64-bit int for string -> uid conversion because strtoll() - * returns a signed value. - */ - int64_t val; - int ret = atoi64(arg, &val); - - if (ret < 0) - return ret; - if (val < 0 || val > max) - return -ERRNO_TO_ERROR(EINVAL); - *uid = val; - return 1; -} -int parse_uid_range(const char *orig_arg, struct uid_range *ur) +static int get_next_word(const char *line, char **word) { - int ret; - char *arg = adu_strdup(orig_arg), *p = strchr(arg, '-'); + enum line_state_flags {LSF_HAVE_WORD = 1, LSF_BACKSLASH = 2, + LSF_QUOTE = 4}; + const char *in; + char *out; + int ret, state = 0; - if (!p || p == arg) { /* -42 or 42 */ - ret = check_uid_arg(p? p + 1 : arg, &ur->high); - if (ret < 0) - goto out; - ur->low = p? 0 : ur->high; - ret = 1; + out = adu_malloc(strlen(line) + 1); + *out = '\0'; + *word = out; + for (in = line; *in; in++) { + switch (*in) { + case '\\': + if (state & LSF_BACKSLASH) /* \\ */ + break; + state |= LSF_BACKSLASH; + state |= LSF_HAVE_WORD; + continue; + case 'n': + case 't': + if (state & LSF_BACKSLASH) { /* \n or \t */ + *out++ = (*in == 'n')? '\n' : '\t'; + state &= ~LSF_BACKSLASH; + continue; + } + break; + case '"': + if (state & LSF_BACKSLASH) /* \" */ + break; + if (state & LSF_QUOTE) { + state &= ~LSF_QUOTE; + continue; + } + state |= LSF_HAVE_WORD; + state |= LSF_QUOTE; + continue; + case ' ': + case '\t': + case '\n': + if (state & LSF_BACKSLASH) + break; + if (state & LSF_QUOTE) + break; + if (state & LSF_HAVE_WORD) + goto success; + /* ignore space at the beginning */ + continue; + } + /* copy char */ + state |= LSF_HAVE_WORD; + *out++ = *in; + state &= ~LSF_BACKSLASH; + } + ret = 0; + if (!(state & LSF_HAVE_WORD)) + goto out; + ret = -ERRNO_TO_ERROR(EINVAL); + if (state & LSF_BACKSLASH) { + ERROR_LOG("trailing backslash\n"); goto out; } - /* 42- or 42-4711 */ - *p = '\0'; - p++; - ret = check_uid_arg(arg, &ur->low); - if (ret < 0) + if (state & LSF_QUOTE) { + ERROR_LOG("unmatched quote character\n"); goto out; - ur->high = ~0U; - if (*p) { /* 42-4711 */ - ret = check_uid_arg(p, &ur->high); - if (ret < 0) - goto out; } - if (ur->low > ur->high) - ret = -ERRNO_TO_ERROR(EINVAL); +success: + *out = '\0'; + return in - line; out: - if (ret < 0) - ERROR_LOG("bad uid option: %s\n", orig_arg); - else - INFO_LOG("admissible uid range: %u - %u\n", ur->low, - ur->high); - free(arg); + free(*word); + *word = NULL; return ret; } -int parse_uid_arg(const char *orig_arg, struct uid_range **ur) +/** + * Free an array of words created by create_argv(). + * + * \param argv A pointer previously obtained by \ref create_argv(). + */ +void free_argv(char **argv) +{ + int i; + + for (i = 0; argv[i]; i++) + free(argv[i]); + free(argv); +} + +/** + * Split a line into words which are separated by whitespace. + * + * In contrast to gengetopt's string parser, double quotes, backslash-escaped + * characters and special characters like \p \\n are honored. The result + * contains pointers to copies of the words contained in \a line and has to be + * freed by using \ref free_argv(). + * + * \param line The line to be split. + * \param result The array of words is returned here. + * + * \return Number of words in \a line, negative on errors. + */ +int create_argv(const char *line, char ***result) { - char *arg, **argv; - unsigned n; - int i, ret = 1; + char *word, **argv = adu_malloc(2 * sizeof(char *)); + const char *p; + int ret, num_words; - if (!orig_arg) - return 0; - arg = adu_strdup(orig_arg); - n = split_args(arg, &argv, ","); - if (!n) - return -E_SYNTAX; - *ur = adu_malloc((n + 1) * sizeof(struct uid_range)); - for (i = 0; i < n; i++) { - ret = parse_uid_range(argv[i], *ur + i); + argv[0] = adu_strdup(line); + for (p = line, num_words = 1; ; p += ret, num_words++) { + ret = get_next_word(p, &word); if (ret < 0) + goto err; + if (!ret) break; + argv = adu_realloc(argv, (num_words + 2) * sizeof(char*)); + argv[num_words] = word; } - free(arg); - if (ret < 0) { - free(*ur); - *ur = NULL; - } - /* an empty range indicates the end of the list */ - (*ur)[n].low = 1; - (*ur)[n].high = 0; - return n; + argv[num_words] = NULL; + *result = argv; + return num_words; +err: + while (num_words > 0) + free(argv[--num_words]); + free(argv); + return ret; }