Doxyfile: Change web sync directory.
[paraslash.git] / string.c
index 598a12f..8c97ccf 100644 (file)
--- a/string.c
+++ b/string.c
@@ -36,6 +36,7 @@ __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("realloc failed (size = %zu), aborting\n",
                        size);
@@ -58,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;
@@ -317,7 +320,7 @@ __must_check __malloc char *para_homedir(void)
  *
  * \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;
@@ -390,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;
+}