Update to cleaned up commons API
authorHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Thu, 23 Feb 2012 13:53:44 +0000 (14:53 +0100)
committerHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Thu, 23 Feb 2012 13:53:44 +0000 (14:53 +0100)
15 files changed:
lib/cfgio_file/src/cfgio_file.c
src/common/autobuf.c
src/common/autobuf.h
src/common/common_types.h
src/config/cfg.c
src/core/olsr_cfg.c
src/core/olsr_http.c
src/core/olsr_logging.c
src/core/olsr_packet_socket.c
src/core/olsr_plugins.c
src/core/olsr_stream_socket.c
src/core/olsr_telnet.c
src/core/os_linux/os_system_linux.c
src/core/os_linux/os_system_linux.h
src/olsr_main.c

index f296881..b527400 100644 (file)
@@ -164,7 +164,7 @@ _cb_file_load(struct cfg_instance *instance,
     parser = cfg_parser_find(instance, &dst, param, NULL);
   }
 
-  db = cfg_parser_parse_buffer(instance, parser, dst.buf, dst.len, log);
+  db = cfg_parser_parse_buffer(instance, parser, abuf_getptr(&dst), abuf_getlen(&dst), log);
   abuf_free(&dst);
   return db;
 }
@@ -211,8 +211,8 @@ _cb_file_save(struct cfg_instance *instance,
   }
 
   total = 0;
