Update to Olsrd-common version of src/common
authorHenning Rogge <hrogge@googlemail.com>
Sat, 5 Mar 2011 13:23:04 +0000 (14:23 +0100)
committerHenning Rogge <hrogge@googlemail.com>
Sat, 5 Mar 2011 13:23:04 +0000 (14:23 +0100)
(avl_strcasecmp was moved to avl_comp.[ch])

22 files changed:
lib/debuginfo/src/olsrd_debuginfo.c
lib/txtinfo/src/olsrd_txtinfo.c
src/common/autobuf.c
src/common/autobuf.h
src/common/avl.c
src/common/avl.h
src/common/avl_comp.c
src/common/avl_comp.h
src/common/avl_olsr_comp.c
src/common/avl_olsr_comp.h
src/common/common_types.h [new file with mode: 0644]
src/common/container_of.h
src/common/list.h
src/common/string.c
src/common/string.h
src/defs.h
src/olsr_callbacks.c
src/olsr_comport_http.c
src/olsr_comport_txt.c
src/olsr_memcookie.c
src/olsr_memcookie.h
src/plugin_loader.c

index fffe752..b46a0fd 100644 (file)
@@ -46,7 +46,9 @@
 #include <stdlib.h>
 
 #include "common/avl.h"
+#include "common/avl_comp.h"
 #include "common/avl_olsr_comp.h"
+#include "common/string.h"
 #include "olsr.h"
 #include "ipcalc.h"
 #include "neighbor_table.h"
