X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=string.c;h=bb63120184c79b44270a4ae1ba671e6dd74de5e1;hp=52c5183b418e772ee5a603eddb4290755769919e;hb=57e0c93e87138fdf1c8793c3d1f3d2880d717548;hpb=45f29beab3d711b91e4d3551958173f53f1c5436 diff --git a/string.c b/string.c index 52c5183b..bb631201 100644 --- a/string.c +++ b/string.c @@ -1,93 +1,85 @@ /* - * Copyright (C) 2004-2007 Andre Noll + * Copyright (C) 2004-2009 Andre Noll * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Licensed under the GPL v2. For licencing details see COPYING. */ -/** \file string.c memory allocation and string handling functions */ - -#include "para.h" -#include "string.h" +/** \file string.c Memory allocation and string handling functions. */ #include /* gettimeofday */ -#include #include #include /* uname() */ #include +#include +#include "para.h" +#include "string.h" #include "error.h" /** - * paraslash's version of realloc() + * Paraslash's version of realloc(). * - * \param p pointer to the memory block, may be NULL - * \param size desired new size + * \param p Pointer to the memory block, may be \p NULL. + * \param size The desired new size. * * A wrapper for realloc(3). It calls \p exit(\p EXIT_FAILURE) on errors, * i.e. there is no need to check the return value in the caller. * * \return A pointer to the newly allocated memory, which is suitably aligned - * for any kind of variable and may be different from \p p. + * for any kind of variable and may be different from \a p. * - * \sa realloc(3) + * \sa realloc(3). */ __must_check __malloc void *para_realloc(void *p, size_t size) { /* - * No need to check for NULL pointers: If p is NULL, the call + * No need to check for NULL pointers: If p is NULL, the call * to realloc is equivalent to malloc(size) */ + assert(size); if (!(p = realloc(p, size))) { - PARA_EMERG_LOG("%s", "realloc failed, aborting\n"); + PARA_EMERG_LOG("realloc failed (size = %zu), aborting\n", + size); exit(EXIT_FAILURE); } return p; } /** - * paraslash's version of malloc() + * Paraslash's version of malloc(). * - * \param size desired new size + * \param size The desired new size. * * A wrapper for malloc(3) which exits on errors. * * \return A pointer to the allocated memory, which is suitably aligned for any - * kind of variable. + * kind of variable. * - * \sa malloc(3) + * \sa malloc(3). */ __must_check __malloc void *para_malloc(size_t size) { - void *p = malloc(size); + void *p; + assert(size); + p = malloc(size); if (!p) { - PARA_EMERG_LOG("%s", "malloc failed, aborting\n"); + PARA_EMERG_LOG("malloc failed (size = %zu), aborting\n", + size); exit(EXIT_FAILURE); } return p; } /** - * paraslash's version of calloc() + * Paraslash's version of calloc(). * - * \param size desired new size + * \param size The desired new size. * * A wrapper for calloc(3) which exits on errors. * - * A pointer to the allocated and zeroed-out memory, which is suitably aligned - * for any kind of variable. + * \return A pointer to the allocated and zeroed-out memory, which is suitably + * aligned for any kind of variable. * * \sa calloc(3) */ @@ -100,14 +92,14 @@ __must_check __malloc void *para_calloc(size_t size) } /** - * paraslash's version of strdup() + * Paraslash's version of strdup(). * - * \param s string to be duplicated + * \param s The string to be duplicated. * - * A wrapper for strdup(3). It calls exit(EXIT_FAILURE) on errors, i.e. there - * is no need to check the return value in the caller. + * A wrapper for strdup(3). It calls \p exit(EXIT_FAILURE) on errors, i.e. + * there is no need to check the return value in the caller. * - * \return A pointer to the duplicated string. If \p s was the NULL pointer, + * \return A pointer to the duplicated string. If \a s was the \p NULL pointer, * an pointer to an empty string is returned. * * \sa strdup(3) @@ -118,14 +110,14 @@ __must_check __malloc char *para_strdup(const char *s) if ((ret = strdup(s? s: ""))) return ret; - PARA_EMERG_LOG("%s", "strdup failed, aborting\n"); + PARA_EMERG_LOG("strdup failed, aborting\n"); exit(EXIT_FAILURE); } /** - * allocate a sufficiently large string and print into it + * Allocate a sufficiently large string and print into it. * - * \param fmt usual format string + * \param fmt A usual format string. * * Produce output according to \p fmt. No artificial bound on the length of the * resulting string is imposed. @@ -133,7 +125,7 @@ __must_check __malloc char *para_strdup(const char *s) * \return This function either returns a pointer to a string that must be * freed by the caller or aborts without returning. * - * \sa printf(3) + * \sa printf(3). */ __must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...) { @@ -144,17 +136,17 @@ __must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...) } /** - * paraslash's version of strcat() + * Paraslash's version of strcat(). * - * \param a string to be appended to - * \param b string to append + * \param a String to be appended to. + * \param b String to append. * * Append \p b to \p a. * - * \return If \p a is NULL, return a pointer to a copy of \p b, i.e. - * para_strcat(NULL, b) is equivalent to para_strdup(b). If \p b is NULL, - * return \p a without making a copy of \p a. Otherwise, construct the - * concatenation \p c, free \p a (but not \p b) and return \p c. + * \return If \a a is \p NULL, return a pointer to a copy of \a b, i.e. + * para_strcat(NULL, b) is equivalent to para_strdup(b). If \a b is \p NULL, + * return \a a without making a copy of \a a. Otherwise, construct the + * concatenation \a c, free \a a (but not \a b) and return \a c. * * \sa strcat(3) */ @@ -172,14 +164,14 @@ __must_check __malloc char *para_strcat(char *a, const char *b) } /** - * paraslash's version of dirname() + * Paraslash's version of dirname(). * - * \param name pointer to the full path + * \param name Pointer to the full path. * - * Compute the directory component of \p name + * Compute the directory component of \p name. * - * \return If \p name is \รพ NULL or the empty string, return \p NULL. - * Otherwise, Make a copy of \p name and return its directory component. Caller + * \return If \a name is \p NULL or the empty string, return \p NULL. + * Otherwise, Make a copy of \a name and return its directory component. Caller * is responsible to free the result. */ __must_check __malloc char *para_dirname(const char *name) @@ -198,291 +190,564 @@ __must_check __malloc char *para_dirname(const char *name) } /** - * paraslash's version of basename() + * Paraslash's version of basename(). * - * \param name Pointer to the full path + * \param name Pointer to the full path. * - * Compute the filename component of \p name + * Compute the filename component of \a name. * - * \return If \p name is \p NULL or the empty string, return \p NULL, - * Otherwise, make a copy of \p name and return its filename component. Caller - * is responsible to free the result. + * \return \p NULL if (a) \a name is the empty string or \p NULL, or (b) name + * ends with a slash. Otherwise, a pointer within \a name is returned. Caller + * must not free the result. */ -__must_check __malloc char *para_basename(const char *name) +__must_check char *para_basename(const char *name) { - char *p; + char *ret; if (!name || !*name) return NULL; - p = strrchr(name, '/'); - if (!p) - return para_strdup(name); - p++; - if (!*p) - return NULL; - return para_strdup(p); + ret = strrchr(name, '/'); + if (!ret) + return (char *)name; + ret++; + return ret; } /** - * simple search and replace routine - * - * \param src source string - * \param macro_name the name of the macro - * \param replacement the replacement format string + * Cut trailing newline. * - * In \p src, replace each occurence of \p macro_name(arg) by the string - * determined by the \p replacement format string. \p replacement may (but - * needs not) contain a single string conversion specifier (%s) which gets - * replaced by \p arg. + * \param buf The string to be chopped. * - * \return A string in which all matches in \p src are replaced, or \p NULL if - * an syntax error was encountered. Caller must free the result. - * - * \sa regcomp(3) + * Replace the last character in \p buf by zero if it is equal to + * the newline character. */ -__must_check __malloc char *s_a_r(const char *src, const char* macro_name, - const char *replacement) +void chop(char *buf) { - regex_t preg; - size_t nmatch = 1; - regmatch_t pmatch[1]; - int eflags = 0; - char *dest = NULL; - const char *bufptr = src; - - if (!macro_name || !replacement || !src) - return para_strdup(src); - regcomp(&preg, macro_name, 0); - while (regexec(&preg, bufptr, nmatch, pmatch, eflags) - != REG_NOMATCH) { - char *tmp, *arg, *o_bracket, *c_bracket; - - o_bracket = strchr(bufptr + pmatch[0].rm_so, '('); - c_bracket = o_bracket? strchr(o_bracket, ')') : NULL; - if (!c_bracket) - goto out; - tmp = para_strdup(bufptr); - tmp[pmatch[0].rm_so] = '\0'; - dest = para_strcat(dest, tmp); - free(tmp); - - arg = para_strdup(o_bracket + 1); - arg[c_bracket - o_bracket - 1] = '\0'; - tmp = make_message(replacement, arg); - free(arg); - dest = para_strcat(dest, tmp); - free(tmp); - bufptr = c_bracket; - bufptr++; - } - dest = para_strcat(dest, bufptr); -// PARA_DEBUG_LOG("%s: returning %s\n", __func__, dest); -out: - regfree(&preg); - return dest; + int n = strlen(buf); + + if (!n) + return; + if (buf[n - 1] == '\n') + buf[n - 1] = '\0'; } /** - * replace a string according to a list of macros + * Get the logname of the current user. * - * \param macro_list the array containing a macro/replacement pairs. - * \param src the source string + * \return A dynamically allocated string that must be freed by the caller. On + * errors, the string "unknown_user" is returned, i.e. this function never + * returns \p NULL. * - * This function just calls s_a_r() for each element of \p macro_list. + * \sa getpwuid(3). + */ +__must_check __malloc char *para_logname(void) +{ + struct passwd *pw = getpwuid(getuid()); + return para_strdup(pw? pw->pw_name : "unknown_user"); +} + +/** + * Get the home directory of the current user. * - * \return \p NULL if one of the underlying calls to \p s_a_r returned \p NULL. - * Otherwise the completely expanded version of \p src is returned. + * \return A dynamically allocated string that must be freed by the caller. If + * the home directory could not be found, this function returns "/tmp". */ -__must_check __malloc char *s_a_r_list(struct para_macro *macro_list, char *src) +__must_check __malloc char *para_homedir(void) { - struct para_macro *mp = macro_list; - char *ret = NULL, *tmp = para_strdup(src); - - while (mp->name) { - ret = s_a_r(tmp, mp->name, mp->replacement); - free(tmp); - if (!ret) /* syntax error */ - return NULL; - tmp = ret; - mp++; - } - //PARA_DEBUG_LOG("%s: returning %s\n", __func__, dest); - return ret; + struct passwd *pw = getpwuid(getuid()); + return para_strdup(pw? pw->pw_dir : "/tmp"); } /** - * cut trailing newline + * Get the own hostname. * - * \param buf the string to be chopped. + * \return A dynamically allocated string containing the hostname. * - * Replace the last character in \p buf by zero if it is euqal to - * the newline character. + * \sa uname(2). */ -void chop(char *buf) +__malloc char *para_hostname(void) { - int n = strlen(buf); - if (!n) - return; - if (buf[n - 1] == '\n') - buf[n - 1] = '\0'; + struct utsname u; + + uname(&u); + return para_strdup(u.nodename); } /** - * get a random filename + * Used to distinguish between read-only and read-write mode. * - * This is by no means a secure way to create temporary files in a hostile - * direcory like \p /tmp. However, it is OK to use for temp files, fifos, - * sockets that are created in ~/.paraslash. Result must be freed by the - * caller. - * - * \return a pointer to a random filename. + * \sa for_each_line(), for_each_line_ro(). + */ +enum for_each_line_modes{ + /** Activate read-only mode. */ + LINE_MODE_RO, + /** Activate read-write mode. */ + LINE_MODE_RW +}; + +static int for_each_complete_line(enum for_each_line_modes mode, char *buf, + size_t size, line_handler_t *line_handler, void *private_data) +{ + char *start = buf, *end; + int ret, i, num_lines = 0; + +// PARA_NOTICE_LOG("buf: %s\n", buf); + while (start < buf + size) { + char *next_null; + char *next_cr; + + next_cr = memchr(start, '\n', buf + size - start); + next_null = memchr(start, '\0', buf + size - start); + if (!next_cr && !next_null) + break; + if (next_cr && next_null) { + end = next_cr < next_null? next_cr : next_null; + } else if (next_null) { + end = next_null; + } else + end = next_cr; + num_lines++; + if (!line_handler) { + start = ++end; + continue; + } + if (mode == LINE_MODE_RO) { + size_t s = end - start; + char *b = para_malloc(s + 1); + memcpy(b, start, s); + b[s] = '\0'; +// PARA_NOTICE_LOG("b: %s, start: %s\n", b, start); + ret = line_handler(b, private_data); + free(b); + } else { + *end = '\0'; + ret = line_handler(start, private_data); + } + if (ret < 0) + return ret; + start = ++end; + } + if (!line_handler || mode == LINE_MODE_RO) + return num_lines; + i = buf + size - start; + if (i && i != size) + memmove(buf, start, i); + return i; +} + +/** + * Call a custom function for each complete line. + * + * \param buf The buffer containing data separated by newlines. + * \param size The number of bytes in \a buf. + * \param line_handler The custom function. + * \param private_data Pointer passed to \a line_handler. + * + * If \p line_handler is \p NULL, the function returns the number of complete + * lines in \p buf. Otherwise, \p line_handler is called for each complete + * line in \p buf. The first argument to \p line_handler is the current line, + * and \p private_data is passed as the second argument. The function returns + * if \p line_handler returns a negative value or no more lines are in the + * buffer. The rest of the buffer (last chunk containing an incomplete line) + * is moved to the beginning of the buffer. + * + * \return If \p line_handler is not \p NULL, this function returns the number + * of bytes not handled to \p line_handler on success, or the negative return + * value of the \p line_handler on errors. + * + * \sa for_each_line_ro(). */ -__must_check __malloc char *para_tmpname(void) +int for_each_line(char *buf, size_t size, line_handler_t *line_handler, + void *private_data) { - struct timeval now; - gettimeofday(&now, NULL); - srand(now.tv_usec); - return make_message("%08i", rand()); + return for_each_complete_line(LINE_MODE_RW, buf, size, line_handler, + private_data); } /** - * create unique temporary file + * Call a custom function for each complete line. * - * \param template the template to be passed to mkstemp() - * \param mode the desired mode of the tempfile + * \param buf Same meaning as in \p for_each_line(). + * \param size Same meaning as in \p for_each_line(). + * \param line_handler Same meaning as in \p for_each_line(). + * \param private_data Same meaning as in \p for_each_line(). * - * This wrapper for mkstemp additionally uses fchmod() to - * set the given mode of the tempfile if mkstemp() returned success. + * This function behaves like \p for_each_line(), but \a buf is left unchanged. * - * \return The file descriptor of the temp file just created on success. - * On errors, -E_MKSTEMP or -E_FCHMOD is returned. + * \return On success, the function returns the number of complete lines in \p + * buf, otherwise the (negative) return value of \p line_handler is returned. + * + * \sa for_each_line(). */ -__must_check int para_mkstemp(char *template, mode_t mode) +int for_each_line_ro(char *buf, size_t size, line_handler_t *line_handler, + void *private_data) +{ + return for_each_complete_line(LINE_MODE_RO, buf, size, line_handler, + private_data); +} + +#define hex(a) (hexchar[(a) & 15]) +static void write_size_header(char *buf, int n) { - int tmp, fd = mkstemp(template); - - if (fd < 0) - return -E_MKSTEMP; - tmp = fchmod(fd, mode); - if (tmp >= 0) - return fd; - close(fd); - unlink(template); - return -E_FCHMOD; + static char hexchar[] = "0123456789abcdef"; + + buf[0] = hex(n >> 12); + buf[1] = hex(n >> 8); + buf[2] = hex(n >> 4); + buf[3] = hex(n); + buf[4] = ' '; +} + +int read_size_header(const char *buf) +{ + int i, len = 0; + + for (i = 0; i < 4; i++) { + unsigned char c = buf[i]; + len <<= 4; + if (c >= '0' && c <= '9') { + len += c - '0'; + continue; + } + if (c >= 'a' && c <= 'f') { + len += c - 'a' + 10; + continue; + } + return -E_SIZE_PREFIX; + } + if (buf[4] != ' ') + return -E_SIZE_PREFIX; + return len; } /** - * get the logname of the current user + * Safely print into a buffer at a given offset. * - * \return A dynammically allocated string that must be freed by the caller. On - * errors, the string "unknown user" is returned, i.e. this function never - * returns NULL. + * \param b Determines the buffer, its size, and the offset. + * \param fmt The format string. * - * \sa getpwuid(3) + * This function prints into the buffer given by \a b at the offset which is + * also given by \a b. If there is not enough space to hold the result, the + * buffer size is doubled until the underlying call to vsnprintf() succeeds + * or the size of the buffer exceeds the maximal size specified in \a b. + * + * In the latter case the unmodified \a buf and \a offset values as well as the + * private_data pointer of \a b are passed to the \a max_size_handler of \a b. + * If this function succeeds, i.e. returns a non-negative value, the offset of + * \a b is reset to zero and the given data is written to the beginning of the + * buffer. If \a max_size_handler() returns a negative value, this value is + * returned by \a para_printf(). + * + * Upon return, the offset of \a b is adjusted accordingly so that subsequent + * calls to this function append data to what is already contained in the + * buffer. + * + * It's OK to call this function with \p b->buf being \p NULL. In this case, an + * initial buffer is allocated. + * + * \return The number of bytes printed into the buffer (not including the + * terminating \p NULL byte) on success, negative on errors. If there is no + * size-bound on \a b, i.e. if \p b->max_size is zero, this function never + * fails. + * + * \sa make_message(), vsnprintf(3). */ -__must_check __malloc char *para_logname(void) +__printf_2_3 int para_printf(struct para_buffer *b, const char *fmt, ...) { - struct passwd *pw = getpwuid(getuid()); - return para_strdup(pw? pw->pw_name : "unknown_user"); + int ret, sz_off = (b->flags & PBF_SIZE_PREFIX)? 5 : 0; + + if (!b->buf) { + b->buf = para_malloc(128); + b->size = 128; + b->offset = 0; + } + while (1) { + char *p = b->buf + b->offset; + size_t size = b->size - b->offset; + va_list ap; + + if (size > sz_off) { + va_start(ap, fmt); + ret = vsnprintf(p + sz_off, size - sz_off, fmt, ap); + va_end(ap); + if (ret > -1 && ret < size - sz_off) { /* success */ + b->offset += ret + sz_off; + if (sz_off) + write_size_header(p, ret); + return ret + sz_off; + } + } + /* check if we may grow the buffer */ + if (!b->max_size || 2 * b->size < b->max_size) { /* yes */ + /* try again with more space */ + b->size *= 2; + b->buf = para_realloc(b->buf, b->size); + continue; + } + /* can't grow buffer */ + if (!b->offset || !b->max_size_handler) /* message too large */ + return -ERRNO_TO_PARA_ERROR(ENOSPC); + ret = b->max_size_handler(b->buf, b->offset, b->private_data); + if (ret < 0) + return ret; + b->offset = 0; + } } +/** \cond LLONG_MAX and LLONG_LIN might not be defined. */ +#ifndef LLONG_MAX +#define LLONG_MAX (1 << (sizeof(long) - 1)) +#endif +#ifndef LLONG_MIN +#define LLONG_MIN (-LLONG_MAX - 1LL) +#endif +/** \endcond */ + /** - * get the home directory of the current user + * Convert a string to a 64-bit signed integer value. * - * \return A dynammically allocated string that must be freed by the caller. If - * the home directory could not be found, this function returns "/tmp". + * \param str The string to be converted. + * \param value Result pointer. + * + * \return Standard. + * + * \sa para_atoi32(), strtol(3), atoi(3). */ -__must_check __malloc char *para_homedir(void) +int para_atoi64(const char *str, int64_t *value) { - struct passwd *pw = getpwuid(getuid()); - return para_strdup(pw? pw->pw_dir : "/tmp"); + char *endptr; + long long tmp; + + errno = 0; /* To distinguish success/failure after call */ + tmp = strtoll(str, &endptr, 10); + if (errno == ERANGE && (tmp == LLONG_MAX || tmp == LLONG_MIN)) + return -E_ATOI_OVERFLOW; + if (errno != 0 && tmp == 0) /* other error */ + return -E_STRTOLL; + if (endptr == str) + return -E_ATOI_NO_DIGITS; + if (*endptr != '\0') /* Further characters after number */ + return -E_ATOI_JUNK_AT_END; + *value = tmp; + return 1; } /** - * split string and return pointers to its parts. + * Convert a string to a 32-bit signed integer value. * - * \param args the string to be split - * \param argv_ptr pointer to the list of substrings - * \param delim delimiter + * \param str The string to be converted. + * \param value Result pointer. * - * This function modifies \p args by replacing each occurance of \p delim by - * zero. A NULL-terminated array of pointers to char* is allocated dynamically - * and these pointers are initialized to point to the broken-up substrings - * within \p args. A pointer to this array is returned via \p argv_ptr. It's OK - * to call this function with \p args \p == \p NULL. + * \return Standard. * - * \return The number of substrings found in \p args. - */ -__must_check unsigned split_args(char *args, char ***argv_ptr, const char *delim) + * \sa para_atoi64(). +*/ +int para_atoi32(const char *str, int32_t *value) { - char *p = args; - char **argv; - size_t n = 0, i, j; - - p = args + strspn(args, delim); - for (;;) { - i = strcspn(p, delim); - if (!i) - break; - p += i; - n++; - p += strspn(p, delim); - } - *argv_ptr = para_malloc((n + 1) * sizeof(char *)); - argv = *argv_ptr; - i = 0; - p = args + strspn(args, delim); - while (p) { - argv[i] = p; - j = strcspn(p, delim); - if (!j) - break; - p += strcspn(p, delim); - if (*p) { - *p = '\0'; - p++; - p += strspn(p, delim); - } - i++; - } - argv[n] = NULL; - return n; + int64_t tmp; + int ret; + const int32_t max = 2147483647; + + ret = para_atoi64(str, &tmp); + if (ret < 0) + return ret; + if (tmp > max || tmp < -max - 1) + return -E_ATOI_OVERFLOW; + *value = tmp; + return 1; +} + +static inline int loglevel_equal(const char *arg, const char * const ll) +{ + return !strncasecmp(arg, ll, strlen(ll)); } /** - * ensure that file descriptors 0, 1, and 2 are valid + * Compute the loglevel number from its name. * - * Common approach that opens /dev/null until it gets a file descriptor greater - * than two. + * \param txt The name of the loglevel (debug, info, ...). * - * \sa okir's Black Hats Manual. + * \return The numeric representation of the loglevel name. */ -void valid_fd_012(void) +int get_loglevel_by_name(const char *txt) { - while (1) { - int fd; + if (loglevel_equal(txt, "debug")) + return LL_DEBUG; + if (loglevel_equal(txt, "info")) + return LL_INFO; + if (loglevel_equal(txt, "notice")) + return LL_NOTICE; + if (loglevel_equal(txt, "warning")) + return LL_WARNING; + if (loglevel_equal(txt, "error")) + return LL_ERROR; + if (loglevel_equal(txt, "crit")) + return LL_CRIT; + if (loglevel_equal(txt, "emerg")) + return LL_EMERG; + return -1; +} - fd = open("/dev/null", O_RDWR); - if (fd < 0) - exit(EXIT_FAILURE); - if (fd > 2) { - close(fd); +static int get_next_word(const char *buf, const char *delim, char **word) +{ + enum line_state_flags {LSF_HAVE_WORD = 1, LSF_BACKSLASH = 2, + LSF_SINGLE_QUOTE = 4, LSF_DOUBLE_QUOTE = 8}; + const char *in; + char *out; + int ret, state = 0; + + out = para_malloc(strlen(buf) + 1); + *out = '\0'; + *word = out; + for (in = buf; *in; in++) { + const char *p; + + switch (*in) { + case '\\': + if (state & LSF_BACKSLASH) /* \\ */ + goto copy_char; + 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; + } + goto copy_char; + case '"': + if (state & LSF_BACKSLASH) /* \" */ + goto copy_char; + if (state & LSF_SINGLE_QUOTE) /* '" */ + goto copy_char; + if (state & LSF_DOUBLE_QUOTE) { + state &= ~LSF_DOUBLE_QUOTE; + continue; + } + state |= LSF_HAVE_WORD; + state |= LSF_DOUBLE_QUOTE; + continue; + case '\'': + if (state & LSF_BACKSLASH) /* \' */ + goto copy_char; + if (state & LSF_DOUBLE_QUOTE) /* "' */ + goto copy_char; + if (state & LSF_SINGLE_QUOTE) { + state &= ~LSF_SINGLE_QUOTE; + continue; + } + state |= LSF_HAVE_WORD; + state |= LSF_SINGLE_QUOTE; + continue; + } + for (p = delim; *p; p++) { + if (*in != *p) + continue; + if (state & LSF_BACKSLASH) + goto copy_char; + if (state & LSF_SINGLE_QUOTE) + goto copy_char; + if (state & LSF_DOUBLE_QUOTE) + goto copy_char; + if (state & LSF_HAVE_WORD) + goto success; break; } + if (*p) /* ignore delimiter 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_PARA_ERROR(EINVAL); + if (state & LSF_BACKSLASH) { + PARA_ERROR_LOG("trailing backslash\n"); + goto out; } + if ((state & LSF_SINGLE_QUOTE) || (state & LSF_DOUBLE_QUOTE)) { + PARA_ERROR_LOG("unmatched quote character\n"); + goto out; + } +success: + *out = '\0'; + return in - buf; +out: + free(*word); + *word = NULL; + return ret; } /** - * get the own hostname + * Free an array of words created by create_argv(). * - * \return A dynammically allocated string containing the hostname. + * \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 buffer into words. + * + * This parser honors single and double quotes, backslash-escaped characters + * and special characters like \p \\n. The result contains pointers to copies + * of the words contained in \a buf and has to be freed by using \ref + * free_argv(). * - * \sa uname(2) + * \param buf The buffer to be split. + * \param delim Each character in this string is treated as a separator. + * \param result The array of words is returned here. + * + * \return Number of words in \a buf, negative on errors. */ -__malloc char *para_hostname(void) +int create_argv(const char *buf, const char *delim, char ***result) { - struct utsname u; + char *word, **argv = para_malloc(2 * sizeof(char *)); + const char *p; + int ret, num_words; + + for (p = buf, num_words = 0; ; p += ret, num_words++) { + ret = get_next_word(p, delim, &word); + if (ret < 0) + goto err; + if (!ret) + break; + argv = para_realloc(argv, (num_words + 2) * sizeof(char*)); + argv[num_words] = word; + } + argv[num_words] = NULL; + *result = argv; + return num_words; +err: + while (num_words > 0) + free(argv[--num_words]); + free(argv); + return ret; +} - uname(&u); - return para_strdup(u.nodename); +int para_regcomp(regex_t *preg, const char *regex, int cflags) +{ + char *buf; + size_t size; + int ret = regcomp(preg, regex, cflags); + + if (ret == 0) + return 1; + size = regerror(ret, preg, NULL, 0); + buf = para_malloc(size); + regerror(ret, preg, buf, size); + PARA_ERROR_LOG("%s\n", buf); + free(buf); + return -E_REGEX; }