Doxyfile: Change web sync directory.
[paraslash.git] / string.c
index 52c5183..8c97ccf 100644 (file)
--- a/string.c
+++ b/string.c
@@ -1,19 +1,7 @@
 /*
  * Copyright (C) 2004-2007 Andre Noll <maan@systemlinux.org>
  *
- *     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 */
@@ -22,7 +10,6 @@
 #include "string.h"
 
 #include <sys/time.h> /* gettimeofday */
-#include <regex.h>
 #include <pwd.h>
 #include <sys/utsname.h> /* uname() */
 #include <string.h>
@@ -49,8 +36,10 @@ __must_check __malloc void *para_realloc(void *p, size_t size)
         * 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;
@@ -70,10 +59,12 @@ __must_check __malloc void *para_realloc(void *p, size_t size)
  */
 __must_check __malloc void *para_malloc(size_t size)
 {
+       assert(size);
        void *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;
@@ -86,8 +77,8 @@ __must_check __malloc void *para_malloc(size_t 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)
  */
@@ -104,8 +95,8 @@ __must_check __malloc void *para_calloc(size_t size)
  *
  * \param s 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,
  * an pointer to an empty string is returned.
@@ -223,93 +214,6 @@ __must_check __malloc char *para_basename(const char *name)
        return para_strdup(p);
 }
 
-/**
- * simple search and replace routine
- *
- * \param src source string
- * \param macro_name the name of the macro
- * \param replacement the replacement format string
- *
- * 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.
- *
- * \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)
- */
-__must_check __malloc char *s_a_r(const char *src, const char* macro_name,
-               const char *replacement)
-{
-       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;
-}
-
-/**
- * replace a string according to a list of macros
- *
- * \param macro_list the array containing a macro/replacement pairs.
- * \param src the source string
- *
- * This function just calls s_a_r() for each element of \p macro_list.
- *
- * \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.
- */
-__must_check __malloc char *s_a_r_list(struct para_macro *macro_list, char *src)
-{
-       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;
-}
-
 /**
  * cut trailing newline
  *
@@ -340,8 +244,11 @@ void chop(char *buf)
 __must_check __malloc char *para_tmpname(void)
 {
        struct timeval now;
+       unsigned int seed;
+
        gettimeofday(&now, NULL);
-       srand(now.tv_usec);
+       seed = now.tv_usec;
+       srand(seed);
        return make_message("%08i", rand());
 }
 
@@ -405,15 +312,15 @@ __must_check __malloc char *para_homedir(void)
  * \param argv_ptr  pointer to the list of substrings
  * \param delim delimiter
  *
- * 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
+ * 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
  * 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.
+ * within \a args. A pointer to this array is returned via \a argv_ptr. It's OK
+ * to call this function with \a args \a == \p NULL.
  *
- * \return The number of substrings found in \p args.
+ * \return The number of substrings found in \a args.
  */
-__must_check unsigned split_args(char *args, char ***argv_ptr, const char *delim)
+__must_check unsigned split_args(char *args, char *** const argv_ptr, const char *delim)
 {
        char *p = args;
        char **argv;
@@ -486,3 +393,230 @@ __malloc char *para_hostname(void)
        uname(&u);
        return para_strdup(u.nodename);
 }
+
+/**
+ * Used to distinguish between read-only and read-write mode.
+ *
+ * \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 seperated 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().
+ */
+int for_each_line(char *buf, size_t size, line_handler_t *line_handler,
+               void *private_data)
+{
+       return for_each_complete_line(LINE_MODE_RW, buf, size, line_handler,
+               private_data);
+}
+
+/**
+ * Call a custom function for each complete line.
+ *
+ * \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 function behaves like \p for_each_line(), but \a buf is left unchanged.
+ *
+ * \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().
+ */
+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);
+}
+
+/**
+ * Safely print into a buffer at a given offset
+ *
+ * \param b Determines the buffer, its size, and the offset.
+ * \param fmt The format string.
+ *
+ * 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.
+ * 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
+ * therminating \p NULL byte).
+ *
+ * \sa make_message(), vsnprintf(3).
+ */
+__printf_2_3 int para_printf(struct para_buffer *b, const char *fmt, ...)
+{
+       int ret;
+
+       if (!b->buf) {
+               b->buf = para_malloc(128);
+               b->size = 128;
+               b->offset = 0;
+       } else if (b->size <= b->offset + 1) {
+               b->size *= 2;
+               b->buf = para_realloc(b->buf, b->size);
+       }
+       while (1) {
+               char *p = b->buf + b->offset;
+               size_t size = b->size - b->offset;
+               va_list ap;
+               va_start(ap, fmt);
+               ret = vsnprintf(p, size, fmt, ap);
+               va_end(ap);
+               if (ret > -1 && ret < size) { /* success */
+                       b->offset += ret;
+                       break;
+               }
+               /* try again with more space */
+               b->size *= 2;
+               b->buf = para_realloc(b->buf, b->size);
+       }
+       return ret;
+}
+
+/** \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 */
+
+/**
+ * Convert a string to a 64-bit signed integer value.
+ *
+ * \param str The string to be converted.
+ * \param value Result pointer.
+ *
+ * \return Positive on success, negative on errors.
+ *
+ * \sa para_atoi32(), strtol(3), atoi(3).
+ */
+int para_atoi64(const char *str, int64_t *value)
+{
+       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;
+}
+
+/**
+ * Convert a string to a 32-bit signed integer value.
+ *
+ * \param str The string to be converted.
+ * \param value Result pointer.
+ *
+ * \return Positive on success, negative on errors.
+ *
+ * \sa para_atoi64().
+*/
+int para_atoi32(const char *str, int32_t *value)
+{
+       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;
+}