@@ -97,6 +99,8 @@ static uint8_t *olsr_packet_statistics(uint8_t *binary,
 
 static void update_statistics_ptr(void *data __attribute__ ((unused)));
 
+static const char *str_hasnextword (const char *buffer, const char *word);
+
 /* plugin configuration */
 static struct ip_acl allowed_nets;
 static uint32_t traffic_interval, traffic_slots, current_slot;
@@ -738,6 +742,36 @@ olsr_debuginfo_displayhelp(struct comport_connection *con,
   return UNKNOWN;
 }
 
+/**
+ * Check if a string starts with a certain word. The function
+ * is not case sensitive.
+ * @param buffer pointer to string
+ * @param word pointer to the word
+ * @return pointer to the string behind the word, NULL if no match
+ */
+static const char *
+str_hasnextword (const char *buffer, const char *word) {
+  /* skip whitespaces first */
+  while (isblank(*buffer)) {
+    buffer++;
+  }
+
+  while (*word != 0 && *buffer != 0 && !isblank(*buffer) && tolower(*word) == tolower(*buffer)) {
+    word++;
+    buffer++;
+  }
+
+  /* complete match ? */
+  if (*word == 0) {
+    while (isblank(*buffer)) {
+      buffer++;
+    }
+    return buffer;
+  }
+  return NULL;
+}
+
+
 /*
  * Local Variables:
  * mode: c
index 7a04a7a..74040a1 100644 (file)
@@ -232,6 +232,10 @@ static char *values_interface[] = {
   buf_srcip.buf, buf_dstip.buf
 };
 
+/* String constants for later use */
+static const char *OLSR_YES = "yes";
+static const char *OLSR_NO  = "no";
+
 /**
  * Constructor of plugin, called before parameters are initialized
  */
index 5d022e2..18f3d64 100644 (file)
  *
  */
 
-#include "common/autobuf.h"
-#include "defs.h"
-
+#include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
+#include <time.h>
+
+#include "common/autobuf.h"
 
+/**
+ * Rounds up a size value to a certain power of 2
+ * @param val original size
+ * @param pow2 power of 2 (1024, 4096, ...)
+ * @return rounded up size
+ */
+static inline size_t
+ROUND_UP_TO_POWER_OF_2(size_t val, size_t pow2) {
+  return (val + pow2 - 1) & ~(pow2 - 1);
+}
 
-static int autobuf_enlarge(struct autobuf *autobuf, int new_size);
+static int int_autobuf_enlarge(struct autobuf *autobuf, int new_size);
+static int abuf_find_template(const char **keys, int tmplLength,
+    const char *txt, int txtLength);
+static void *int_malloc(size_t size);
+static void *int_realloc(void *old, size_t newsize);
+static void int_free(void *ptr);
 
+static void *(*autobuf_malloc)(size_t) = int_malloc;
+static void *(*autobuf_realloc)(void *, size_t) = int_realloc;
+static void (*autobuf_free)(void *) = int_free;
+
+/**
+ * Allows to overwrite the memory handler functions for autobufs
+ * @param custom_malloc overwrites malloc handler, NULL restores default one
+ * @param custom_realloc overwrites realloc handler, NULL restores default one
+ * @param custom_free overwrites free handler, NULL restores default one
+ */
+void
+abuf_set_memory_handler(
+    void *(*custom_malloc)(size_t),
+    void *(*custom_realloc)(void *, size_t),
+    void (*custom_free)(void *)) {
+  autobuf_malloc = custom_malloc ? custom_malloc : int_malloc;
+  autobuf_realloc = custom_realloc ? custom_realloc : int_realloc;
+  autobuf_free = custom_free ? custom_free : int_free;
+}
 
+/**
+ * Initialize an autobuffer and allocate a chunk of memory
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param initial_size size of allocated memory, might be 0
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
 int
 abuf_init(struct autobuf *autobuf, int initial_size)
 {
@@ -61,7 +104,7 @@ abuf_init(struct autobuf *autobuf, int initial_size)
     return 0;
   }
   autobuf->size = ROUND_UP_TO_POWER_OF_2(initial_size, AUTOBUFCHUNK);
-  autobuf->buf = calloc(autobuf->size, 1);
+  autobuf->buf = autobuf_malloc(autobuf->size);
   if (autobuf->buf == NULL) {
     autobuf->size = 0;
     return -1;
@@ -70,51 +113,47 @@ abuf_init(struct autobuf *autobuf, int initial_size)
   return 0;
 }
 
+/**
+ * Free all currently used memory of an autobuffer.
+ * The buffer can still be used afterwards !
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ */
 void
 abuf_free(struct autobuf *autobuf)
 {
-  free(autobuf->buf);
+  autobuf_free(autobuf->buf);
   autobuf->buf = NULL;
   autobuf->len = 0;
   autobuf->size = 0;
 }
 
-static int
-autobuf_enlarge(struct autobuf *autobuf, int new_size)
-{
-  new_size++;
-  if (new_size > autobuf->size) {
-    char *p;
-    int roundUpSize = ROUND_UP_TO_POWER_OF_2(new_size, AUTOBUFCHUNK);
-    p = realloc(autobuf->buf, roundUpSize);
-    if (p == NULL) {
-#ifdef WIN32
-      WSASetLastError(ENOMEM);
-#else
-      errno = ENOMEM;
-#endif
-      return -1;
-    }
-    autobuf->buf = p;
-
-    memset(&autobuf->buf[autobuf->size], 0, roundUpSize - autobuf->size);
-    autobuf->size = roundUpSize;
-  }
-  return 0;
-}
-
+/**
+ * vprintf()-style function that appends the output to an autobuffer
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param format printf format string
+ * @param ap variable argument list pointer
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
 int
-abuf_vappendf(struct autobuf *autobuf, const char *format, va_list ap)
+abuf_vappendf(struct autobuf *autobuf,
+    const char *format, va_list ap)
 {
   int rc;
   int min_size;
   va_list ap2;
+
+  if (autobuf == NULL) return 0;
+
   va_copy(ap2, ap);
   rc = vsnprintf(autobuf->buf + autobuf->len, autobuf->size - autobuf->len, format, ap);
   va_end(ap);
   min_size = autobuf->len + rc;
   if (min_size >= autobuf->size) {
-    if (autobuf_enlarge(autobuf, min_size) < 0) {
+    if (int_autobuf_enlarge(autobuf, min_size) < 0) {
       autobuf->buf[autobuf->len] = '\0';
       return -1;
     }
@@ -125,25 +164,47 @@ abuf_vappendf(struct autobuf *autobuf, const char *format, va_list ap)
   return 0;
 }
 
+/**
+ * printf()-style function that appends the output to an autobuffer.
+ * The function accepts a variable number of arguments based on the format string.
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param format printf format string
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
 int
 abuf_appendf(struct autobuf *autobuf, const char *fmt, ...)
 {
   int rv;
   va_list ap;
+
+  if (autobuf == NULL) return 0;
+
   va_start(ap, fmt);
   rv = abuf_vappendf(autobuf, fmt, ap);
   va_end(ap);
   return rv;
 }
 
+/**
+ * Appends a null-terminated string to an autobuffer
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param s string to append to the buffer
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
 int
 abuf_puts(struct autobuf *autobuf, const char *s)
 {
   int len;
 
-  if (NULL == s) return 0;
+  if (s == NULL) return 0;
+  if (autobuf == NULL) return 0;
+
   len  = strlen(s);
-  if (autobuf_enlarge(autobuf, autobuf->len + len + 1) < 0) {
+  if (int_autobuf_enlarge(autobuf, autobuf->len + len + 1) < 0) {
     return -1;
   }
   strcpy(autobuf->buf + autobuf->len, s);
@@ -151,13 +212,26 @@ abuf_puts(struct autobuf *autobuf, const char *s)
   return len;
 }
 
+/**
+ * Appends a formatted time string to an autobuffer
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param format strftime() format string
+ * @param tm pointer to time data
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
 int
 abuf_strftime(struct autobuf *autobuf, const char *format, const struct tm *tm)
 {
-  int rc = strftime(autobuf->buf + autobuf->len, autobuf->size - autobuf->len, format, tm);
+  int rc;
+
+  if (autobuf == NULL) return 0;
+
+  rc = strftime(autobuf->buf + autobuf->len, autobuf->size - autobuf->len, format, tm);
   if (rc == 0) {
     /* we had an error! Probably the buffer too small. So we add some bytes. */
-    if (autobuf_enlarge(autobuf, autobuf->size + AUTOBUFCHUNK) < 0) {
+    if (int_autobuf_enlarge(autobuf, autobuf->size + AUTOBUFCHUNK) < 0) {
       autobuf->buf[autobuf->len] = '\0';
       return -1;
     }
@@ -167,10 +241,21 @@ abuf_strftime(struct autobuf *autobuf, const char *format, const struct tm *tm)
   return rc;
 }
 
+/**
+ * Copies a binary buffer to the end of an autobuffer.
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param p pointer to memory block to be copied
+ * @param len length of memory block
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
 int
 abuf_memcpy(struct autobuf *autobuf, const void *p, const unsigned int len)
 {
-  if (autobuf_enlarge(autobuf, autobuf->len + len) < 0) {
+  if (autobuf == NULL) return 0;
+
+  if (int_autobuf_enlarge(autobuf, autobuf->len + len) < 0) {
     return -1;
   }
   memcpy(autobuf->buf + autobuf->len, p, len);
@@ -178,10 +263,22 @@ abuf_memcpy(struct autobuf *autobuf, const void *p, const unsigned int len)
   return len;
 }
 
+/**
+ * Append a memory block to the beginning of an autobuffer.
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param p pointer to memory block to be copied as a prefix
+ * @param len length of memory block
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
 int
-abuf_memcpy_prefix(struct autobuf *autobuf, const void *p, const unsigned int len)
+abuf_memcpy_prefix(struct autobuf *autobuf,
+    const void *p, const unsigned int len)
 {
-  if (autobuf_enlarge(autobuf, autobuf->len + len) < 0) {
+  if (autobuf == NULL) return 0;
+
+  if (int_autobuf_enlarge(autobuf, autobuf->len + len) < 0) {
     return -1;
   }
   memmove(&autobuf->buf[len], autobuf->buf, autobuf->len);
@@ -190,10 +287,22 @@ abuf_memcpy_prefix(struct autobuf *autobuf, const void *p, const unsigned int le
   return len;
 }
 
-int
+/**
+ * Remove a prefix from an autobuffer. This function can be used
+ * to create an autobuffer based fifo.
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param len number of bytes to be removed
+ */
+void
 abuf_pull(struct autobuf * autobuf, int len) {
   char *p;
-  size_t newsize;
+  int newsize;
+
+  if (autobuf == NULL) return;
 
   if (len != autobuf->len) {
     memmove(autobuf->buf, &autobuf->buf[len], autobuf->len - len);
@@ -201,39 +310,42 @@ abuf_pull(struct autobuf * autobuf, int len) {
   autobuf->len -= len;
 
   newsize = ROUND_UP_TO_POWER_OF_2(autobuf->len + 1, AUTOBUFCHUNK);
-  p = realloc(autobuf->buf, newsize);
+  if (newsize + 2*AUTOBUFCHUNK >= autobuf->size) {
+    /* only reduce buffer size if difference is larger than two chunks */
+    return;
+  }
+
+  /* generate smaller buffer */
+  p = autobuf_realloc(autobuf->buf, newsize);
   if (p == NULL) {
-#ifdef WIN32
-    WSASetLastError(ENOMEM);
-#else
-    errno = ENOMEM;
-#endif
-    return -1;
+    /* keep the longer buffer if we cannot get a smaller one */
+    return;
   }
   autobuf->buf = p;
   autobuf->size = newsize;
-  return 0;
-}
-
-static int
-abuf_find_template(const char **keys, int tmplLength, const char *txt, int txtLength) {
-  int i;
-
-  for (i=0; i<tmplLength; i++) {
-    if (strncmp(keys[i], txt, txtLength) == 0 && keys[i][txtLength] == 0) {
-      return i;
-    }
-  }
-  return -1;
+  return;
 }
 
+/**
+ * Initialize an index table for a template engine.
+ * Each usage of a key in the format has to be %key%
+ * @param keys array of keys for the template engine
+ * @param tmplLength number of keys
+ * @param format format string of the template
+ * @param indexTable pointer to an size_t array with a minimum
+ *   length of 3 times the number of keys used in the format string
+ * @param indexLength length of the size_t array
+ * @return number of indices written into index table,
+ *   -1 if an error happened
+ */
 int
 abuf_template_init (const char **keys, size_t tmplLength, const char *format, size_t *indexTable, size_t indexLength) {
   size_t pos = 0, indexCount = 0;
   int start = -1, i = 0;
+  bool escape = false;
 
   while (format[pos]) {
-    if (format[pos] == '%') {
+    if (!escape && format[pos] == '%') {
       if (start == -1) {
         start = pos++;
         continue;
@@ -257,35 +369,127 @@ abuf_template_init (const char **keys, size_t tmplLength, const char *format, si
       }
       start = -1;
     }
+    else if (format[pos] == '\\') {
+      /* handle "\\" and "\%" in text */
+      escape = !escape;
+    }
+    else {
+      escape = false;
+    }
+
     pos++;
   }
   return indexCount;
 }
 
-int abuf_templatef (struct autobuf *buf, const char *format, char **values, size_t *table, size_t indexCount) {
+/**
+ * Append the result of a template engine into an autobuffer.
+ * Each usage of a key will be replaced with the corresponding
+ * value.
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param format format string (as supplied to abuf_template_init()
+ * @param values array of values (same number as keys)
+ * @param table pointer to index table initialized by abuf_template_init()
+ * @param indexCount length of index table as returned by abuf_template_init()
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
+int
+abuf_templatef (struct autobuf *autobuf,
+    const char *format, char **values, size_t *table, size_t indexCount) {
   size_t i, last = 0;
 
+  if (autobuf == NULL) return 0;
+
   for (i=0; i<indexCount; i+=3) {
-    /* copy praefix text */
+    /* copy prefix text */
     if (last < table[i+1]) {
-      if (abuf_memcpy(buf, &format[last], table[i+1] - last) < 0) {
+      if (abuf_memcpy(autobuf, &format[last], table[i+1] - last) < 0) {
         return -1;
       }
     }
-    if (abuf_puts(buf, values[table[i]]) < 0) {
+    if (abuf_puts(autobuf, values[table[i]]) < 0) {
       return -1;
     }
     last = table[i+2];
   }
 
   if (last < strlen(format)) {
-    if (abuf_puts(buf, &format[last]) < 0) {
+    if (abuf_puts(autobuf, &format[last]) < 0) {
       return -1;
     }
   }
   return 0;
 }
 
+/**
+ * Enlarge an autobuffer if necessary
+ * @param autobuf pointer to autobuf object
+ * @param file code file where this function was called (supplied by macro)
+ * @param line line number in file where this function was called (supplied by macro)
+ * @param new_size number of bytes necessary in autobuffer
+ * @return -1 if an out-of-memory error happened, 0 otherwise
+ */
+static int
+int_autobuf_enlarge(struct autobuf *autobuf, int new_size)
+{
+  new_size++;
+  if (new_size > autobuf->size) {
+    char *p;
+    int roundUpSize = ROUND_UP_TO_POWER_OF_2(new_size, AUTOBUFCHUNK);
+    p = autobuf_realloc(autobuf->buf, roundUpSize);
+    if (p == NULL) {
+#ifdef WIN32
+      WSASetLastError(ENOMEM);
+#else
+      errno = ENOMEM;
+#endif
+      return -1;
+    }
+    autobuf->buf = p;
+
+    memset(&autobuf->buf[autobuf->size], 0, roundUpSize - autobuf->size);
+    autobuf->size = roundUpSize;
+  }
+  return 0;
+}
+
+/**
+ * Find the position of one member of a string array in a text.
+ * @param keys pointer to string array
+ * @param tmplLength number of strings in array
+ * @param txt pointer to text to search in
+ * @param txtLength length of text to search in
+ * @return index in array found in text, -1 if no string matched
+ */
+static int
+abuf_find_template(const char **keys, int tmplLength, const char *txt, int txtLength) {
+  int i;
+
+  for (i=0; i<tmplLength; i++) {
+    if (strncmp(keys[i], txt, txtLength) == 0 && keys[i][txtLength] == 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+static void *
+int_malloc(size_t size) {
+  return calloc(size, 1);
+}
+
+static void *
+int_realloc(void *old, size_t newsize) {
+  return realloc(old, newsize);
+}
+
+static void
+int_free(void *ptr) {
+  free (ptr);
+}
+
 /*
  * Local Variables:
  * mode: c
index 6f0e133..324f258 100644 (file)
 #ifndef _COMMON_AUTOBUF_H
 #define _COMMON_AUTOBUF_H
 
-#include "defs.h"
 #include <stdarg.h>
 #include <time.h>
 
-#define AUTOBUFCHUNK   4096
+#include "common/common_types.h"
+
+static const int AUTOBUFCHUNK = 4096;
+
+/**
+ * Auto-sized buffer handler, mostly used for generation of
+ * large string buffers.
+ */
 struct autobuf {
+  /* total number of bytes allocated in the buffer */
   int size;
+
+  /* currently number of used bytes */
   int len;
+
+  /* pointer to allocated memory */
   char *buf;
 };
 
-int EXPORT(abuf_init) (struct autobuf * autobuf, int initial_size);
-void EXPORT(abuf_free) (struct autobuf * autobuf);
+void abuf_set_memory_handler(
+    void *(*custom_malloc)(size_t),
+    void *(*custom_realloc)(void *, size_t),
+    void (*custom_free)(void *));
+
+int EXPORT(abuf_init) (struct autobuf *autobuf, int initial_size);
+void EXPORT(abuf_free) (struct autobuf *autobuf);
 int EXPORT(abuf_vappendf) (struct autobuf *autobuf, const char *fmt, va_list ap) __attribute__ ((format(printf, 2, 0)));
-int EXPORT(abuf_appendf) (struct autobuf * autobuf, const char *fmt, ...) __attribute__ ((format(printf, 2, 3)));
+int EXPORT(abuf_appendf) (struct autobuf *autobuf, const char *fmt, ...) __attribute__ ((format(printf, 2, 3)));
 int EXPORT(abuf_puts) (struct autobuf * autobuf, const char *s);
 int EXPORT(abuf_strftime) (struct autobuf * autobuf, const char *format, const struct tm * tm);
 int EXPORT(abuf_memcpy) (struct autobuf * autobuf, const void *p, const unsigned int len);
 int EXPORT(abuf_memcpy_prefix) (struct autobuf *autobuf, const void *p, const unsigned int len);
-int EXPORT(abuf_pull) (struct autobuf * autobuf, int len);
+void EXPORT(abuf_pull) (struct autobuf * autobuf, int len);
 int EXPORT(abuf_template_init) (const char **keys, size_t length, const char *format, size_t *indexTable, size_t indexLength);
 int EXPORT(abuf_templatef) (struct autobuf *autobuf, const char *format, char **values, size_t *indexTable, size_t indexCount);
+
 #endif
 
 /*
index c0434b8..f207712 100644 (file)
  * the copyright holders.
  */
 
-#include <stdbool.h>
 #include <stddef.h>
-#include <stdint.h>
 #include <time.h>
 #include <string.h>
 
-#include "avl.h"
-#include "list.h"
+#include "common/common_types.h"
+#include "common/list.h"
+#include "common/avl.h"
 
 /**
  * internal type save inline function to calculate the maximum of
@@ -55,7 +54,7 @@
  * @param y second parameter of maximum function
  * @return largest integer of both parameters
  */
-static inline int avl_max(int x, int y) {
+static inline int int_avl_max(int x, int y) {
   return x > y ? x : y;
 }
 
@@ -67,17 +66,23 @@ static inline int avl_max(int x, int y) {
  * @param y second parameter of minimum function
  * @return smallest integer of both parameters
  */
-static inline int avl_min(int x, int y) {
+static inline int int_avl_min(int x, int y) {
   return x < y ? x : y;
 }
 
-static struct avl_node *
-avl_find_rec(struct avl_node *node, const void *key, avl_tree_comp comp, void *ptr, int *cmp_result);
-static void avl_insert_before(struct avl_tree *tree, struct avl_node *pos_node, struct avl_node *node);
-static void avl_insert_after(struct avl_tree *tree, struct avl_node *pos_node, struct avl_node *node);
-static void post_insert(struct avl_tree *tree, struct avl_node *node);
-static void avl_delete_worker(struct avl_tree *tree, struct avl_node *node);
-static void avl_remove(struct avl_tree *tree, struct avl_node *node);
+static struct avl_node *int_avl_find_rec(struct avl_node *node,
+    const void *key, avl_tree_comp comp, void *ptr, int *cmp_result);
+static void int_avl_insert_before(struct avl_tree *tree,
+    struct avl_node *pos_node, struct avl_node *node);
+static void int_avl_insert_after(struct avl_tree *tree,
+    struct avl_node *pos_node, struct avl_node *node);
+static void int_post_insert(struct avl_tree *tree, struct avl_node *node);
+static void int_avl_delete_worker(struct avl_tree *tree, struct avl_node *node);
+static void int_avl_remove(struct avl_tree *tree, struct avl_node *node);
+static void int_avl_rotate_right(struct avl_tree *tree, struct avl_node *node);
+static void int_avl_rotate_left(struct avl_tree *tree, struct avl_node *node);
+static void int_avl_post_delete(struct avl_tree *tree, struct avl_node *node);
+static struct avl_node *int_avl_local_min(struct avl_node *node);
 
 /**
  * Initialize a new avl_tree struct
@@ -114,7 +119,7 @@ avl_find(const struct avl_tree *tree, const void *key)
   if (tree->root == NULL)
     return NULL;
 
-  node = avl_find_rec(tree->root, key, tree->comp, tree->cmp_ptr, &diff);
+  node = int_avl_find_rec(tree->root, key, tree->comp, tree->cmp_ptr, &diff);
 
   return diff == 0 ? node : NULL;
 }
@@ -135,7 +140,7 @@ avl_find_lessequal(const struct avl_tree *tree, const void *key) {
   if (tree->root == NULL)
     return NULL;
 
-  node = avl_find_rec(tree->root, key, tree->comp, tree->cmp_ptr, &diff);
+  node = int_avl_find_rec(tree->root, key, tree->comp, tree->cmp_ptr, &diff);
 
   /* go left as long as key<node.key */
   while (diff < 0) {
@@ -177,7 +182,7 @@ avl_find_greaterequal(const struct avl_tree *tree, const void *key) {
   if (tree->root == NULL)
     return NULL;
 
-  node = avl_find_rec(tree->root, key, tree->comp, tree->cmp_ptr, &diff);
+  node = int_avl_find_rec(tree->root, key, tree->comp, tree->cmp_ptr, &diff);
 
   /* go right as long as key>node.key */
   while (diff > 0) {
@@ -231,7 +236,7 @@ avl_insert(struct avl_tree *tree, struct avl_node *new)
     return 0;
   }
 
-  node = avl_find_rec(tree->root, new->key, tree->comp, tree->cmp_ptr, &diff);
+  node = int_avl_find_rec(tree->root, new->key, tree->comp, tree->cmp_ptr, &diff);
 
   last = node;
 
@@ -251,12 +256,12 @@ avl_insert(struct avl_tree *tree, struct avl_node *new)
 
     new->leader = 0;
 
-    avl_insert_after(tree, last, new);
+    int_avl_insert_after(tree, last, new);
     return 0;
   }
 
   if (node->balance == 1) {
-    avl_insert_before(tree, node, new);
+    int_avl_insert_before(tree, node, new);
 
     node->balance = 0;
     new->parent = node;
@@ -265,7 +270,7 @@ avl_insert(struct avl_tree *tree, struct avl_node *new)
   }
 
   if (node->balance == -1) {
-    avl_insert_after(tree, last, new);
+    int_avl_insert_after(tree, last, new);
 
     node->balance = 0;
     new->parent = node;
@@ -274,21 +279,21 @@ avl_insert(struct avl_tree *tree, struct avl_node *new)
   }
 
   if (diff < 0) {
-    avl_insert_before(tree, node, new);
+    int_avl_insert_before(tree, node, new);
 
     node->balance = -1;
     new->parent = node;
     node->left = new;
-    post_insert(tree, node);
+    int_post_insert(tree, node);
     return 0;
   }
 
-  avl_insert_after(tree, last, new);
+  int_avl_insert_after(tree, last, new);
 
   node->balance = 1;
   new->parent = node;
   node->right = new;
-  post_insert(tree, node);
+  int_post_insert(tree, node);
   return 0;
 }
 
@@ -298,7 +303,7 @@ avl_insert(struct avl_tree *tree, struct avl_node *new)
  * @param node pointer to node
  */
 void
-avl_delete(struct avl_tree *tree, struct avl_node *node)
+avl_remove(struct avl_tree *tree, struct avl_node *node)
 {
   struct avl_node *next;
   struct avl_node *parent;
@@ -338,14 +343,24 @@ avl_delete(struct avl_tree *tree, struct avl_node *node)
     }
 
     else
-      avl_delete_worker(tree, node);
+      int_avl_delete_worker(tree, node);
   }
 
-  avl_remove(tree, node);
+  int_avl_remove(tree, node);
 }
 
+/**
+ * Finds a record in an avl_tree corresponding (or close)
+ * to a supplied key.
+ * @param node pointer to avl_node to start tree lookup
+ * @param key pointer to key
+ * @param comp pointer to key comparator
+ * @param cmp_ptr pointer to key comparator custom data
+ * @param cmp_result pointer to an integer to store the final key comparison
+ * @return pointer to result of the lookup (avl_node)
+ */
 static struct avl_node *
-avl_find_rec(struct avl_node *node, const void *key, avl_tree_comp comp, void *cmp_ptr, int *cmp_result)
+int_avl_find_rec(struct avl_node *node, const void *key, avl_tree_comp comp, void *cmp_ptr, int *cmp_result)
 {
   int diff;
 
@@ -354,14 +369,14 @@ avl_find_rec(struct avl_node *node, const void *key, avl_tree_comp comp, void *c
 
   if (diff < 0) {
     if (node->left != NULL)
-      return avl_find_rec(node->left, key, comp, cmp_ptr, cmp_result);
+      return int_avl_find_rec(node->left, key, comp, cmp_ptr, cmp_result);
 
     return node;
   }
 
   if (diff > 0) {
     if (node->right != NULL)
-      return avl_find_rec(node->right, key, comp, cmp_ptr, cmp_result);
+      return int_avl_find_rec(node->right, key, comp, cmp_ptr, cmp_result);
 
     return node;
   }
@@ -369,8 +384,13 @@ avl_find_rec(struct avl_node *node, const void *key, avl_tree_comp comp, void *c
   return node;
 }
 
+/**
+ * Rotate an avl_node to the right inside a avl_tree
+ * @param tree pointer to tree
+ * @param node pointer to node
+ */
 static void
-avl_rotate_right(struct avl_tree *tree, struct avl_node *node)
+int_avl_rotate_right(struct avl_tree *tree, struct avl_node *node)
 {
   struct avl_node *left, *parent;
 
@@ -397,12 +417,17 @@ avl_rotate_right(struct avl_tree *tree, struct avl_node *node)
   if (node->left != NULL)
     node->left->parent = node;
 
-  node->balance += 1 - avl_min(left->balance, 0);
-  left->balance += 1 + avl_max(node->balance, 0);
+  node->balance += 1 - int_avl_min(left->balance, 0);
+  left->balance += 1 + int_avl_max(node->balance, 0);
 }
 
+/**
+ * Rotate an avl_node to the left inside a avl_tree
+ * @param tree pointer to tree
+ * @param node pointer to node
+ */
 static void
-avl_rotate_left(struct avl_tree *tree, struct avl_node *node)
+int_avl_rotate_left(struct avl_tree *tree, struct avl_node *node)
 {
   struct avl_node *right, *parent;
 
@@ -429,12 +454,17 @@ avl_rotate_left(struct avl_tree *tree, struct avl_node *node)
   if (node->right != NULL)
     node->right->parent = node;
 
-  node->balance -= 1 + avl_max(right->balance, 0);
-  right->balance -= 1 - avl_min(node->balance, 0);
+  node->balance -= 1 + int_avl_max(right->balance, 0);
+  right->balance -= 1 - int_avl_min(node->balance, 0);
 }
 
+/**
+ * Rebalance the avl_tree after an insert
+ * @param tree pointer to avl_tree
+ * @param node pointer to inserted node
+ */
 static void
-post_insert(struct avl_tree *tree, struct avl_node *node)
+int_post_insert(struct avl_tree *tree, struct avl_node *node)
 {
   struct avl_node *parent = node->parent;
 
@@ -448,17 +478,17 @@ post_insert(struct avl_tree *tree, struct avl_node *node)
       return;
 
     if (parent->balance == -1) {
-      post_insert(tree, parent);
+      int_post_insert(tree, parent);
       return;
     }
 
     if (node->balance == -1) {
-      avl_rotate_right(tree, parent);
+      int_avl_rotate_right(tree, parent);
       return;
     }
 
-    avl_rotate_left(tree, node);
-    avl_rotate_right(tree, node->parent->parent);
+    int_avl_rotate_left(tree, node);
+    int_avl_rotate_right(tree, node->parent->parent);
     return;
   }
 
@@ -468,42 +498,67 @@ post_insert(struct avl_tree *tree, struct avl_node *node)
     return;
 
   if (parent->balance == 1) {
-    post_insert(tree, parent);
+    int_post_insert(tree, parent);
     return;
   }
 
   if (node->balance == 1) {
-    avl_rotate_left(tree, parent);
+    int_avl_rotate_left(tree, parent);
     return;
   }
 
-  avl_rotate_right(tree, node);
-  avl_rotate_left(tree, node->parent->parent);
+  int_avl_rotate_right(tree, node);
+  int_avl_rotate_left(tree, node->parent->parent);
 }
 
+/**
+ * Add an avl_node into the linked list before another node and
+ * fix the object count of the tree
+ * @param tree pointer to avl_tree
+ * @param pos_node pointer to reference node
+ * @param node pointer to node to be inserted
+ */
 static void
-avl_insert_before(struct avl_tree *tree, struct avl_node *pos_node, struct avl_node *node)
+int_avl_insert_before(struct avl_tree *tree, struct avl_node *pos_node, struct avl_node *node)
 {
   list_add_before(&pos_node->list, &node->list);
   tree->count++;
 }
 
+/**
+ * Add an avl_node into the linked list after another node and
+ * fix the object count of the tree
+ * @param tree pointer to avl_tree
+ * @param pos_node pointer to reference node
+ * @param node pointer to node to be inserted
+ */
 static void
-avl_insert_after(struct avl_tree *tree, struct avl_node *pos_node, struct avl_node *node)
+int_avl_insert_after(struct avl_tree *tree, struct avl_node *pos_node, struct avl_node *node)
 {
   list_add_after(&pos_node->list, &node->list);
   tree->count++;
 }
 
+/**
+ * Remove an avl_node from the linked list and
+ * fix the object count of the tree
+ * @param tree pointer to avl_tre
+ * @param node pointer to avl_node to be removed
+ */
 static void
-avl_remove(struct avl_tree *tree, struct avl_node *node)
+int_avl_remove(struct avl_tree *tree, struct avl_node *node)
 {
   list_remove(&node->list);
   tree->count--;
 }
 
-static void
-avl_post_delete(struct avl_tree *tree, struct avl_node *node)
+/**
+ * Rebalance the avl_tree after a remove operation
+ * @param tree pointer to avl_tree
+ * @param node pointer to node which childs have to be
+ *   rebalanced.
+ */static void
+int_avl_post_delete(struct avl_tree *tree, struct avl_node *node)
 {
   struct avl_node *parent;
 
@@ -514,7 +569,7 @@ avl_post_delete(struct avl_tree *tree, struct avl_node *node)
     parent->balance++;
 
     if (parent->balance == 0) {
-      avl_post_delete(tree, parent);
+      int_avl_post_delete(tree, parent);
       return;
     }
 
@@ -522,26 +577,26 @@ avl_post_delete(struct avl_tree *tree, struct avl_node *node)
       return;
 
     if (parent->right->balance == 0) {
-      avl_rotate_left(tree, parent);
+      int_avl_rotate_left(tree, parent);
       return;
     }
 
     if (parent->right->balance == 1) {
-      avl_rotate_left(tree, parent);
-      avl_post_delete(tree, parent->parent);
+      int_avl_rotate_left(tree, parent);
+      int_avl_post_delete(tree, parent->parent);
       return;
     }
 
-    avl_rotate_right(tree, parent->right);
-    avl_rotate_left(tree, parent);
-    avl_post_delete(tree, parent->parent);
+    int_avl_rotate_right(tree, parent->right);
+    int_avl_rotate_left(tree, parent);
+    int_avl_post_delete(tree, parent->parent);
     return;
   }
 
   parent->balance--;
 
   if (parent->balance == 0) {
-    avl_post_delete(tree, parent);
+    int_avl_post_delete(tree, parent);
     return;
   }
 
@@ -549,23 +604,28 @@ avl_post_delete(struct avl_tree *tree, struct avl_node *node)
     return;
 
   if (parent->left->balance == 0) {
-    avl_rotate_right(tree, parent);
+    int_avl_rotate_right(tree, parent);
     return;
   }
 
   if (parent->left->balance == -1) {
-    avl_rotate_right(tree, parent);
-    avl_post_delete(tree, parent->parent);
+    int_avl_rotate_right(tree, parent);
+    int_avl_post_delete(tree, parent->parent);
     return;
   }
 
-  avl_rotate_left(tree, parent->left);
-  avl_rotate_right(tree, parent);
-  avl_post_delete(tree, parent->parent);
+  int_avl_rotate_left(tree, parent->left);
+  int_avl_rotate_right(tree, parent);
+  int_avl_post_delete(tree, parent->parent);
 }
 
+/**
+ * Iterate down the the left-most node of a tree
+ * @param node pointer to node to start iterate with
+ * @return left-most child of reference node
+ */
 static struct avl_node *
-avl_local_min(struct avl_node *node)
+int_avl_local_min(struct avl_node *node)
 {
   while (node->left != NULL)
     node = node->left;
@@ -584,8 +644,13 @@ avl_local_max(struct avl_node *node)
 }
 #endif
 
+/**
+ * Remove a node from a tree and rebalance it
+ * @param tree pointer to tree
+ * @param node pointer to node to be removed
+ */
 static void
-avl_delete_worker(struct avl_tree *tree, struct avl_node *node)
+int_avl_delete_worker(struct avl_tree *tree, struct avl_node *node)
 {
   struct avl_node *parent, *min;
 
@@ -605,24 +670,24 @@ avl_delete_worker(struct avl_tree *tree, struct avl_node *node)
         return;
 
       if (parent->balance == 0) {
-        avl_post_delete(tree, parent);
+        int_avl_post_delete(tree, parent);
         return;
       }
 
       if (parent->right->balance == 0) {
-        avl_rotate_left(tree, parent);
+        int_avl_rotate_left(tree, parent);
         return;
       }
 
       if (parent->right->balance == 1) {
-        avl_rotate_left(tree, parent);
-        avl_post_delete(tree, parent->parent);
+        int_avl_rotate_left(tree, parent);
+        int_avl_post_delete(tree, parent->parent);
         return;
       }
 
-      avl_rotate_right(tree, parent->right);
-      avl_rotate_left(tree, parent);
-      avl_post_delete(tree, parent->parent);
+      int_avl_rotate_right(tree, parent->right);
+      int_avl_rotate_left(tree, parent);
+      int_avl_post_delete(tree, parent->parent);
       return;
     }
 
@@ -634,24 +699,24 @@ avl_delete_worker(struct avl_tree *tree, struct avl_node *node)
         return;
 
       if (parent->balance == 0) {
-        avl_post_delete(tree, parent);
+        int_avl_post_delete(tree, parent);
         return;
       }
 
       if (parent->left->balance == 0) {
-        avl_rotate_right(tree, parent);
+        int_avl_rotate_right(tree, parent);
         return;
       }
 
       if (parent->left->balance == -1) {
-        avl_rotate_right(tree, parent);
-        avl_post_delete(tree, parent->parent);
+        int_avl_rotate_right(tree, parent);
+        int_avl_post_delete(tree, parent->parent);
         return;
       }
 
-      avl_rotate_left(tree, parent->left);
-      avl_rotate_right(tree, parent);
-      avl_post_delete(tree, parent->parent);
+      int_avl_rotate_left(tree, parent->left);
+      int_avl_rotate_right(tree, parent);
+      int_avl_post_delete(tree, parent->parent);
       return;
     }
   }
@@ -671,7 +736,7 @@ avl_delete_worker(struct avl_tree *tree, struct avl_node *node)
     else
       parent->right = node->right;
 
-    avl_post_delete(tree, node->right);
+    int_avl_post_delete(tree, node->right);
     return;
   }
 
@@ -690,12 +755,12 @@ avl_delete_worker(struct avl_tree *tree, struct avl_node *node)
     else
       parent->right = node->left;
 
-    avl_post_delete(tree, node->left);
+    int_avl_post_delete(tree, node->left);
     return;
   }
 
-  min = avl_local_min(node->right);
-  avl_delete_worker(tree, min);
+  min = int_avl_local_min(node->right);
+  int_avl_delete_worker(tree, min);
   parent = node->parent;
 
   min->balance = node->balance;
index d6367d8..6f20087 100644 (file)
 #define _AVL_H
 
 #include <stddef.h>
-#include <stdbool.h>
 
+#include "common/common_types.h"
 #include "list.h"
 #include "container_of.h"
 
-/* Support for OLSR.org linker symbol export */
-#define EXPORT(sym) sym
-
 /**
  * This element is a member of a avl-tree. It must be contained in all
  * larger structs that should be put into a tree.
@@ -150,7 +147,7 @@ struct avl_node *EXPORT(avl_find)(const struct avl_tree *, const void *);
 struct avl_node *EXPORT(avl_find_greaterequal)(const struct avl_tree *tree, const void *key);
 struct avl_node *EXPORT(avl_find_lessequal)(const struct avl_tree *tree, const void *key);
 int EXPORT(avl_insert)(struct avl_tree *, struct avl_node *);
-void EXPORT(avl_delete)(struct avl_tree *, struct avl_node *);
+void EXPORT(avl_remove)(struct avl_tree *, struct avl_node *);
 
 /**
  * @param tree pointer to avl-tree
@@ -182,6 +179,21 @@ avl_is_empty(struct avl_tree *tree) {
 }
 
 /**
+ * Legacy function for code that still use the old avl_delete
+ * function instead of the new avl_remove one.
+ *
+ * Use avl_remove() !
+ *
+ * Remove a node from an avl tree
+ * @param tree pointer to tree
+ * @param node pointer to node
+ */
+static inline void
+avl_delete(struct avl_tree *tree, struct avl_node *node) {
+  avl_remove(tree, node);
+}
+
+/**
  * @param tree pointer to avl-tree
  * @param key pointer to key
  * @param element pointer to a node element
index 27de12c..4c0b670 100644 (file)
@@ -37,8 +37,8 @@
  * the copyright holders.
  */
 
-#include <stdint.h>
 #include <string.h>
+#include <strings.h>
 
 #include "common/avl_comp.h"
 
 int
 avl_comp_uint32(const void *k1, const void *k2, void *ptr __attribute__ ((unused)))
 {
-  const uint32_t *key1 = (const uint32_t *)k1;
-  const uint32_t *key2 = (const uint32_t *)k2;
-  if (*key1 > *key2) {
+  const uint32_t *u1 = k1;
+  const uint32_t *u2 = k2;
+
+  if (*u1 > *u2) {
     return 1;
   }
-  if (*key1 < *key2) {
+  if (*u2 > *u1) {
     return -1;
   }
   return 0;
@@ -75,12 +76,13 @@ avl_comp_uint32(const void *k1, const void *k2, void *ptr __attribute__ ((unused
 int
 avl_comp_uint16(const void *k1, const void *k2, void *ptr __attribute__ ((unused)))
 {
-  const uint16_t *key1 = (const uint16_t *)k1;
-  const uint16_t *key2 = (const uint16_t *)k2;
-  if (*key1 > *key2) {
+  const uint16_t *u1 = k1;
+  const uint16_t *u2 = k2;
+
+  if (*u1 > *u2) {
     return 1;
   }
-  if (*key1 < *key2) {
+  if (*u2 > *u1) {
     return -1;
   }
   return 0;
@@ -89,20 +91,23 @@ avl_comp_uint16(const void *k1, const void *k2, void *ptr __attribute__ ((unused
 /**
  * AVL tree comparator for unsigned 8 bit integers
  * Custom pointer is not used
- * @param p1 pointer to key 1
- * @param p2 pointer to key 2
+ * @param k1 pointer to key 1
+ * @param k2 pointer to key 2
  * @param ptr custom pointer for avl comparater (unused)
  * @return +1 if k1>k2, -1 if k1<k2, 0 if k1==k2
  */
 int
-avl_comp_uint8(const void *p1, const void *p2, void *ptr __attribute__ ((unused)))
+avl_comp_uint8(const void *k1, const void *k2, void *ptr __attribute__ ((unused)))
 {
-  const uint8_t *i1 = p1;
-  const uint8_t *i2 = p2;
-  if (*i1 > *i2)
+  const uint8_t *u1 = k1;
+  const uint8_t *u2 = k2;
+
+  if (*u1 > *u2) {
     return 1;
-  if (*i1 < *i2)
+  }
+  if (*u2 > *u1) {
     return -1;
+  }
   return 0;
 }
 
@@ -120,3 +125,16 @@ avl_comp_mem(const void *k1, const void *k2, void *ptr) {
   return memcmp(k1, k2, length);
 }
 
+/**
+ * AVL tree comparator for case insensitive strings.
+ * Custom pointer is the length of the memory to compare.
+ * @param k1 pointer to string 1
+ * @param k2 pointer to string 2
+ * @param ptr custom pointer for avl comparater (unused)
+ * @return +1 if k1>k2, -1 if k1<k2, 0 if k1==k2
+ */
+int
+avl_comp_strcasecmp(const void *txt1, const void *txt2,
+    void *ptr __attribute__ ((unused))) {
+  return strcasecmp(txt1, txt2);
+}
index 3230dc6..981b429 100644 (file)
 #ifndef AVL_COMP_H_
 #define AVL_COMP_H_
 
-#include "common/avl.h"
-
-/* Support for OLSR.org linker symbol export */
-#define EXPORT(sym) sym
+#include "common/common_types.h"
 
 int EXPORT(avl_comp_uint32)(const void *k1, const void *k2, void *ptr);
 int EXPORT(avl_comp_uint16)(const void *k1, const void *k2, void *ptr);
 int EXPORT(avl_comp_uint8)(const void *k1, const void *k2, void *ptr);
 int EXPORT(avl_comp_mem)(const void *k1, const void *k2, void *ptr);
+int EXPORT(avl_comp_strcasecmp)(const void *, const void *, void *);
 
 #endif /* AVL_COMP_H_ */
index eefed0b..5296ef7 100644 (file)
@@ -31,10 +31,6 @@ avl_comp_mac(const void *ip1, const void *ip2, void *ptr __attribute__ ((unused)
   return memcmp(ip1, ip2, 6);
 }
 
-int avl_comp_strcasecmp(const void *txt1, const void *txt2, void *ptr __attribute__ ((unused))) {
-  return strcasecmp(txt1, txt2);
-}
-
 int avl_comp_int(const void *p1, const void *p2, void *ptr __attribute__ ((unused))) {
   const int *i1 = p1, *i2 = p2;
 
index d467552..345b3b5 100644 (file)
@@ -18,7 +18,6 @@ extern avl_tree_comp avl_comp_prefix_origin_default;
 extern int avl_comp_ipv4(const void *, const void *, void *);
 extern int avl_comp_ipv6(const void *, const void *, void *);
 extern int avl_comp_mac(const void *, const void *, void *);
-extern int avl_comp_strcasecmp(const void *, const void *, void *);
 extern int avl_comp_int(const void *, const void *, void *);
 extern int avl_comp_interface_id(const void *, const void *, void *);
 
diff --git a/src/common/common_types.h b/src/common/common_types.h
new file mode 100644 (file)
index 0000000..9b36d8d
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ * common_types.h
+ *
+ *  Created on: Mar 2, 2011
+ *      Author: rogge
+ */
+
+#ifndef COMMON_TYPES_H_
+#define COMMON_TYPES_H_
+
+/*
+ * This include file creates stdint/stdbool datatypes for
+ * visual studio, because microsoft does not support C99
+ */
+
+/* support EXPORT macro of OLSR */
+#ifndef EXPORT
+#  define EXPORT(x) x
+#endif
+
+/* types */
+#ifdef _MSC_VER
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef signed char int8_t;
+typedef signed short int16_t;
+typedef signed int int32_t;
+#else
+#include <inttypes.h>
+#endif
+
+#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+
+/* we have a C99 environment */
+#include <stdbool.h>
+#elif defined __GNUC__
+
+/* we simulate a C99 environment */
+#define bool _Bool
+#define true 1
+#define false 0
+#define __bool_true_false_are_defined 1
+#endif
+
+/* add some safe-gaurds */
+#ifndef _MSC_VER
+#if !defined bool || !defined true || !defined false || !defined __bool_true_false_are_defined
+#error You have no C99-like boolean types. Please extend src/olsr_type.h!
+#endif
+#endif
+
+#endif /* COMMON_TYPES_H_ */
index fc50c61..ca3150c 100644 (file)
 #ifndef CONTAINER_OF_H_
 #define CONTAINER_OF_H_
 
-#include "stddef.h"
+#include <stddef.h>
 
-#ifndef container_of
+/* allow compilation with c99 mode */
+#ifndef typeof
+#define typeof(x) __typeof__(x)
+#endif
 
 /**
  * casts an embedded node of a list/tree into the surrounding struct
@@ -57,7 +60,8 @@
 /**
  * Helper function for NULL safe container_of macro
  */
-static inline void *__container_of_if_notnull(void *ptr, size_t offset) {
+static inline void *
+__container_of_if_notnull(void *ptr, size_t offset) {
   return ptr == NULL ? NULL : (((char *)ptr) - offset);
 }
 
@@ -71,6 +75,4 @@ static inline void *__container_of_if_notnull(void *ptr, size_t offset) {
  */
 #define container_of_if_notnull(ptr, type, member) ((type *)__container_of_if_notnull(ptr, offsetof(type, member)))
 
-#endif
-
 #endif /* CONTAINER_OF_H_ */
index 8c5da60..b70fc5f 100644 (file)
@@ -41,9 +41,9 @@
 #define LIST_H_
 
 #include <stddef.h>
-#include <stdbool.h>
 
-#include "container_of.h"
+#include "common/container_of.h"
+#include "common/common_types.h"
 
 /**
  * this struct is used as list head and list elements.
@@ -67,7 +67,8 @@ struct list_entity {
  * initialize a list-head
  * @param pointer to list-head
  */
-static inline void list_init_head(struct list_entity *head) {
+static inline void
+list_init_head(struct list_entity *head) {
   head->next = head->prev = head;
 }
 
@@ -75,7 +76,8 @@ static inline void list_init_head(struct list_entity *head) {
  * initialize a list-node
  * @param pointer to list-node
  */
-static inline void list_init_node(struct list_entity *entity) {
+static inline void
+list_init_node(struct list_entity *entity) {
   entity->next = entity->prev = NULL;
 }
 
@@ -85,7 +87,8 @@ static inline void list_init_node(struct list_entity *entity) {
  * @param next node after the insertion point
  * @param new node which will be added to the list between 'prev' and 'next'
  */
-static inline void __list_add(struct list_entity *prev, struct list_entity *next, struct list_entity *new) {
+static inline void
+__list_add(struct list_entity *prev, struct list_entity *next, struct list_entity *new) {
   new->next = next;
   new->prev = prev;
   next->prev = new;
@@ -97,7 +100,8 @@ static inline void __list_add(struct list_entity *prev, struct list_entity *next
  * @param head pointer to list head
  * @param new node which will be added to the list
  */
-static inline void list_add_head(struct list_entity *head, struct list_entity *new) {
+static inline void
+list_add_head(struct list_entity *head, struct list_entity *new) {
   __list_add(head, head->next, new);
 }
 
@@ -106,7 +110,8 @@ static inline void list_add_head(struct list_entity *head, struct list_entity *n
  * @param head pointer to list head
  * @param new node which will be added to the list
  */
-static inline void list_add_tail(struct list_entity *head, struct list_entity *new) {
+static inline void
+list_add_tail(struct list_entity *head, struct list_entity *new) {
   __list_add(head->prev, head, new);
 }
 
@@ -115,7 +120,8 @@ static inline void list_add_tail(struct list_entity *head, struct list_entity *n
  * @param before reference node in the list
  * @param new node which will be added to the list
  */
-static inline void list_add_before(struct list_entity *before, struct list_entity *new) {
+static inline void
+list_add_before(struct list_entity *before, struct list_entity *new) {
   __list_add(before->prev, before, new);
 }
 
@@ -124,7 +130,8 @@ static inline void list_add_before(struct list_entity *before, struct list_entit
  * @param before reference node in the list
  * @param new node which will be added to the list
  */
-static inline void list_add_after(struct list_entity *after, struct list_entity *new) {
+static inline void
+list_add_after(struct list_entity *after, struct list_entity *new) {
   __list_add(after, after->next, new);
 }
 
@@ -133,7 +140,8 @@ static inline void list_add_after(struct list_entity *after, struct list_entity
  * @param prev node before the removed part of the list
  * @param next node after the removed part of the list
  */
-static inline void __list_remove(struct list_entity *prev, struct list_entity *next) {
+static inline void
+__list_remove(struct list_entity *prev, struct list_entity *next) {
   prev->next = next;
   next->prev = prev;
 }
@@ -142,7 +150,8 @@ static inline void __list_remove(struct list_entity *prev, struct list_entity *n
  * removes a node from a list and clears node pointers
  * @param entity node to remove from the list
  */
-static inline void list_remove(struct list_entity *entity) {
+static inline void
+list_remove(struct list_entity *entity) {
   __list_remove(entity->prev, entity->next);
   entity->prev = entity->next = NULL;
 }
@@ -152,7 +161,8 @@ static inline void list_remove(struct list_entity *entity) {
  * @param head pointer to list head
  * @return true if list is empty, false otherwise
  */
-static inline bool list_is_empty(struct list_entity *head) {
+static inline bool
+list_is_empty(struct list_entity *head) {
   return head->next == head && head->prev == head;
 }
 
@@ -162,7 +172,8 @@ static inline bool list_is_empty(struct list_entity *head) {
  * @return true if both pointers of the node are initialized,
  *   false otherwise
  */
-static inline bool list_node_added(struct list_entity *node) {
+static inline bool
+list_node_added(struct list_entity *node) {
   return node->next != NULL && node->prev != NULL;
 }
 
@@ -172,7 +183,8 @@ static inline bool list_node_added(struct list_entity *node) {
  * @param entity pointer to node
  * @return true if node is first element of list, false otherwise
  */
-static inline bool list_is_first(const struct list_entity *head, const struct list_entity *entity) {
+static inline bool
+list_is_first(const struct list_entity *head, const struct list_entity *entity) {
   return head->next == entity;
 }
 
@@ -182,7 +194,8 @@ static inline bool list_is_first(const struct list_entity *head, const struct li
  * @param entity pointer to node
  * @return true if node is last element of list, false otherwise
  */
-static inline bool list_is_last(const struct list_entity *head, const struct list_entity *entity) {
+static inline bool
+list_is_last(const struct list_entity *head, const struct list_entity *entity) {
   return head->prev == entity;
 }
 
@@ -192,7 +205,8 @@ static inline bool list_is_last(const struct list_entity *head, const struct lis
  * @param remove_from head of the list which elements will be added after the elements
  *   of the first one
  */
-static inline void list_merge(struct list_entity *add_to, struct list_entity *remove_from) {
+static inline void
+list_merge(struct list_entity *add_to, struct list_entity *remove_from) {
   if (list_is_empty(remove_from)) {
     return;
   }
index fc8f267..edca96d 100644 (file)
  *
  */
 
-#include "common/string.h"
-
-#include <string.h>
 #include <assert.h>
+#include <ctype.h>
+#include <string.h>
 
-const char *OLSR_YES = "yes";
-const char *OLSR_NO = "no";
+#include "common/string.h"
 
-/*
- * A somewhat safe version of strncpy and strncat. Note, that
- * BSD/Solaris strlcpy()/strlcat() differ in implementation, while
- * the BSD compiler prints out a warning if you use plain strcpy().
+/**
+ * A safer version of strncpy that ensures that the
+ * destination string will be null-terminated if its
+ * length is greater than 0.
+ * @param dest target string buffer
+ * @param src source string buffer
+ * @param size size of target buffer
+ * @return pointer to target buffer
  */
 char *
 strscpy(char *dest, const char *src, size_t size)
 {
-  size_t l = 0;
   assert(dest != NULL);
   assert(src != NULL);
-  if (NULL != dest && NULL != src) {
-    /* src does not need to be null terminated */
-    if (0 < size--) {
-      while (l < size && 0 != src[l])
-        l++;
-    }
-    dest[l] = 0;
+
+  /* src does not need to be null terminated */
+  if (size > 0) {
+    strncpy(dest, src, size-1);
+    dest[size-1] = 0;
   }
-  return strncpy(dest, src, l);
+
+  return dest;
 }
 
-/*
- * A somewhat safe version of strncat. Note, that the
- * size parameter denotes the complete size of dest,
- * which is different from the strncat semantics.
+/**
+ * A safer version of strncat that ensures that
+ * the target buffer will be null-terminated if
+ * its size is greater than zero.
+ *
+ * If the target buffer is already full, it will
+ * not be changed.
+ * @param dest target string buffer
+ * @param src source string buffer
+ * @param size size of target buffer
+ * @return pointer to target buffer
  */
 char *
 strscat(char *dest, const char *src, size_t size)
 {
-  const size_t l = strlen(dest);
-  return strscpy(dest + l, src, size > l ? size - l : 0);
+  size_t l;
+
+  assert(dest != NULL);
+  assert(src != NULL);
+
+  l = strlen(dest);
+  if (l < size) {
+    strscpy(dest + l, src, size - l);
+  }
+  return dest;
 }
 
 /**
- * Check if a string starts with a certain word. The function
- * is not case sensitive.
- * @param buffer pointer to string
- * @param word pointer to the word
- * @return pointer to the string behind the word, NULL if no match
+ * Removes leading and trailing whitespaces from a string.
+ * Instead of moving characters around, it will change the
+ * pointer to the beginning of the buffer.
+ * @param ptr pointer to string-pointer
  */
-const char *
-str_hasnextword (const char *buffer, const char *word) {
-  /* skip whitespaces first */
-  while (isblank(*buffer)) {
-    buffer++;
+void
+str_trim (char **ptr) {
+  char *string, *end;
+
+  assert (ptr);
+  assert (*ptr);
+
+  string = *ptr;
+
+  /* skip leading whitespaces */
+  while (isspace(*string)) {
+    string++;
   }
 
-  while (*word != 0 && *buffer != 0 && !isblank(*buffer) && tolower(*word) == tolower(*buffer)) {
-    word++;
-    buffer++;
+  /* get end of string */
+  end = string;
+  while (*end) {
+    end++;
   }
+  end--;
 
-  /* complete match ? */
-  if (*word == 0) {
-    while (isblank(*buffer)) {
-      buffer++;
-    }
-    return buffer;
+  /* remove trailing whitespaces */
+  while (end > string && isspace(*end)) {
+    *end-- = 0;
   }
-  return NULL;
+
+  *ptr = string;
 }
 
 /*
index 7cf055f..68cd99a 100644 (file)
 #ifndef COMMON_STRING_H_
 #define COMMON_STRING_H_
 
-#include "defs.h"
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 
+#include "common/common_types.h"
+
 char *EXPORT(strscpy) (char *dest, const char *src, size_t size);
 char *EXPORT(strscat) (char *dest, const char *src, size_t size);
-
-const char *EXPORT(str_hasnextword) (const char *buffer, const char *word);
-
-extern const char *EXPORT(OLSR_YES);
-extern const char *EXPORT(OLSR_NO);
+void EXPORT(str_trim) (char **ptr);
 
 #endif
 
index 80f84a3..49bc42b 100644 (file)
@@ -47,7 +47,9 @@
 #endif
 
 /* Export symbol for use in plugins. See ../olsrd-exports.sh */
-#define EXPORT(sym) sym
+#ifndef EXPORT
+#  define EXPORT(x) x
+#endif
 
 extern const char EXPORT(olsrd_version)[];
 extern const char EXPORT(build_date)[];
index 7aa9b21..d4d513b 100644 (file)
@@ -11,7 +11,7 @@
 
 #include "common/list.h"
 #include "common/avl.h"
-#include "common/avl_olsr_comp.h"
+#include "common/avl_comp.h"
 #include "olsr_logging.h"
 #include "olsr_callbacks.h"
 
index 7a46489..ffb5a4d 100644 (file)
@@ -45,7 +45,7 @@
 
 #include "common/autobuf.h"
 #include "common/avl.h"
-#include "common/avl_olsr_comp.h"
+#include "common/avl_comp.h"
 #include "common/string.h"
 #include "olsr_logging.h"
 #include "olsr_memcookie.h"
index f2aa08e..77f6f74 100644 (file)
@@ -43,7 +43,7 @@
 #include <stdlib.h>
 
 #include "common/avl.h"
-#include "common/avl_olsr_comp.h"
+#include "common/avl_comp.h"
 #include "olsr_cfg.h"
 #include "olsr_logging.h"
 #include "olsr_memcookie.h"
index 6a5acc0..a89bd9c 100644 (file)
@@ -45,7 +45,7 @@
 
 #include "common/list.h"
 #include "common/avl.h"
-#include "common/avl_olsr_comp.h"
+#include "common/avl_comp.h"
 #include "olsr.h"
 #include "defs.h"
 #include "olsr_memcookie.h"
index 08ab1db..1dc6ba0 100644 (file)
  *
  */
 
-#include <stdint.h>
+#ifndef _OLSR_MEMCOOKIE_H
+#define _OLSR_MEMCOOKIE_H
 
 #include "olsr_types.h"
 #include "common/list.h"
 #include "common/avl.h"
 
-#ifndef _OLSR_COOKIE_H
-#define _OLSR_COOKIE_H
-
 extern struct avl_tree EXPORT(olsr_cookie_tree);
 
 /*
@@ -189,7 +187,7 @@ olsr_memcookie_set_minfree(struct olsr_memcookie_info *ci, uint32_t min_free)
   ci->ci_min_free_count = min_free;
 }
 
-#endif /* _OLSR_COOKIE_H */
+#endif /* _OLSR_MEMCOOKIE_H */
 
 /*
  * Local Variables:
index 10af0cb..fbf48fd 100644 (file)
@@ -47,7 +47,7 @@
 
 #include "common/list.h"
 #include "common/avl.h"
-#include "common/avl_olsr_comp.h"
+#include "common/avl_comp.h"
 #include "plugin_loader.h"
 #include "plugin.h"
 #include "plugin_util.h"