-  while (total < abuf.len) {
-    bytes = write(fd, &abuf.buf[total], abuf.len - total);
+  while (total < abuf_getlen(&abuf)) {
+    bytes = write(fd, abuf_getptr(&abuf) + total, abuf_getlen(&abuf) - total);
     if (bytes <= 0 && errno != EINTR) {
       cfg_append_printable_line(log,
           "Error while writing to file '%s': %s (%d)",
index 7591e6f..9d0a00b 100644 (file)
@@ -63,27 +63,6 @@ ROUND_UP_TO_POWER_OF_2(size_t val, size_t pow2) {
 }
 
 static int _autobuf_enlarge(struct autobuf *autobuf, size_t new_size);
-static void *_malloc(size_t size);
-
-static void *(*autobuf_malloc)(size_t) = _malloc;
-static void *(*autobuf_realloc)(void *, size_t) = realloc;
-static void (*autobuf_free)(void *) = 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 : _malloc;
-  autobuf_realloc = custom_realloc ? custom_realloc : realloc;
-  autobuf_free = custom_free ? custom_free : free;
-}
 
 /**
  * Initialize an autobuffer and allocate a chunk of memory
@@ -93,14 +72,14 @@ abuf_set_memory_handler(
 int
 abuf_init(struct autobuf *autobuf)
 {
-  autobuf->len = 0;
-  autobuf->size = AUTOBUFCHUNK;
-  autobuf->buf = autobuf_malloc(autobuf->size);
-  if (autobuf->buf == NULL) {
-    autobuf->size = 0;
+  autobuf->_len = 0;
+  autobuf->_total = AUTOBUFCHUNK;
+  autobuf->_buf = calloc(1, autobuf->_total);
+  if (autobuf->_buf == NULL) {
+    autobuf->_total = 0;
     return -1;
   }
-  *autobuf->buf = '\0';
+  *autobuf->_buf = '\0';
   return 0;
 }
 
@@ -112,10 +91,10 @@ abuf_init(struct autobuf *autobuf)
 void
 abuf_free(struct autobuf *autobuf)
 {
-  autobuf_free(autobuf->buf);
-  autobuf->buf = NULL;
-  autobuf->len = 0;
-  autobuf->size = 0;
+  free(autobuf->_buf);
+  autobuf->_buf = NULL;
+  autobuf->_len = 0;
+  autobuf->_total = 0;
 }
 
 /**
@@ -138,18 +117,18 @@ abuf_vappendf(struct autobuf *autobuf,
   if (autobuf == NULL) return 0;
 
   va_copy(ap2, ap);
-  rc = vsnprintf(autobuf->buf + autobuf->len, autobuf->size - autobuf->len, format, ap);
+  rc = vsnprintf(autobuf->_buf + autobuf->_len, autobuf->_total - autobuf->_len, format, ap);
   va_end(ap);
-  min_size = autobuf->len + (size_t)rc;
-  if (min_size >= autobuf->size) {
+  min_size = autobuf->_len + (size_t)rc;
+  if (min_size >= autobuf->_total) {
     if (_autobuf_enlarge(autobuf, min_size) < 0) {
-      autobuf->buf[autobuf->len] = '\0';
+      autobuf->_buf[autobuf->_len] = '\0';
       return -1;
     }
-    vsnprintf(autobuf->buf + autobuf->len, autobuf->size - autobuf->len, format, ap2);
+    vsnprintf(autobuf->_buf + autobuf->_len, autobuf->_total - autobuf->_len, format, ap2);
   }
   va_end(ap2);
-  autobuf->len = min_size;
+  autobuf->_len = min_size;
   return rc;
 }
 
@@ -189,11 +168,11 @@ abuf_puts(struct autobuf *autobuf, const char *s)
   if (autobuf == NULL) return 0;
 
   len  = strlen(s);
-  if (_autobuf_enlarge(autobuf, autobuf->len + len + 1) < 0) {
+  if (_autobuf_enlarge(autobuf, autobuf->_len + len + 1) < 0) {
     return -1;
   }
-  strcpy(autobuf->buf + autobuf->len, s);
-  autobuf->len += len;
+  strcpy(autobuf->_buf + autobuf->_len, s);
+  autobuf->_len += len;
   return 0;
 }
 
@@ -211,16 +190,16 @@ abuf_strftime(struct autobuf *autobuf, const char *format, const struct tm *tm)
 
   if (autobuf == NULL) return 0;
 
-  rc = strftime(autobuf->buf + autobuf->len, autobuf->size - autobuf->len, format, tm);
+  rc = strftime(autobuf->_buf + autobuf->_len, autobuf->_total - 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) {
-      autobuf->buf[autobuf->len] = '\0';
+    if (_autobuf_enlarge(autobuf, autobuf->_total + AUTOBUFCHUNK) < 0) {
+      autobuf->_buf[autobuf->_len] = '\0';
       return -1;
     }
-    rc = strftime(autobuf->buf + autobuf->len, autobuf->size - autobuf->len, format, tm);
+    rc = strftime(autobuf->_buf + autobuf->_len, autobuf->_total - autobuf->_len, format, tm);
   }
-  autobuf->len += rc;
+  autobuf->_len += rc;
   return rc == 0 ? -1 : 0;
 }
 
@@ -236,14 +215,14 @@ abuf_memcpy(struct autobuf *autobuf, const void *p, const size_t len)
 {
   if (autobuf == NULL) return 0;
 
-  if (_autobuf_enlarge(autobuf, autobuf->len + len) < 0) {
+  if (_autobuf_enlarge(autobuf, autobuf->_len + len) < 0) {
     return -1;
   }
-  memcpy(autobuf->buf + autobuf->len, p, len);
-  autobuf->len += len;
+  memcpy(autobuf->_buf + autobuf->_len, p, len);
+  autobuf->_len += len;
 
   /* null-terminate autobuf */
-  autobuf->buf[autobuf->len] = 0;
+  autobuf->_buf[autobuf->_len] = 0;
 
   return 0;
 }
@@ -261,15 +240,15 @@ abuf_memcpy_prepend(struct autobuf *autobuf,
 {
   if (autobuf == NULL) return 0;
 
-  if (_autobuf_enlarge(autobuf, autobuf->len + len) < 0) {
+  if (_autobuf_enlarge(autobuf, autobuf->_len + len) < 0) {
     return -1;
   }
-  memmove(&autobuf->buf[len], autobuf->buf, autobuf->len);
-  memcpy(autobuf->buf, p, len);
-  autobuf->len += len;
+  memmove(&autobuf->_buf[len], autobuf->_buf, autobuf->_len);
+  memcpy(autobuf->_buf, p, len);
+  autobuf->_len += len;
 
   /* null-terminate autobuf */
-  autobuf->buf[autobuf->len] = 0;
+  autobuf->_buf[autobuf->_len] = 0;
 
   return 0;
 }
@@ -287,25 +266,25 @@ abuf_pull(struct autobuf * autobuf, size_t len) {
 
   if (autobuf == NULL) return;
 
-  if (len != autobuf->len) {
-    memmove(autobuf->buf, &autobuf->buf[len], autobuf->len - len);
+  if (len != autobuf->_len) {
+    memmove(autobuf->_buf, &autobuf->_buf[len], autobuf->_len - len);
   }
-  autobuf->len -= len;
+  autobuf->_len -= len;
 
-  newsize = ROUND_UP_TO_POWER_OF_2(autobuf->len + 1, AUTOBUFCHUNK);
-  if (newsize + 2*AUTOBUFCHUNK >= autobuf->size) {
+  newsize = ROUND_UP_TO_POWER_OF_2(autobuf->_len + 1, AUTOBUFCHUNK);
+  if (newsize + 2*AUTOBUFCHUNK >= autobuf->_total) {
     /* only reduce buffer size if difference is larger than two chunks */
     return;
   }
 
   /* generate smaller buffer */
-  p = autobuf_realloc(autobuf->buf, newsize);
+  p = realloc(autobuf->_buf, newsize);
   if (p == NULL) {
     /* keep the longer buffer if we cannot get a smaller one */
     return;
   }
-  autobuf->buf = p;
-  autobuf->size = newsize;
+  autobuf->_buf = p;
+  autobuf->_total = newsize;
   return;
 }
 
@@ -323,9 +302,9 @@ _autobuf_enlarge(struct autobuf *autobuf, size_t new_size)
   size_t roundUpSize;
 
   new_size++;
-  if (new_size > autobuf->size) {
+  if (new_size > autobuf->_total) {
     roundUpSize = ROUND_UP_TO_POWER_OF_2(new_size+1, AUTOBUFCHUNK);
-    p = autobuf_realloc(autobuf->buf, roundUpSize);
+    p = realloc(autobuf->_buf, roundUpSize);
     if (p == NULL) {
 #ifdef WIN32
       WSASetLastError(ENOMEM);
@@ -334,21 +313,10 @@ _autobuf_enlarge(struct autobuf *autobuf, size_t new_size)
 #endif
       return -1;
     }
-    autobuf->buf = p;
+    autobuf->_buf = p;
 
-    memset(&autobuf->buf[autobuf->size], 0, roundUpSize - autobuf->size);
-    autobuf->size = roundUpSize;
+    memset(&autobuf->_buf[autobuf->_total], 0, roundUpSize - autobuf->_total);
+    autobuf->_total = roundUpSize;
   }
   return 0;
 }
-
-/**
- * Internal implementation of malloc that clears buffer.
- * Maps to calloc(size, 1).
- * @param size number of bytes to be allocated
- * @return pointer to allocated memory, NULL if out of memory
- */
-static void *
-_malloc(size_t size) {
-  return calloc(size, 1);
-}
index 5b3110b..3cec1bf 100644 (file)
@@ -56,20 +56,15 @@ static const size_t AUTOBUFCHUNK = 4096;
  */
 struct autobuf {
   /* total number of bytes allocated in the buffer */
-  size_t size;
+  size_t _total;
 
   /* currently number of used bytes */
-  size_t len;
+  size_t _len;
 
   /* pointer to allocated memory */
-  char *buf;
+  char *_buf;
 };
 
-EXPORT void abuf_set_memory_handler(
-    void *(*custom_malloc)(size_t),
-    void *(*custom_realloc)(void *, size_t),
-    void (*custom_free)(void *));
-
 EXPORT int abuf_init(struct autobuf *autobuf);
 EXPORT void abuf_free(struct autobuf *autobuf);
 EXPORT int abuf_vappendf(struct autobuf *autobuf, const char *fmt,
@@ -91,8 +86,48 @@ EXPORT void abuf_pull(struct autobuf * autobuf, size_t len);
  */
 static INLINE void
 abuf_clear(struct autobuf *autobuf) {
-  autobuf->len = 0;
-  memset(autobuf->buf, 0, autobuf->size);
+  autobuf->_len = 0;
+  memset(autobuf->_buf, 0, autobuf->_total);
+}
+
+/**
+ * @param autobuf pointer to autobuf
+ * @return pointer to internal bufffer memory
+ */
+static INLINE char *
+abuf_getptr(struct autobuf *autobuf) {
+  return autobuf->_buf;
+}
+
+/**
+ * @param autobuf pointer to autobuf
+ * @return number of bytes stored in autobuf
+ */
+static INLINE size_t
+abuf_getlen(struct autobuf *autobuf) {
+  return autobuf->_len;
+}
+
+/**
+ * @param autobuf pointer to autobuf
+ * @return number of bytes allocated in buffer
+ */
+static INLINE size_t
+abuf_getmax(struct autobuf *autobuf) {
+  return autobuf->_total;
+}
+
+/**
+ *
+ * @param autobuf
+ * @param len
+ */
+static INLINE void
+abuf_setlen(struct autobuf * autobuf, size_t len) {
+  if (autobuf->_total > len) {
+    autobuf->_len = len;
+  }
+  autobuf->_buf[len] = 0;
 }
 
 /**
index c4a829d..918fa2a 100644 (file)
 #endif
 #endif
 
-/*
- * This include file creates stdint/stdbool datatypes for
- * visual studio, because microsoft does not support C99
- */
-
 /* printf size_t modifiers*/
 
 #if defined(WIN32)
   #error Please implement size_t modifiers
 #endif
 
-/* types */
-#if defined(WIN32)
+#include <limits.h>
+
+/* we have C99 ? */
+#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#include <stdbool.h>
+#else
+
+/*
+ * This include file creates stdint/stdbool datatypes for
+ * visual studio, because microsoft does not support C99
+ */
+
 typedef unsigned char uint8_t;
 typedef unsigned short uint16_t;
 typedef unsigned int uint32_t;
@@ -107,30 +113,17 @@ typedef signed int int32_t;
 # define UINT8_MAX    (255)
 # define UINT16_MAX   (65535)
 # define UINT32_MAX   (4294967295U)
-#else
-#include <inttypes.h>
-#endif
-
-#include <limits.h>
-
-#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
-
-/* we have a C99 environment */
-#include <stdbool.h>
-#elif defined __GNUC__
 
+#ifdef __GNUC__
 /* we simulate a C99 environment */
 #define bool _Bool
 #define true 1
 #define false 0
 #define __bool_true_false_are_defined 1
-#endif
+#else
+#error No boolean available, please extende common/common_types.h
+#endif /* __GNUC__ */
 
-/* add some safe-gaurds */
-#ifndef WIN32
-#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 /* __STDC_VERSION__ && __STDC_VERSION__ >= 199901L */
 
 #endif /* COMMON_TYPES_H_ */
index 9b4e917..12fe37e 100644 (file)
@@ -98,8 +98,8 @@ cfg_append_printable_line(struct autobuf *autobuf, const char *fmt, ...) {
 
   if (autobuf == NULL) return 0;
 
-  _value = (unsigned char *)autobuf->buf + autobuf->len;
-  len = autobuf->len;
+  _value = (unsigned char *)abuf_getptr(autobuf) + abuf_getlen(autobuf);
+  len = abuf_getlen(autobuf);
 
   va_start(ap, fmt);
   rv = abuf_vappendf(autobuf, fmt, ap);
@@ -110,7 +110,7 @@ cfg_append_printable_line(struct autobuf *autobuf, const char *fmt, ...) {
   }
 
   /* convert everything non-printable to '.' */
-  while (*_value && len++ < autobuf->len) {
+  while (*_value && len++ < abuf_getlen(autobuf)) {
     if (*_value < 32 || *_value == 127 || *_value == 255) {
       *_value = '.';
     }
index b8f03b3..b0e4af6 100644 (file)
@@ -255,7 +255,7 @@ olsr_cfg_apply(void) {
   /* re-validate configuration data */
   if (cfg_schema_validate(_olsr_raw_db, false, true, &log)) {
     OLSR_WARN(LOG_CONFIG, "Configuration validation failed");
-    OLSR_WARN_NH(LOG_CONFIG, "%s", log.buf);
+    OLSR_WARN_NH(LOG_CONFIG, "%s", abuf_getptr(&log));
     goto apply_failed;
   }
 
index 1f28be4..1eb128c 100644 (file)
@@ -211,10 +211,10 @@ _cb_receive_data(struct olsr_stream_session *session) {
   size_t len;
 
   /* search for end of http header */
-  if ((first_header = strstr(session->in.buf, "\r\n\r\n"))) {
+  if ((first_header = strstr(abuf_getptr(&session->in), "\r\n\r\n"))) {
     first_header += 4;
   }
-  else if ((first_header = strstr(session->in.buf, "\n\n"))) {
+  else if ((first_header = strstr(abuf_getptr(&session->in), "\n\n"))) {
     first_header += 2;
   }
   else {
@@ -222,7 +222,7 @@ _cb_receive_data(struct olsr_stream_session *session) {
     return STREAM_SESSION_ACTIVE;
   }
 
-  if (_parse_http_header(session->in.buf, session->in.len, &header)) {
+  if (_parse_http_header(abuf_getptr(&session->in), abuf_getlen(&session->in), &header)) {
     OLSR_INFO(LOG_HTTP, "Error, malformed HTTP header.\n");
     _create_http_error(session, HTTP_400_BAD_REQ);
     return STREAM_SESSION_SEND_AND_QUIT;
@@ -259,7 +259,7 @@ _cb_receive_data(struct olsr_stream_session *session) {
       return STREAM_SESSION_SEND_AND_QUIT;
     }
 
-    if (strtoul(content_length, NULL, 10) > session->in.len) {
+    if (strtoul(content_length, NULL, 10) > abuf_getlen(&session->in)) {
       /* header not complete */
       return STREAM_SESSION_ACTIVE;;
     }
@@ -493,8 +493,8 @@ _create_http_header(struct olsr_stream_session *session,
   abuf_appendf(&buf, "Content-type: %s\r\n", content_type);
 
   /* Content length */
-  if (session->out.len > 0) {
-    abuf_appendf(&buf, "Content-length: %zu\r\n", session->out.len);
+  if (abuf_getlen(&session->out) > 0) {
+    abuf_appendf(&buf, "Content-length: %zu\r\n", abuf_getlen(&session->out));
   }
 
   if (code == HTTP_401_UNAUTHORIZED) {
@@ -510,8 +510,8 @@ _create_http_header(struct olsr_stream_session *session,
   /* End header */
   abuf_puts(&buf, "\r\n");
 
-  abuf_memcpy_prepend(&session->out, buf.buf, buf.len);
-  OLSR_DEBUG(LOG_HTTP, "Generated Http-Header:\n%s", buf.buf);
+  abuf_memcpy_prepend(&session->out, abuf_getptr(&buf), abuf_getlen(&buf));
+  OLSR_DEBUG(LOG_HTTP, "Generated Http-Header:\n%s", abuf_getptr(&buf));
 
   abuf_free(&buf);
 }
index adf380a..ea31227 100644 (file)
@@ -331,8 +331,8 @@ olsr_log(enum log_severity severity, enum log_source source, bool no_header,
   p3 = abuf_vappendf(&_logbuffer, format, ap);
 
   /* remove \n at the end of the line if necessary */
-  if (_logbuffer.buf[p1 + p2 + p3 - 1] == '\n') {
-    _logbuffer.buf[p1 + p2 + p3 - 1] = 0;
+  if (abuf_getptr(&_logbuffer)[p1 + p2 + p3 - 1] == '\n') {
+    abuf_getptr(&_logbuffer)[p1 + p2 + p3 - 1] = 0;
     p3--;
   }
 
@@ -341,7 +341,7 @@ olsr_log(enum log_severity severity, enum log_source source, bool no_header,
   param.no_header = no_header;
   param.file = file;
   param.line = line;
-  param.buffer = _logbuffer.buf;
+  param.buffer = abuf_getptr(&_logbuffer);
   param.timeLength = p1;
   param.prefixLength = p2;
 
@@ -377,6 +377,7 @@ olsr_log_oom(enum log_severity severity, enum log_source source,
   struct log_handler_entry *h, *iterator;
   struct log_parameters param;
   int i,j;
+  char *ptr;
 
   /* test if event is consumed by any log handler */
   if (!log_global_mask[source].log_for_severity[severity]) {
@@ -385,31 +386,32 @@ olsr_log_oom(enum log_severity severity, enum log_source source,
   }
 
   /* generate OOM log string */
-  _logbuffer.buf[0] = 0;
-  strscat(_logbuffer.buf, LOG_SEVERITY_NAMES[severity], _logbuffer.size);
-  strscat(_logbuffer.buf, " ", _logbuffer.size);
-  strscat(_logbuffer.buf, LOG_SOURCE_NAMES[source], _logbuffer.size);
-  strscat(_logbuffer.buf, " ", _logbuffer.size);
-  strscat(_logbuffer.buf, file, _logbuffer.size);
-  strscat(_logbuffer.buf, " ", _logbuffer.size);
+  ptr = abuf_getptr(&_logbuffer);
+  ptr[0] = 0;
+  strscat(ptr, LOG_SEVERITY_NAMES[severity], abuf_getmax(&_logbuffer));
+  strscat(ptr, " ", abuf_getmax(&_logbuffer));
+  strscat(ptr, LOG_SOURCE_NAMES[source], abuf_getmax(&_logbuffer));
+  strscat(ptr, " ", abuf_getmax(&_logbuffer));
+  strscat(ptr, file, abuf_getmax(&_logbuffer));
+  strscat(ptr, " ", abuf_getmax(&_logbuffer));
 
-  j = strlen(_logbuffer.buf) + 4;
+  j = strlen(ptr) + 4;
 
   for (i=0; i < 5; i++) {
-    _logbuffer.buf[j-i] = '0' + (line % 10);
+    ptr[j-i] = '0' + (line % 10);
     line /= 10;
   }
-  _logbuffer.buf[++j] = ' ';
-  _logbuffer.buf[++j] = 0;
+  ptr[++j] = ' ';
+  ptr[++j] = 0;
 
-  strscat(_logbuffer.buf, OUT_OF_MEMORY_ERROR, _logbuffer.size);
+  strscat(ptr, OUT_OF_MEMORY_ERROR, abuf_getmax(&_logbuffer));
 
   param.severity = severity;
   param.source = source;
   param.no_header = true;
   param.file = file;
   param.line = line;
-  param.buffer = _logbuffer.buf;
+  param.buffer = ptr;
   param.timeLength = 0;
   param.prefixLength = 0;
 
index 299d3cd..18df42d 100644 (file)
@@ -155,7 +155,7 @@ olsr_packet_send(struct olsr_packet_socket *pktsocket, union netaddr_socket *rem
   struct netaddr_str buf;
 #endif
 
-  if (pktsocket->out.len == 0) {
+  if (abuf_getlen(&pktsocket->out) == 0) {
     /* no backlog of outgoing packets, try to send directly */
     result = os_sendto(pktsocket->scheduler_entry.fd, data, length, remote);
     if (result > 0) {
@@ -218,7 +218,7 @@ _cb_packet_event(int fd, void *data, bool event_read, bool event_write) {
     }
   }
 
-  if (event_write && pktsocket->out.len > 0) {
+  if (event_write && abuf_getlen(&pktsocket->out) > 0) {
     /* handle outgoing data */
 
     /* pointer to remote socket */
@@ -248,7 +248,7 @@ _cb_packet_event(int fd, void *data, bool event_read, bool event_write) {
     abuf_pull(&pktsocket->out, sizeof(*skt) + 2 + length);
   }
 
-  if (pktsocket->out.len == 0) {
+  if (abuf_getlen(&pktsocket->out) == 0) {
     /* nothing left to send, disable outgoing events */
     olsr_socket_set_write(&pktsocket->scheduler_entry, false);
   }
index 20a729d..0da3f83 100644 (file)
@@ -405,14 +405,14 @@ _open_plugin(const char *filename) {
     abuf_clear(&abuf);
     abuf_templatef(&abuf, dlopen_patterns[i], dlopen_values, table, indexCount);
 
-    OLSR_DEBUG(LOG_PLUGINLOADER, "Trying to load library: %s", abuf.buf);
-    result = dlopen(abuf.buf, RTLD_NOW);
+    OLSR_DEBUG(LOG_PLUGINLOADER, "Trying to load library: %s", abuf_getptr(&abuf));
+    result = dlopen(abuf_getptr(&abuf), RTLD_NOW);
   }
   if (result == NULL) {
     OLSR_WARN(LOG_PLUGINLOADER, "Loading of plugin %s failed.\n", filename);
   }
   else {
-    OLSR_INFO(LOG_PLUGINLOADER, "Loading plugin %s from %s\n", filename, abuf.buf);
+    OLSR_INFO(LOG_PLUGINLOADER, "Loading plugin %s from %s\n", filename, abuf_getptr(&abuf));
   }
 
   abuf_free(&abuf);
index 7038ad2..bf6c83b 100644 (file)
@@ -221,7 +221,7 @@ olsr_stream_remove(struct olsr_stream_socket *stream_socket, bool force) {
   }
 
   list_for_each_element_safe(&stream_socket->session, session, node, ptr) {
-    if (force || (session->out.len == 0 && !session->busy)) {
+    if (force || (abuf_getlen(&session->out) == 0 && !session->busy)) {
       /* close everything that doesn't need to send data anymore */
       olsr_stream_close(session, force);
     }
@@ -638,7 +638,7 @@ _cb_parse_connection(int fd, void *data, bool event_read, bool event_write) {
         /* out of memory */
         OLSR_WARN(LOG_SOCKET_STREAM, "Out of memory for comport session input buffer");
         session->state = STREAM_SESSION_CLEANUP;
-      } else if (session->in.len > s_sock->config.maximum_input_buffer) {
+      } else if (abuf_getlen(&session->in) > s_sock->config.maximum_input_buffer) {
         /* input buffer overflow */
         if (s_sock->config.create_error) {
           s_sock->config.create_error(session, STREAM_REQUEST_TOO_LARGE);
@@ -661,15 +661,15 @@ _cb_parse_connection(int fd, void *data, bool event_read, bool event_write) {
   }
 
   if (session->state == STREAM_SESSION_ACTIVE && s_sock->config.receive_data != NULL
-      && (session->in.len > 0 || session->send_first)) {
+      && (abuf_getlen(&session->in) > 0 || session->send_first)) {
     session->state = s_sock->config.receive_data(session);
     session->send_first = false;
   }
 
   /* send data if necessary */
-  if (session->state != STREAM_SESSION_CLEANUP && session->out.len > 0) {
+  if (session->state != STREAM_SESSION_CLEANUP && abuf_getlen(&session->out) > 0) {
     if (event_write) {
-      len = send(fd, session->out.buf, session->out.len, 0);
+      len = send(fd, abuf_getptr(&session->out), abuf_getlen(&session->out), 0);
 
       if (len > 0) {
         OLSR_DEBUG(LOG_SOCKET_STREAM, "  send returned %d\n", len);
@@ -687,7 +687,7 @@ _cb_parse_connection(int fd, void *data, bool event_read, bool event_write) {
     }
   }
 
-  if (session->out.len == 0) {
+  if (abuf_getlen(&session->out) == 0) {
     /* nothing to send anymore */
     OLSR_DEBUG(LOG_SOCKET_STREAM, "  deactivating output in scheduler\n");
     olsr_socket_set_write(&session->scheduler_entry, false);
index 8e00913..842ced1 100644 (file)
@@ -321,25 +321,25 @@ _cb_telnet_receive_data(struct olsr_stream_session *session) {
   telnet_session = (struct olsr_telnet_session *)session;
 
   /* loop over input */
-  while (session->in.len > 0) {
+  while (abuf_getlen(&session->in) > 0) {
     char *para = NULL, *cmd = NULL, *next = NULL;
 
     /* search for end of line */
-    eol = memchr(session->in.buf, '\n', session->in.len);
+    eol = memchr(abuf_getptr(&session->in), '\n', abuf_getlen(&session->in));
 
     if (eol == NULL) {
       break;
     }
 
     /* terminate line with a 0 */
-    if (eol != session->in.buf && eol[-1] == '\r') {
+    if (eol != abuf_getptr(&session->in) && eol[-1] == '\r') {
       eol[-1] = 0;
     }
     *eol++ = 0;
 
     /* handle line */
-    OLSR_DEBUG(LOG_TELNET, "Interactive console: %s\n", session->in.buf);
-    cmd = &session->in.buf[0];
+    OLSR_DEBUG(LOG_TELNET, "Interactive console: %s\n", abuf_getptr(&session->in));
+    cmd = abuf_getptr(&session->in);
     processedCommand = true;
 
     /* apply default command */
@@ -353,7 +353,7 @@ _cb_telnet_receive_data(struct olsr_stream_session *session) {
       chainCommands = true;
     }
     while (cmd) {
-      len = session->out.len;
+      len = abuf_getlen(&session->out);
 
       /* handle difference between multicommand and singlecommand mode */
       if (chainCommands) {
@@ -386,12 +386,12 @@ _cb_telnet_receive_data(struct olsr_stream_session *session) {
           case TELNET_RESULT_CONTINOUS:
             break;
           case TELNET_RESULT_INTERNAL_ERROR:
-            session->out.len = len;
+            abuf_setlen(&session->out, len);
             abuf_appendf(&session->out,
                 "Error in autobuffer during command '%s'.\n", cmd);
             break;
           case TELNET_RESULT_UNKNOWN_COMMAND:
-            session->out.len = len;
+            abuf_setlen(&session->out, len);
             abuf_appendf(&session->out, "Error, unknown command '%s'\n", cmd);
             break;
           case TELNET_RESULT_QUIT:
@@ -406,9 +406,9 @@ _cb_telnet_receive_data(struct olsr_stream_session *session) {
     }
 
     /* remove line from input buffer */
-    abuf_pull(&session->in, eol - session->in.buf);
+    abuf_pull(&session->in, eol - abuf_getptr(&session->in));
 
-    if (session->in.buf[0] == '/') {
+    if (abuf_getptr(&session->in)[0] == '/') {
       /* end of multiple command line */
       return STREAM_SESSION_SEND_AND_QUIT;
     }
index 5a0b59a..84a7317 100644 (file)
@@ -283,8 +283,9 @@ os_system_netlink_remove(struct os_system_netlink *nl) {
  * Add a netlink message to the outgoign queue of a handler
  * @param nl pointer to netlink handler
  * @param nl_hdr pointer to netlink message
+ * @return sequence number used for message
  */
-void
+int
 os_system_netlink_send(struct os_system_netlink *nl,
     struct nlmsghdr *nl_hdr) {
   nl->seq_used++;
@@ -296,6 +297,7 @@ os_system_netlink_send(struct os_system_netlink *nl,
 
   /* trigger write */
   olsr_socket_set_write(&nl->socket, true);
+  return nl->seq_used;
 }
 
 /**
@@ -360,8 +362,8 @@ _flush_netlink_buffer(struct os_system_netlink *nl) {
   olsr_timer_set(&nl->timeout, OS_SYSTEM_NETLINK_TIMEOUT*10, 0, nl, _netlink_timer);
 
   /* send outgoing message */
-  _netlink_send_iov[0].iov_base = nl->out.buf;
-  _netlink_send_iov[0].iov_len = nl->out.len;
+  _netlink_send_iov[0].iov_base = abuf_getptr(&nl->out);
+  _netlink_send_iov[0].iov_len = abuf_getlen(&nl->out);
 
   if ((ret = sendmsg(nl->socket.fd, &_netlink_send_msg, 0)) <= 0) {
     OLSR_WARN(LOG_OS_SYSTEM,
@@ -370,12 +372,10 @@ _flush_netlink_buffer(struct os_system_netlink *nl) {
   }
   else {
     OLSR_DEBUG(LOG_OS_SYSTEM, "Sent %zd/%zu bytes for netlink seqno: %d",
-        ret, nl->out.len, nl->seq_used);
+        ret, abuf_getlen(&nl->out), nl->seq_used);
     nl->seq_sent = nl->seq_used;
     abuf_clear(&nl->out);
-  }
 
-  if (nl->out.len == 0) {
     olsr_socket_set_write(&nl->socket, false);
   }
 }
index f4c55a7..595b0e3 100644 (file)
@@ -42,13 +42,13 @@ struct os_system_netlink {
   struct olsr_timer_entry *timeout;
 };
 
-int os_system_netlink_add(struct os_system_netlink *,
+EXPORT int os_system_netlink_add(struct os_system_netlink *,
     int protocol, uint32_t multicast);
-void os_system_netlink_remove(struct os_system_netlink *);
-void os_system_netlink_send(struct os_system_netlink *fd,
+EXPORT void os_system_netlink_remove(struct os_system_netlink *);
+EXPORT int os_system_netlink_send(struct os_system_netlink *fd,
     struct nlmsghdr *nl_hdr);
 
-int os_system_netlink_addreq(struct nlmsghdr *n,
+EXPORT int os_system_netlink_addreq(struct nlmsghdr *n,
     int type, const void *data, int len);
 
 static INLINE int
index fdc1eef..49f446f 100644 (file)
@@ -580,12 +580,12 @@ parse_commandline(int argc, char **argv, bool reload_only) {
     }
   }
 
-  if (log.len > 0) {
+  if (abuf_getlen(&log) > 0) {
     if (reload_only) {
-      OLSR_WARN(LOG_MAIN, "Cannot reload configuration.\n%s", log.buf);
+      OLSR_WARN(LOG_MAIN, "Cannot reload configuration.\n%s", abuf_getptr(&log));
     }
     else {
-      fputs(log.buf, return_code == 0 ? stdout : stderr);
+      fputs(abuf_getptr(&log), return_code == 0 ? stdout : stderr);
     }
   }
 
@@ -613,8 +613,8 @@ display_schema(void) {
     return_code = -1;
   }
 
-  if (log.len > 0) {
-    fputs(log.buf, stdout);
+  if (abuf_getlen(&log) > 0) {
+    fputs(abuf_getptr(&log), stdout);
   }
 
   abuf_free(&log);