More doxygen comments and some code cleanup
authorHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Mon, 10 Oct 2011 06:42:14 +0000 (08:42 +0200)
committerHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Mon, 10 Oct 2011 06:42:14 +0000 (08:42 +0200)
21 files changed:
src/core/olsr_cfg.c
src/core/olsr_cfg.h
src/core/olsr_clock.c
src/core/olsr_http.c
src/core/olsr_logging.c
src/core/olsr_logging_cfg.c
src/core/olsr_memcookie.c
src/core/olsr_memcookie.h
src/core/olsr_netaddr_acl.c
src/core/olsr_netaddr_acl.h
src/core/olsr_packet_socket.c
src/core/olsr_plugins.c
src/core/olsr_plugins.h
src/core/olsr_socket.c
src/core/olsr_socket.h
src/core/olsr_stream_socket.c
src/core/olsr_telnet.c
src/core/olsr_telnet.h
src/core/olsr_timer.c
src/core/olsr_timer.h
src/olsr.c

index 033e896..e5919d4 100644 (file)
@@ -53,7 +53,7 @@
 #include "olsr.h"
 
 /* static prototypes */
-static int _validate_global(struct cfg_schema_section *, const char *section_name,
+static int _cb_validate_global(struct cfg_schema_section *, const char *section_name,
     struct cfg_named_section *, struct autobuf *);
 
 /* global config */
@@ -72,7 +72,7 @@ OLSR_SUBSYSTEM_STATE(olsr_cfg_state);
 /* define global configuration template */
 static struct cfg_schema_section global_section = {
   .t_type = CFG_SECTION_GLOBAL,
-  .t_validate = _validate_global,
+  .t_validate = _cb_validate_global,
 };
 
 static struct cfg_schema_entry global_entries[] = {
@@ -91,6 +91,7 @@ static struct cfg_schema_entry global_entries[] = {
 
 /**
  * Initializes the olsrd configuration subsystem
+ * @return -1 if an error happened, 0 otherwise
  */
 int
 olsr_cfg_init(void) {
@@ -267,6 +268,10 @@ apply_failed:
   return result;
 }
 
+/**
+ * Copy work-db into raw-db to roll back changes before commit.
+ * @return -1 if an error happened, 0 otherwise
+ */
 int
 olsr_cfg_rollback(void) {
   struct cfg_db *db;
@@ -288,6 +293,12 @@ olsr_cfg_rollback(void) {
   return 0;
 }
 
+/**
+ * Update binary copy of global config section
+ * @param raw true if data shall be taken from raw database,
+ *   false if work-db should be taken as a source.
+ * @return -1 if an error happened, 0 otherwise
+ */
 int
 olsr_cfg_update_globalcfg(bool raw) {
   struct cfg_named_section *named;
@@ -304,7 +315,7 @@ olsr_cfg_update_globalcfg(bool raw) {
  * @return -1 if an error happened, 0 otherwise
  */
 int
-olsr_cfg_create_new_rawdb(void) {
+olsr_cfg_clear_rawdb(void) {
   struct cfg_db *db;
 
   /* remember old db */
@@ -324,6 +335,9 @@ olsr_cfg_create_new_rawdb(void) {
   return 0;
 }
 
+/**
+ * @return pointer to configuration instance object
+ */
 struct cfg_instance *
 olsr_cfg_get_instance(void) {
   return &_olsr_cfg_instance;
@@ -371,7 +385,7 @@ olsr_cfg_get_delta(void) {
  * @return -1 if section is not valid, 0 otherwise
  */
 static int
-_validate_global(struct cfg_schema_section *schema __attribute__((unused)),
+_cb_validate_global(struct cfg_schema_section *schema __attribute__((unused)),
     const char *section_name __attribute__((unused)),
     struct cfg_named_section *section, struct autobuf *log) {
   struct olsr_config_global config;
index 9e53213..c23fee5 100644 (file)
@@ -70,7 +70,7 @@ int olsr_cfg_rollback(void);
 
 /* do not export this to plugins */
 int olsr_cfg_update_globalcfg(bool);
-int olsr_cfg_create_new_rawdb(void);
+int olsr_cfg_clear_rawdb(void);
 
 EXPORT struct cfg_instance *olsr_cfg_get_instance(void);
 EXPORT struct cfg_db *olsr_cfg_get_db(void);
index e59caa8..41fc85c 100644 (file)
@@ -62,6 +62,7 @@ static int olsr_get_timezone(void);
 
 /**
  * Initialize olsr clock system
+ * @return -1 if an error happened, 0 otherwise
  */
 int
 olsr_clock_init(void) {
@@ -92,6 +93,7 @@ olsr_clock_cleanup(void) {
 
 /**
  * Update the internal clock to current system time
+ * @return -1 if an error happened, 0 otherwise
  */
 int
 olsr_clock_update(void)
@@ -181,106 +183,12 @@ olsr_clock_isPast(uint32_t absolute)
   return now_times - absolute <= (1u << 31);
 }
 
-/**
- *Function that converts a double to a mantissa/exponent
- *product as described in RFC3626:
- *
- * value = C*(1+a/16)*2^b [in seconds]
- *
- *  where a is the integer represented by the four highest bits of the
- *  field and b the integer represented by the four lowest bits of the
- *  field.
- *
- *@param interval the time interval to process
- *
- *@return a 8-bit mantissa/exponent product
- */
-uint8_t
-olsr_clock_encode_olsrv1(const uint32_t interval)
-{
-  uint8_t a = 0, b = 0;                /* Underflow defaults */
-
-  /* It is sufficent to compare the integer part since we test on >=.
-   * So we have now only a floating point division and the rest of the loop
-   * are only integer operations.
-   *
-   * const unsigned int unscaled_interval = interval / VTIME_SCALE_FACTOR;
-   *
-   * VTIME_SCALE_FACTOR = 1/16
-   *
-   * => unscaled_interval = interval(ms) / 1000 * 16
-   *                      = interval(ms) / 125 * 2
-   */
-
-  unsigned unscaled_interval = interval;
-  while (unscaled_interval >= 62) {
-    unscaled_interval >>= 1;
-    b++;
-  }
-
-  if (0 < b) {
-    if (15 < --b) {
-      a = 15;                   /* Overflow defaults */
-      b = 15;
-    } else {
-      a = (interval >> (b + 2)) - 15;
-    }
-  }
-
-  return (a << 4) + b;
-}
-
-/**
- * Function for converting a mantissa/exponent 8bit value back
- * to double as described in RFC3626:
- *
- * value = C*(1+a/16)*2^b [in seconds]
- *
- *  where a is the integer represented by the four highest bits of the
- *  field and b the integer represented by the four lowest bits of the
- *  field.
- *
- * me is the 8 bit mantissa/exponent value
- *
- * To avoid expensive floating maths, we transform the equation:
- *     value = C * (1 + a / 16) * 2^b
- * first, we make an int addition from the floating point addition:
- *     value = C * ((16 + a) / 16) * 2^b
- * then we get rid of a pair of parentheses
- *     value = C * (16 + a) / 16 * 2^b
- * and now we make an int multiplication from the floating point one
- *     value = C * (16 + a) * 2^b / 16
- * so that we can make a shift from the multiplication
- *     value = C * ((16 + a) << b) / 16
- * and sionce C and 16 are constants
- *     value = ((16 + a) << b) * C / 16
- *
- * VTIME_SCALE_FACTOR = 1/16
- *
- * =>  value(ms) = ((16 + a) << b) / 256 * 1000
- *
- * 1. case: b >= 8
- *           = ((16 + a) << (b-8)) * 1000
- *
- * 2. case: b <= 8
- *           = ((16 + a) * 1000) >> (8-b)
- */
-uint32_t
-olsr_clock_decode_olsrv1(const uint8_t me)
-{
-  const uint8_t a = me >> 4;
-  const uint8_t b = me & 0x0F;
-
-  if (b >= 8) {
-    return ((16 + a) << (b - 8)) * 1000;
-  }
-  assert(me == olsr_clock_encode_olsrv1(((16 + a) * 1000) >> (8 - b)));
-  return ((16 + a) * 1000) >> (8 - b);
-}
-
 /**
  * converts an unsigned integer value into a string representation
  * (divided by 1000)
+ * @param buffer pointer to time string buffer
+ * @param t current OLSR time
+ * @return pointer to time string
  */
 char *
 olsr_clock_to_string(struct millitxt_buf *buffer, uint32_t t) {
@@ -291,6 +199,8 @@ olsr_clock_to_string(struct millitxt_buf *buffer, uint32_t t) {
 /**
  * converts a floating point text into a unsigned integer representation
  * (multiplied by 1000)
+ * @param txt pointer to text representation
+ * @return integer representation
  */
 uint32_t olsr_clock_parse_string(char *txt) {
   uint32_t t = 0;
@@ -324,7 +234,7 @@ uint32_t olsr_clock_parse_string(char *txt) {
  * Format an absolute wallclock system time string.
  * May be called upto 4 times in a single printf() statement.
  * Displays microsecond resolution.
- *
+ * @param buf pointer to timeval buffer
  * @return buffer to a formatted system time string.
  */
 const char *
@@ -349,26 +259,26 @@ olsr_clock_getWallclockString(struct timeval_buf *buf)
  * Displays millisecond resolution.
  *
  * @param buf string buffer for creating output
- * @param clk absolute timestamp
+ * @param clk OLSR timestamp
  * @return buffer to a formatted system time string.
  */
 const char *
 olsr_clock_toClockString(struct timeval_buf *buf, uint32_t clk)
 {
-  unsigned int msec = clk % 1000;
-  unsigned int sec = clk / 1000;
+  unsigned int msec = clk % MSEC_PER_SEC;
+  unsigned int sec = clk / MSEC_PER_SEC;
 
   snprintf(buf->buf, sizeof(buf),
-      "%02u:%02u:%02u.%03u", sec / 3600, (sec % 3600) / 60, (sec % 60), (msec % MSEC_PER_SEC));
+      "%02u:%02u:%02u.%03u", sec / 3600, (sec % 3600) / 60, (sec % 60), msec);
 
   return buf->buf;
 }
 
 /**
- * Returns the difference between gmt and local time in seconds.
  * Use gmtime() and localtime() to keep things simple.
+ * taken and modified from www.tcpdump.org.
  *
- * taken and slightly modified from www.tcpdump.org.
+ * @return difference between gmt and local time in seconds.
  */
 static int
 olsr_get_timezone(void)
@@ -377,10 +287,20 @@ olsr_get_timezone(void)
   static int time_diff = OLSR_TIMEZONE_UNINITIALIZED;
   if (time_diff == OLSR_TIMEZONE_UNINITIALIZED) {
     int dir;
-    const time_t t = time(NULL);
-    const struct tm gmt = *gmtime(&t);
-    const struct tm *loc = localtime(&t);
+    struct timeval tv;
+    time_t t;
+    struct tm gmt;
+    struct tm *loc;
+
+    if (os_gettimeofday(&tv, 0)) {
+      OLSR_WARN(LOG_TIMER, "Cannot read internal clock: %s (%d)",
+          strerror(errno), errno);
+      return 0;
+    }
 
+    t = tv.tv_sec;
+    gmt = *gmtime(&t);
+    loc = localtime(&t);
     time_diff = (loc->tm_hour - gmt.tm_hour) * 60 * 60 + (loc->tm_min - gmt.tm_min) * 60;
 
     /*
@@ -397,10 +317,3 @@ olsr_get_timezone(void)
   }
   return time_diff;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 4a6dfbe..c433c11 100644 (file)
@@ -61,7 +61,7 @@ static struct olsr_http_handler *_get_site_handler(const char *uri);
 static const char *_get_headertype_string(enum olsr_http_result type);
 static void _create_http_header(struct olsr_stream_session *session,
     enum olsr_http_result code, const char *content_type);
-static int _parse_http_header(char *message, size_t message_len,
+static int _parse_http_header(char *header_data, size_t header_len,
     struct olsr_http_session *header);
 static size_t _parse_query_string(char *s,
     char **name, char **value, size_t count);
@@ -344,6 +344,12 @@ _cb_receive_data(struct olsr_stream_session *session) {
   return STREAM_SESSION_SEND_AND_QUIT;
 }
 
+/**
+ * Check if an incoming session is authorized to view a http site.
+ * @param handler pointer to site handler
+ * @param session pointer to http session.
+ * @return true if authorized, false if not
+ */
 static bool
 _auth_okay(struct olsr_http_handler *handler,
     struct olsr_http_session *session) {
@@ -524,48 +530,48 @@ _create_http_header(struct olsr_stream_session *session,
 
 /**
  * Parse a HTTP header
- * @param message pointer to header data
- * @param message_len length of header data
+ * @param header_data pointer to header data
+ * @param header_len length of header data
  * @param header pointer to object to store the results
  * @return 0 if http header was correct, -1 if an error happened
  */
 static int
-_parse_http_header(char *message, size_t message_len,
+_parse_http_header(char *header_data, size_t header_len,
     struct olsr_http_session *header) {
   size_t header_index;
 
-  assert(message);
+  assert(header_data);
   assert(header);
 
   memset(header, 0, sizeof(struct olsr_http_session));
-  header->method = message;
+  header->method = header_data;
 
   while(true) {
-    if (message_len < 2) {
+    if (header_len < 2) {
       goto unexpected_end;
     }
 
-    if (*message == ' ' && header->http_version == NULL) {
-      *message = '\0';
+    if (*header_data == ' ' && header->http_version == NULL) {
+      *header_data = '\0';
 
       if (header->request_uri == NULL) {
-        header->request_uri = &message[1];
+        header->request_uri = &header_data[1];
       }
       else if (header->http_version == NULL) {
-        header->http_version = &message[1];
+        header->http_version = &header_data[1];
       }
     }
-    else if (*message == '\r') {
-      *message = '\0';
+    else if (*header_data == '\r') {
+      *header_data = '\0';
     }
-    else if (*message == '\n') {
-      *message = '\0';
+    else if (*header_data == '\n') {
+      *header_data = '\0';
 
-      message++; message_len--;
+      header_data++; header_len--;
       break;
     }
 
-    message++; message_len--;
+    header_data++; header_len--;
   }
 
   if (header->http_version == NULL) {
@@ -573,17 +579,17 @@ _parse_http_header(char *message, size_t message_len,
   }
 
   for(header_index = 0; true; header_index++) {
-    if (message_len < 1) {
+    if (header_len < 1) {
       goto unexpected_end;
     }
 
-    if (*message == '\n') {
+    if (*header_data == '\n') {
       break;
     }
-    else if (*message == '\r') {
-      if (message_len < 2) return true;
+    else if (*header_data == '\r') {
+      if (header_len < 2) return true;
 
-      if (message[1] == '\n') {
+      if (header_data[1] == '\n') {
         break;
       }
     }
@@ -592,93 +598,93 @@ _parse_http_header(char *message, size_t message_len,
       goto too_many_fields;
     }
 
-    header->header_name[header_index] = message;
+    header->header_name[header_index] = header_data;
 
     while(true) {
-      if (message_len < 1) {
+      if (header_len < 1) {
         goto unexpected_end;
       }
 
-      if (*message == ':') {
-        *message = '\0';
+      if (*header_data == ':') {
+        *header_data = '\0';
 
-        message++; message_len--;
+        header_data++; header_len--;
         break;
       }
-      else if (*message == ' ' || *message == '\t') {
-        *message = '\0';
+      else if (*header_data == ' ' || *header_data == '\t') {
+        *header_data = '\0';
       }
-      else if (*message == '\n' || *message == '\r') {
+      else if (*header_data == '\n' || *header_data == '\r') {
         goto unexpected_end;
       }
 
-      message++; message_len--;
+      header_data++; header_len--;
     }
 
     while(true) {
-      if (message_len < 1) {
+      if (header_len < 1) {
         goto unexpected_end;
       }
 
       if (header->header_value[header_index] == NULL) {
-        if (*message != ' ' && *message != '\t') {
-          header->header_value[header_index] = message;
+        if (*header_data != ' ' && *header_data != '\t') {
+          header->header_value[header_index] = header_data;
         }
       }
 
-      if (*message == '\n') {
-        if (message_len < 2) {
+      if (*header_data == '\n') {
+        if (header_len < 2) {
           goto unexpected_end;
         }
 
-        if (message[1] == ' ' || message[1] == '\t') {
-          *message = ' ';
-          message[1] = ' ';
+        if (header_data[1] == ' ' || header_data[1] == '\t') {
+          *header_data = ' ';
+          header_data[1] = ' ';
 
-          message += 2; message_len -= 2;
+          header_data += 2; header_len -= 2;
           continue;
         }
 
-        *message = '\0';
+        *header_data = '\0';
 
         if (header->header_value[header_index] == NULL) {
-          header->header_value[header_index] = message;
+          header->header_value[header_index] = header_data;
         }
 
-        message++; message_len--;
+        header_data++; header_len--;
         break;
       }
-      else if (*message == '\r') {
-        if (message_len < 2) {
+      else if (*header_data == '\r') {
+        if (header_len < 2) {
           goto unexpected_end;
         }
 
-        if (message[1] == '\n') {
-          if (message_len < 3) {
+        if (header_data[1] == '\n') {
+          if (header_len < 3) {
             goto unexpected_end;
           }
 
-          if (message[2] == ' ' || message[2] == '\t') {
-            *message = ' ';
-            message[1] = ' ';
-            message[2] = ' ';
+          if (header_data[2] == ' ' || header_data[2] == '\t') {
+            *header_data = ' ';
+            header_data[1] = ' ';
+            header_data[2] = ' ';
 
-            message += 3; message_len -= 3;
+            header_data += 3; header_len -= 3;
             continue;
           }
 
-          *message = '\0';
+          *header_data = '\0';
 
           if (header->header_value[header_index] == NULL) {
-            header->header_value[header_index] = message;
+            header->header_value[header_index] = header_data;
           }
 
-          message += 2; message_len -= 2;
+          header_data += 2; header_len -= 2;
           break;
         }
       }
 
-      message++; message_len--;
+      header_data++; header_len--;
     }
   }
 
index 832257a..2078f23 100644 (file)
@@ -74,6 +74,8 @@ OLSR_SUBSYSTEM_STATE(olsr_logging_state);
 
 /**
  * Initialize logging system
+ * @param def_severity default severity level
+ * @return -1 if an error happened, 0 otherwise
  */
 int
 olsr_log_init(enum log_severity def_severity)
@@ -88,7 +90,7 @@ olsr_log_init(enum log_severity def_severity)
 
   if (abuf_init(&logbuffer, 4096)) {
     fputs("Not enough memory for logging buffer\n", stderr);
-    olsr_logging_state--;
+    olsr_subsystem_cleanup(&olsr_logging_state);
     return -1;
   }
 
@@ -231,7 +233,7 @@ olsr_log(enum log_severity severity, enum log_source source, bool no_header,
   tm_ptr = localtime((time_t *) & timeval.tv_sec);
   now = *tm_ptr;
 
-  /* generate log string (insert file/line in DEBUG mode) */
+  /* generate log string */
   abuf_clear(&logbuffer);
   if (!no_header) {
     p1 = abuf_appendf(&logbuffer, "%d:%02d:%02d.%03ld ",
@@ -319,6 +321,8 @@ olsr_log_oom(enum log_severity severity, enum log_source source,
   }
 }
 
+// TODO: clean up this interface
+
 /**
  * Logger for stderr output
  * @param entry
index 92b658e..3f7b411 100644 (file)
@@ -65,7 +65,7 @@
 #define LOG_FILE_ENTRY   "file"
 
 /* prototype for configuration change handler */
-static void _olsr_logcfg_apply(void);
+static void _cb_logcfg_apply(void);
 static void _apply_log_setting(struct cfg_named_section *named,
     const char *entry_name, enum log_severity severity);
 
@@ -91,8 +91,8 @@ static struct cfg_schema_entry logging_entries[] = {
 };
 
 static struct cfg_delta_handler logcfg_delta_handler = {
-//  .s_type = LOG_SECTION,
-  .callback = _olsr_logcfg_apply,
+  .s_type = LOG_SECTION,
+  .callback = _cb_logcfg_apply,
 };
 
 static enum log_source *debug_lvl_1 = NULL;
@@ -319,10 +319,8 @@ _apply_log_setting(struct cfg_named_section *named,
  * Wrapper for configuration delta handling
  */
 static void
-_olsr_logcfg_apply(void) {
+_cb_logcfg_apply(void) {
   if (olsr_logcfg_apply(olsr_cfg_get_db())) {
-    if (config_global.failfast) {
-      olsr_exit();
-    }
+    // TODO: open logging file failed, decide what to do
   }
 }
index 21b387f..6ef9e70 100644 (file)
@@ -62,7 +62,7 @@ OLSR_SUBSYSTEM_STATE(olsr_memcookie_state);
  * @return number of bytes including padding for alignment
  */
 static inline size_t
-calc_aligned_size(size_t size) {
+_calc_aligned_size(size_t size) {
   static const size_t add = sizeof(size_t) * 2 - 1;
   static const size_t mask = ~(sizeof(size_t)*2 - 1);
 
@@ -98,7 +98,7 @@ void
 olsr_memcookie_init(void) {
   /* check size of memory prefix */
   assert (sizeof(struct olsr_memory_prefix)
-      == calc_aligned_size(sizeof(struct olsr_memory_prefix)));
+      == _calc_aligned_size(sizeof(struct olsr_memory_prefix)));
 
   if (olsr_subsystem_init(&olsr_memcookie_state))
     return;
@@ -146,7 +146,7 @@ olsr_memcookie_add(const char *cookie_name, size_t size)
   ci->ci_name = cookie_name;
   ci->ci_node.key = ci->ci_name;
   ci->ci_size = size;
-  ci->ci_custom_offset = sizeof(struct olsr_memory_prefix) + calc_aligned_size(size);
+  ci->ci_custom_offset = sizeof(struct olsr_memory_prefix) + _calc_aligned_size(size);
   ci->ci_min_free_count = COOKIE_FREE_LIST_THRESHOLD;
 
   /* no custom data at this point */
@@ -352,7 +352,7 @@ olsr_memcookie_add_custom(const char *memcookie_name, const char *name, size_t s
     return NULL;
   }
   custom_cookie->name = name;
-  custom_cookie->size = calc_aligned_size(size);
+  custom_cookie->size = _calc_aligned_size(size);
   custom_cookie->init = init;
   custom_cookie->move = move;
 
@@ -481,11 +481,3 @@ olsr_memcookie_remove_custom(const char*memcookie_name, struct olsr_memcookie_cu
   list_remove(&custom->node);
   free (custom);
 }
-
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index f6b5c9e..227e340 100644 (file)
@@ -46,8 +46,6 @@
 #include "common/list.h"
 #include "common/avl.h"
 
-extern struct avl_tree EXPORT(olsr_cookie_tree);
-
 /*
  * This is a cookie. A cookie is a tool aimed for olsrd developers.
  * It is used for tracking resource usage in the system and also
@@ -140,6 +138,8 @@ struct olsr_memory_prefix {
 
 #define COOKIE_FREE_LIST_THRESHOLD 10   /* Blocks / Percent  */
 
+extern struct avl_tree EXPORT(olsr_cookie_tree);
+
 /* Externals. */
 void olsr_memcookie_init(void);
 void olsr_memcookie_cleanup(void);
@@ -191,10 +191,3 @@ olsr_memcookie_set_minfree(struct olsr_memcookie_info *ci, uint32_t min_free)
 }
 
 #endif /* _OLSR_MEMCOOKIE_H */
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 274590c..af7b16b 100644 (file)
@@ -22,13 +22,32 @@ static const char *_FIRST_ACCEPT = "first_accept";
 static const char *_DEFAULT_ACCEPT = "default_accept";
 static const char *_DEFAULT_REJECT = "default_reject";
 
+/**
+ * Initialize an ACL object. It will contain no addresses on both
+ * accept and reject list and will be "accept first", "reject default".
+ * @param acl pointer to ACL
+ */
 void
 olsr_acl_add(struct olsr_netaddr_acl *acl) {
   memset(acl, 0, sizeof(acl));
 }
 
+void
+olsr_acl_remove(struct olsr_netaddr_acl *acl) {
+  free(acl->accept);
+  free(acl->reject);
+
+  memset(acl, 0, sizeof(*acl));
+}
+
+/**
+ * Initialize an ACL with a list of string parameters.
+ * @param acl pointer to uninitialized ACL
+ * @param array pointer to array of text arguments for ACL
+ * @return -1 if an error happened, 0 otherwise
+ */
 int
-olsr_acl_from_cfg_entry(struct olsr_netaddr_acl *acl, struct strarray *array) {
+olsr_acl_from_strarray(struct olsr_netaddr_acl *acl, struct strarray *array) {
   size_t accept_count, reject_count;
   char *ptr;
   accept_count = 0;
@@ -93,20 +112,16 @@ olsr_acl_from_cfg_entry(struct olsr_netaddr_acl *acl, struct strarray *array) {
   return 0;
 
 from_entry_error:
-  free(acl->accept);
-  free(acl->reject);
-  memset(acl, 0, sizeof(*acl));
+  olsr_acl_remove(acl);
   return -1;
 }
 
-void
-olsr_acl_remove(struct olsr_netaddr_acl *acl) {
-  free(acl->accept);
-  free(acl->reject);
-
-  memset(acl, 0, sizeof(*acl));
-}
-
+/**
+ * Copy one ACL to another one.
+ * @param to pointer to destination ACL
+ * @param from pointer to source ACL
+ * @return -1 if an error happened, 0 otherwise
+ */
 int
 olsr_acl_copy(struct olsr_netaddr_acl *to, struct olsr_netaddr_acl *from) {
   olsr_acl_remove(to);
@@ -130,6 +145,12 @@ olsr_acl_copy(struct olsr_netaddr_acl *to, struct olsr_netaddr_acl *from) {
   return 0;
 }
 
+/**
+ * Check if an address is accepted by an ACL
+ * @param acl pointer to ACL
+ * @param addr pointer to address
+ * @return true if accepted, false otherwise
+ */
 bool
 olsr_acl_check_accept(struct olsr_netaddr_acl *acl, struct netaddr *addr) {
   if (acl->reject_first) {
@@ -152,8 +173,8 @@ olsr_acl_check_accept(struct olsr_netaddr_acl *acl, struct netaddr *addr) {
 }
 
 /**
- * Schema entry validator for access control lists
- * See CFG_VALIDATE_ACL_() macros
+ * Schema entry validator for access control lists.
+ * See CFG_VALIDATE_ACL_*() macros.
  * @param entry pointer to schema entry
  * @param section_name name of section type and name
  * @param value value of schema entry
@@ -182,6 +203,14 @@ olsr_acl_validate(const struct cfg_schema_entry *entry,
   return cfg_schema_validate_netaddr(entry, section_name, value, out);
 }
 
+/**
+ * Schema entry binary converter for ACL entries.
+ * See CFG_MAP_ACL_*() macros.
+ * @param s_entry pointer to schema entry.
+ * @param value pointer to value to configuration entry
+ * @param reference pointer to binary target
+ * @return -1 if an error happened, 0 otherwise
+ */
 int
 olsr_acl_tobin(const struct cfg_schema_entry *s_entry __attribute__((unused)),
     struct strarray *value, void *reference) {
@@ -192,9 +221,15 @@ olsr_acl_tobin(const struct cfg_schema_entry *s_entry __attribute__((unused)),
   free(ptr->accept);
   free(ptr->reject);
 
-  return olsr_acl_from_cfg_entry(ptr, value);
+  return olsr_acl_from_strarray(ptr, value);
 }
 
+/**
+ * Handle the four control text blocks for ACL initialization.
+ * @param acl pointer to ACL
+ * @param cmd pointer to control word
+ * @return -1 if not a control word, 0 if control world was applied
+ */
 static int
 _handle_control_cmd(struct olsr_netaddr_acl *acl, const char *cmd) {
   if (strcasecmp(cmd, _DEFAULT_ACCEPT) == 0) {
@@ -218,6 +253,12 @@ _handle_control_cmd(struct olsr_netaddr_acl *acl, const char *cmd) {
   return 0;
 }
 
+/**
+ * @param array pointer to array of addresses and networks
+ * @param length length of array
+ * @param addr pointer of address to be checked
+ * @return true if address is inside list of addresses and networks
+ */
 static bool
 _is_in_array(struct netaddr *array, size_t length, struct netaddr *addr) {
   size_t i;
index e9ca346..52e1e15 100644 (file)
@@ -41,7 +41,7 @@ struct olsr_netaddr_acl {
 };
 
 EXPORT void olsr_acl_add(struct olsr_netaddr_acl *);
-EXPORT int olsr_acl_from_cfg_entry(struct olsr_netaddr_acl *, struct strarray *);
+EXPORT int olsr_acl_from_strarray(struct olsr_netaddr_acl *, struct strarray *);
 EXPORT void olsr_acl_remove(struct olsr_netaddr_acl *);
 EXPORT int olsr_acl_copy(struct olsr_netaddr_acl *to, struct olsr_netaddr_acl *from);
 
index 6428594..7d0d2fc 100644 (file)
@@ -57,7 +57,7 @@ static char input_buffer[65536];
 /* remember if initialized or not */
 OLSR_SUBSYSTEM_STATE(olsr_packet_state);
 
-static void olsr_packet_event(int fd, void *data, enum olsr_sockethandler_flags flags);
+static void _cb_packet_event(int fd, void *data, enum olsr_sockethandler_flags flags);
 
 /**
  * Initialize packet socket handler
@@ -110,7 +110,7 @@ olsr_packet_add(struct olsr_packet_socket *pktsocket,
   }
 
   if ((pktsocket->scheduler_entry = olsr_socket_add(
-      s, olsr_packet_event, pktsocket, OLSR_SOCKET_READ)) == NULL) {
+      s, _cb_packet_event, pktsocket, OLSR_SOCKET_READ)) == NULL) {
     OLSR_WARN(LOG_SOCKET_PACKET, "Packet socket hookup to scheduler failed for %s\n",
         netaddr_socket_to_string(&buf, local));
     goto open_comport_error;
@@ -203,7 +203,7 @@ olsr_packet_send(struct olsr_packet_socket *pktsocket, union netaddr_socket *rem
  * @param flags socket handler flags about event (read and/or write)
  */
 static void
-olsr_packet_event(int fd, void *data, enum olsr_sockethandler_flags flags) {
+_cb_packet_event(int fd, void *data, enum olsr_sockethandler_flags flags) {
   struct olsr_packet_socket *pktsocket = data;
   union netaddr_socket *skt, sock;
   uint16_t length;
index f7a9f82..6c63e49 100644 (file)
@@ -123,8 +123,8 @@ olsr_plugins_cleanup(void) {
 }
 
 /**
- * This function is called by the constructor of a plugin.
- *
+ * This function is called by the constructor of a plugin to
+ * insert the plugin into the global list.
  * @param pl_def pointer to plugin definition
  */
 void
@@ -146,6 +146,10 @@ olsr_plugins_hook(struct olsr_plugin *pl_def) {
   OLSR_INFO(LOG_PLUGINLOADER, "Hooked plugin %s", pl_def->name);
 }
 
+/**
+ * Initialize all static plugins
+ * @return -1 if a static plugin could not be loaded, 0 otherwise
+ */
 int
 olsr_plugins_init_static(void) {
   struct olsr_plugin *p, *it;
@@ -159,11 +163,12 @@ olsr_plugins_init_static(void) {
   OLSR_FOR_ALL_PLUGIN_ENTRIES(p, it) {
     if (olsr_plugins_load(p->name) == NULL) {
       OLSR_WARN(LOG_PLUGINLOADER, "Cannot load plugin '%s'", p->name);
-      error = 1;
+      error = -1;
     }
   }
   return error;
 }
+
 /**
  * Query for a certain plugin name
  * @param libname name of plugin
@@ -199,9 +204,8 @@ olsr_plugins_get(const char *libname) {
 
 /**
  * Load a plugin and call its initialize callback
- *
- *@param libname the name of the library(file)
- *@return plugin db object
+ * @param libname the name of the library(file)
+ * @return plugin db object
  */
 struct olsr_plugin *
 olsr_plugins_load(const char *libname)
@@ -407,12 +411,3 @@ _open_plugin(const char *filename) {
   abuf_free(&abuf);
   return result;
 }
-
-/*
- * Local Variables:
- * mode: c
- * style: linux
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
index a04f29b..7142f60 100644 (file)
@@ -128,12 +128,3 @@ olsr_plugins_is_enabled(struct olsr_plugin *p) {
 }
 
 #endif
-
-/*
- * Local Variables:
- * mode: c
- * style: linux
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
index ad2e849..3565fdc 100644 (file)
@@ -71,6 +71,7 @@ olsr_socket_intfree(struct olsr_socket_entry *sock) {
 
 /**
  * Initialize olsr socket scheduler
+ * @return -1 if an error happened, 0 otherwise
  */
 int
 olsr_socket_init(void) {
@@ -108,9 +109,10 @@ olsr_socket_cleanup(void)
   olsr_memcookie_remove(socket_memcookie);
 }
 
+// TODO: remove malloc by giving function initialized socket entry
 /**
- * Add a socket and handler to the socketset
- * beeing used in the main select(2) loop
+ * Add a socket handler to the list of sockets
+ * being used in the main select(2) loop
  *
  * @param fd file descriptor for socket
  * @param pf_imm processing callback
@@ -277,10 +279,3 @@ olsr_socket_handle(uint32_t until_time)
     return -1;
   return 0;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 45bc13d..fcc0b7a 100644 (file)
@@ -70,6 +70,7 @@ struct olsr_socket_entry {
   /* custom data pointer for sockets */
   void *data;
 
+  // TODO: convert into two booleans
   /* flags (OLSR_SOCKET_READ and OLSR_SOCKET_WRITE) */
   enum olsr_sockethandler_flags flags;
 };
@@ -108,10 +109,3 @@ olsr_socket_disable(struct olsr_socket_entry *entry, unsigned int flags)
 }
 
 #endif
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 02769b6..0d85d88 100644 (file)
@@ -70,13 +70,13 @@ OLSR_SUBSYSTEM_STATE(olsr_stream_state);
 
 static int _apply_managed_socket(struct olsr_stream_managed *managed,
     struct olsr_stream_socket *stream, struct netaddr *bindto, uint16_t port);
-static void _parse_request(int fd, void *data, unsigned int flags);
+static void _cb_parse_request(int fd, void *data, unsigned int flags);
 static struct olsr_stream_session *_create_session(
-    struct olsr_stream_socket *comport, int sock, struct netaddr *remote_addr);
-static void _parse_connection(int fd, void *data,
+    struct olsr_stream_socket *stream_socket, int sock, struct netaddr *remote_addr);
+static void _cb_parse_connection(int fd, void *data,
         enum olsr_sockethandler_flags flags);
 
-static void _timeout_handler(void *);
+static void _cb_timeout_handler(void *);
 
 /**
  * Initialize the stream socket handlers
@@ -91,16 +91,16 @@ olsr_stream_init(void) {
       sizeof(struct olsr_stream_session));
   if (connection_cookie == NULL) {
     OLSR_WARN_OOM(LOG_SOCKET_STREAM);
-    olsr_stream_state--;
+    olsr_subsystem_cleanup(&olsr_stream_state);
     return -1;
   }
 
   connection_timeout = olsr_timer_add("stream socket timout",
-      &_timeout_handler, false);
+      &_cb_timeout_handler, false);
   if (connection_timeout == NULL) {
     OLSR_WARN_OOM(LOG_SOCKET_STREAM);
     olsr_memcookie_remove(connection_cookie);
-    olsr_stream_state--;
+    olsr_subsystem_cleanup(&olsr_stream_state);
     return -1;
   }
 
@@ -139,19 +139,19 @@ olsr_stream_flush(struct olsr_stream_session *con) {
 
 /**
  * Add a new stream socket to the scheduler
- * @param comport pointer to uninitialized stream socket struct
+ * @param stream_socket pointer to uninitialized stream socket struct
  * @param local pointer to local ip/port of socket
  * @return -1 if an error happened, 0 otherwise
  */
 int
-olsr_stream_add(struct olsr_stream_socket *comport,
+olsr_stream_add(struct olsr_stream_socket *stream_socket,
     union netaddr_socket *local) {
   int s = -1;
 #if !defined(REMOVE_LOG_WARN)
   struct netaddr_str buf;
 #endif
 
-  memset(comport, 0, sizeof(*comport));
+  memset(stream_socket, 0, sizeof(*stream_socket));
 
   /* Init socket */
   s = os_net_getsocket(local, OS_SOCKET_TCP, 0, LOG_SOCKET_STREAM);
@@ -166,26 +166,26 @@ olsr_stream_add(struct olsr_stream_socket *comport,
     goto add_stream_error;
   }
 
-  if ((comport->scheduler_entry = olsr_socket_add(s,
-      _parse_request, comport, OLSR_SOCKET_READ)) == NULL) {
+  if ((stream_socket->scheduler_entry = olsr_socket_add(s,
+      _cb_parse_request, stream_socket, OLSR_SOCKET_READ)) == NULL) {
     OLSR_WARN(LOG_SOCKET_STREAM, "tcp socket hookup to scheduler failed for %s\n",
         netaddr_socket_to_string(&buf, local));
     goto add_stream_error;
   }
-  memcpy(&comport->local_socket, local, sizeof(comport->local_socket));
+  memcpy(&stream_socket->local_socket, local, sizeof(stream_socket->local_socket));
 
-  if (comport->config.memcookie == NULL) {
-    comport->config.memcookie = connection_cookie;
+  if (stream_socket->config.memcookie == NULL) {
+    stream_socket->config.memcookie = connection_cookie;
   }
-  if (comport->config.allowed_sessions == 0) {
-    comport->config.allowed_sessions = 10;
+  if (stream_socket->config.allowed_sessions == 0) {
+    stream_socket->config.allowed_sessions = 10;
   }
-  if (comport->config.maximum_input_buffer == 0) {
-    comport->config.maximum_input_buffer = 65536;
+  if (stream_socket->config.maximum_input_buffer == 0) {
+    stream_socket->config.maximum_input_buffer = 65536;
   }
 
-  list_init_head(&comport->session);
-  list_add_tail(&olsr_stream_head, &comport->node);
+  list_init_head(&stream_socket->session);
+  list_add_tail(&olsr_stream_head, &stream_socket->node);
 
   return 0;
 
@@ -193,34 +193,44 @@ add_stream_error:
   if (s != -1) {
     os_close(s);
   }
-  if (comport->scheduler_entry) {
-    olsr_socket_remove(comport->scheduler_entry);
+  if (stream_socket->scheduler_entry) {
+    olsr_socket_remove(stream_socket->scheduler_entry);
   }
   return -1;
 }
 
+/**
+ * Remove a stream socket from the scheduler
+ * @param stream_socket pointer to socket
+ */
 void
-olsr_stream_remove(struct olsr_stream_socket *comport) {
+olsr_stream_remove(struct olsr_stream_socket *stream_socket) {
   struct olsr_stream_session *session;
 
-  if (list_node_added(&comport->node)) {
-    comport = list_first_element(&olsr_stream_head, comport, node);
-    while (!list_is_empty(&comport->session)) {
-      session = list_first_element(&comport->session, session, node);
+  if (list_node_added(&stream_socket->node)) {
+    stream_socket = list_first_element(&olsr_stream_head, stream_socket, node);
+    while (!list_is_empty(&stream_socket->session)) {
+      session = list_first_element(&stream_socket->session, session, node);
       olsr_stream_close(session);
     }
 
-    list_remove(&comport->node);
+    list_remove(&stream_socket->node);
 
-    if (comport->scheduler_entry) {
-      os_close(comport->scheduler_entry->fd);
-      olsr_socket_remove(comport->scheduler_entry);
+    if (stream_socket->scheduler_entry) {
+      os_close(stream_socket->scheduler_entry->fd);
+      olsr_socket_remove(stream_socket->scheduler_entry);
     }
   }
 }
 
+/**
+ * Create an outgoing stream socket.
+ * @param stream socket pointer to stream socket
+ * @param remote pointer to address of remote TCP server
+ * @return pointer to stream session, NULL if an error happened.
+ */
 struct olsr_stream_session *
-olsr_stream_connect_to(struct olsr_stream_socket *comport,
+olsr_stream_connect_to(struct olsr_stream_socket *stream_socket,
     union netaddr_socket *remote) {
   struct olsr_stream_session *session;
   struct netaddr remote_addr;
@@ -245,7 +255,7 @@ olsr_stream_connect_to(struct olsr_stream_socket *comport,
   }
 
   netaddr_from_socket(&remote_addr, remote);
-  session = _create_session(comport, s, &remote_addr);
+  session = _create_session(stream_socket, s, &remote_addr);
   if (session) {
     session->wait_for_connect = wait_for_connect;
     return session;
@@ -259,11 +269,20 @@ connect_to_error:
   return NULL;
 }
 
+/**
+ * Reset the session timeout of a TCP session
+ * @param con pointer to stream session
+ * @param timeout timeout in milliseconds
+ */
 void
 olsr_stream_set_timeout(struct olsr_stream_session *con, uint32_t timeout) {
   olsr_timer_set(&con->timeout, timeout, 0, con, connection_timeout);
 }
 
+/**
+ * Close a TCP stream session
+ * @param session pointer to stream session
+ */
 void
 olsr_stream_close(struct olsr_stream_session *session) {
   if (session->comport->config.cleanup) {
@@ -282,6 +301,10 @@ olsr_stream_close(struct olsr_stream_session *session) {
   olsr_memcookie_free(session->comport->config.memcookie, session);
 }
 
+/**
+ * Initialized a managed TCP stream
+ * @param managed pointer to uninitialized managed stream
+ */
 void
 olsr_stream_add_managed(struct olsr_stream_managed *managed) {
   memset(managed, 0, sizeof(*managed));
@@ -290,6 +313,13 @@ olsr_stream_add_managed(struct olsr_stream_managed *managed) {
   managed->config.session_timeout = 120000;
 }
 
+/**
+ * Apply a configuration to a stream. Will reset both ACLs
+ * and socket ports/bindings.
+ * @param managed pointer to managed stream
+ * @param config pointer to stream config
+ * @return -1 if an error happened, 0 otherwise.
+ */
 int
 olsr_stream_apply_managed(struct olsr_stream_managed *managed,
     struct olsr_stream_managed_config *config) {
@@ -317,6 +347,10 @@ olsr_stream_apply_managed(struct olsr_stream_managed *managed,
   return 0;
 }
 
+/**
+ * Remove a managed TCP stream
+ * @param managed pointer to managed stream
+ */
 void
 olsr_stream_remove_managed(struct olsr_stream_managed *managed) {
   olsr_stream_remove(&managed->socket_v4);
@@ -325,6 +359,14 @@ olsr_stream_remove_managed(struct olsr_stream_managed *managed) {
   olsr_acl_remove(&managed->acl);
 }
 
+/**
+ * Apply new configuration to a managed stream socket
+ * @param managed pointer to managed stream
+ * @param stream pointer to TCP stream to configure
+ * @param bindto local address to bind socket to
+ * @param port local port number
+ * @return -1 if an error happened, 0 otherwise.
+ */
 static int
 _apply_managed_socket(struct olsr_stream_managed *managed,
     struct olsr_stream_socket *stream,
@@ -358,8 +400,14 @@ _apply_managed_socket(struct olsr_stream_managed *managed,
   return 0;
 }
 
+/**
+ * Handle incoming server socket event from socket scheduler.
+ * @param fd filedescriptor for event
+ * @param data custom user data
+ * @param flags OLSR_SOCKET_(READ|WRITE)
+ */
 static void
-_parse_request(int fd, void *data, unsigned int flags) {
+_cb_parse_request(int fd, void *data, unsigned int flags) {
   struct olsr_stream_socket *comport;
   union netaddr_socket remote_socket;
   struct netaddr remote_addr;
@@ -395,8 +443,15 @@ _parse_request(int fd, void *data, unsigned int flags) {
   _create_session(comport, sock, &remote_addr);
 }
 
+/**
+ * Configure a TCP session socket
+ * @param stream_socket pointer to stream socket
+ * @param sock pointer to socket filedescriptor
+ * @param remote_addr pointer to remote address
+ * @return pointer to new stream session, NULL if an error happened.
+ */
 static struct olsr_stream_session *
-_create_session(struct olsr_stream_socket *comport,
+_create_session(struct olsr_stream_socket *stream_socket,
     int sock, struct netaddr *remote_addr) {
   struct olsr_stream_session *session;
 #if !defined REMOVE_LOG_DEBUG
@@ -410,7 +465,7 @@ _create_session(struct olsr_stream_socket *comport,
     return NULL;
   }
 
-  session = olsr_memcookie_malloc(comport->config.memcookie);
+  session = olsr_memcookie_malloc(stream_socket->config.memcookie);
   if (session == NULL) {
     OLSR_WARN(LOG_SOCKET_STREAM, "Cannot allocate memory for comport session");
     goto parse_request_error;
@@ -426,35 +481,35 @@ _create_session(struct olsr_stream_socket *comport,
   }
 
   if ((session->scheduler_entry = olsr_socket_add(sock,
-      &_parse_connection, session,
+      &_cb_parse_connection, session,
       OLSR_SOCKET_READ | OLSR_SOCKET_WRITE)) == NULL) {
     OLSR_WARN(LOG_SOCKET_STREAM, "Cannot hook incoming session into scheduler");
     goto parse_request_error;
   }
 
-  session->send_first = comport->config.send_first;
-  session->comport = comport;
+  session->send_first = stream_socket->config.send_first;
+  session->comport = stream_socket;
 
   session->remote_address = *remote_addr;
 
-  if (comport->config.allowed_sessions-- > 0) {
+  if (stream_socket->config.allowed_sessions-- > 0) {
     /* create active session */
     session->state = STREAM_SESSION_ACTIVE;
   } else {
     /* too many sessions */
-    if (comport->config.create_error) {
-      comport->config.create_error(session, STREAM_SERVICE_UNAVAILABLE);
+    if (stream_socket->config.create_error) {
+      stream_socket->config.create_error(session, STREAM_SERVICE_UNAVAILABLE);
     }
     session->state = STREAM_SESSION_SEND_AND_QUIT;
   }
 
-  if (comport->config.session_timeout) {
+  if (stream_socket->config.session_timeout) {
     session->timeout = olsr_timer_start(
-        comport->config.session_timeout, 0, session, connection_timeout);
+        stream_socket->config.session_timeout, 0, session, connection_timeout);
   }
 
-  if (comport->config.init) {
-    if (comport->config.init(session)) {
+  if (stream_socket->config.init) {
+    if (stream_socket->config.init(session)) {
       goto parse_request_error;
     }
   }
@@ -462,25 +517,35 @@ _create_session(struct olsr_stream_socket *comport,
   OLSR_DEBUG(LOG_SOCKET_STREAM, "Got connection through socket %d with %s.\n",
       sock, netaddr_to_string(&buf, remote_addr));
 
-  list_add_tail(&comport->session, &session->node);
+  list_add_tail(&stream_socket->session, &session->node);
   return session;
 
 parse_request_error:
   abuf_free(&session->in);
   abuf_free(&session->out);
-  olsr_memcookie_free(comport->config.memcookie, session);
+  olsr_memcookie_free(stream_socket->config.memcookie, session);
 
   return NULL;
 }
 
+/**
+ * Handle TCP session timeout
+ * @param data custom data
+ */
 static void
-_timeout_handler(void *data) {
+_cb_timeout_handler(void *data) {
   struct olsr_stream_session *session = data;
   olsr_stream_close(session);
 }
 
+/**
+ * Handle events for TCP session from network scheduler
+ * @param fd filedescriptor of TCP session
+ * @param data custom data
+ * @param flags OLSR_SOCKET_(READ|WRITE)
+ */
 static void
-_parse_connection(int fd, void *data,
+_cb_parse_connection(int fd, void *data,
     enum olsr_sockethandler_flags flags) {
   struct olsr_stream_session *session;
   struct olsr_stream_socket *comport;
index 8403fc9..d258702 100644 (file)
 #define _CFG_TELNET_SECTION "telnet"
 
 /* static function prototypes */
-static void _config_changed(void);
-static int _telnet_init(struct olsr_stream_session *);
-static void _telnet_cleanup(struct olsr_stream_session *);
-static void _telnet_create_error(struct olsr_stream_session *,
+static void _cb_config_changed(void);
+static int _cb_telnet_init(struct olsr_stream_session *);
+static void _cb_telnet_cleanup(struct olsr_stream_session *);
+static void _cb_telnet_create_error(struct olsr_stream_session *,
     enum olsr_stream_errors);
-static enum olsr_stream_session_state _telnet_receive_data(
+static enum olsr_stream_session_state _cb_telnet_receive_data(
     struct olsr_stream_session *);
 static enum olsr_telnet_result _telnet_handle_command(
     struct olsr_telnet_data *);
@@ -40,14 +40,14 @@ static struct olsr_telnet_command *_check_telnet_command(
     struct olsr_telnet_data *data, const char *name,
     struct olsr_telnet_command *cmd);
 
-static void _telnet_repeat_timer(void *data);
-static enum olsr_telnet_result _telnet_quit(struct olsr_telnet_data *data);
-static enum olsr_telnet_result _telnet_help(struct olsr_telnet_data *data);
-static enum olsr_telnet_result _telnet_echo(struct olsr_telnet_data *data);
-static enum olsr_telnet_result _telnet_repeat(struct olsr_telnet_data *data);
-static enum olsr_telnet_result _telnet_timeout(struct olsr_telnet_data *data);
-static enum olsr_telnet_result _telnet_version(struct olsr_telnet_data *data);
-static enum olsr_telnet_result _telnet_plugin(struct olsr_telnet_data *data);
+static void _cb_telnet_repeat_timer(void *data);
+static enum olsr_telnet_result _cb_telnet_quit(struct olsr_telnet_data *data);
+static enum olsr_telnet_result _cb_telnet_help(struct olsr_telnet_data *data);
+static enum olsr_telnet_result _cb_telnet_echo(struct olsr_telnet_data *data);
+static enum olsr_telnet_result _cb_telnet_repeat(struct olsr_telnet_data *data);
+static enum olsr_telnet_result _cb_telnet_timeout(struct olsr_telnet_data *data);
+static enum olsr_telnet_result _cb_telnet_version(struct olsr_telnet_data *data);
+static enum olsr_telnet_result _cb_telnet_plugin(struct olsr_telnet_data *data);
 
 /* global and static variables */
 static struct cfg_schema_section telnet_section = {
@@ -68,22 +68,22 @@ static struct cfg_schema_entry telnet_entries[] = {
 
 static struct cfg_delta_handler telnet_handler = {
   .s_type = _CFG_TELNET_SECTION,
-  .callback = _config_changed
+  .callback = _cb_config_changed
 };
 
 /* built-in telnet commands */
 static struct olsr_telnet_command _builtin[] = {
-  TELNET_CMD("quit", _telnet_quit, "Ends telnet session"),
-  TELNET_CMD("exit", _telnet_quit, "Ends telnet session"),
-  TELNET_CMD("help", _telnet_help,
+  TELNET_CMD("quit", _cb_telnet_quit, "Ends telnet session"),
+  TELNET_CMD("exit", _cb_telnet_quit, "Ends telnet session"),
+  TELNET_CMD("help", _cb_telnet_help,
       "help: Display the online help text and a list of commands"),
-  TELNET_CMD("echo", _telnet_echo,"echo <string>: Prints a string"),
-  TELNET_CMD("repeat", _telnet_repeat,
+  TELNET_CMD("echo", _cb_telnet_echo,"echo <string>: Prints a string"),
+  TELNET_CMD("repeat", _cb_telnet_repeat,
       "repeat <seconds> <command>: Repeats a telnet command every X seconds"),
-  TELNET_CMD("timeout", _telnet_timeout,
+  TELNET_CMD("timeout", _cb_telnet_timeout,
       "timeout <seconds> :Sets telnet session timeout"),
-  TELNET_CMD("version", _telnet_version, "Displays version of the program"),
-  TELNET_CMD("plugin", _telnet_plugin,
+  TELNET_CMD("version", _cb_telnet_version, "Displays version of the program"),
+  TELNET_CMD("plugin", _cb_telnet_plugin,
         "control plugins dynamically, parameters are 'list',"
         " 'activate <plugin>', 'deactivate <plugin>', "
         "'load <plugin>' and 'unload <plugin>'"),
@@ -99,6 +99,10 @@ static struct olsr_timer_info *_telnet_repeat_timerinfo;
 
 struct avl_tree telnet_cmd_tree;
 
+/**
+ * Initialize telnet subsystem
+ * @return 0 if initialized successfully, -1 otherwise
+ */
 int
 olsr_telnet_init(void) {
   size_t i;
@@ -113,7 +117,7 @@ olsr_telnet_init(void) {
     return -1;
   }
 
-  _telnet_repeat_timerinfo = olsr_timer_add("txt repeat timer", _telnet_repeat_timer, true);
+  _telnet_repeat_timerinfo = olsr_timer_add("txt repeat timer", _cb_telnet_repeat_timer, true);
   if (_telnet_repeat_timerinfo == NULL) {
     olsr_memcookie_remove(_telnet_memcookie);
     olsr_subsystem_cleanup(&olsr_telnet_state);
@@ -130,10 +134,10 @@ olsr_telnet_init(void) {
   _telnet_managed.config.maximum_input_buffer = 4096;
   _telnet_managed.config.allowed_sessions = 3;
   _telnet_managed.config.memcookie = _telnet_memcookie;
-  _telnet_managed.config.init = _telnet_init;
-  _telnet_managed.config.cleanup = _telnet_cleanup;
-  _telnet_managed.config.receive_data = _telnet_receive_data;
-  _telnet_managed.config.create_error = _telnet_create_error;
+  _telnet_managed.config.init = _cb_telnet_init;
+  _telnet_managed.config.cleanup = _cb_telnet_cleanup;
+  _telnet_managed.config.receive_data = _cb_telnet_receive_data;
+  _telnet_managed.config.create_error = _cb_telnet_create_error;
 
   /* initialize telnet commands */
   avl_init(&telnet_cmd_tree, avl_comp_strcasecmp, false, NULL);
@@ -144,6 +148,9 @@ olsr_telnet_init(void) {
   return 0;
 }
 
+/**
+ * Cleanup all allocated data of telnet subsystem
+ */
 void
 olsr_telnet_cleanup(void) {
   if (olsr_subsystem_cleanup(&olsr_telnet_state))
@@ -157,6 +164,11 @@ olsr_telnet_cleanup(void) {
   olsr_memcookie_remove(_telnet_memcookie);
 }
 
+/**
+ * Add a new telnet command to telnet subsystem
+ * @param command pointer to initialized telnet command object
+ * @return -1 if an error happened, 0 otherwise
+ */
 int
 olsr_telnet_add(struct olsr_telnet_command *command) {
   command->node.key = command->command;
@@ -166,6 +178,10 @@ olsr_telnet_add(struct olsr_telnet_command *command) {
   return 0;
 }
 
+/**
+ * Remove a telnet command from telnet subsystem
+ * @param command pointer to telnet command object
+ */
 void
 olsr_telnet_remove(struct olsr_telnet_command *command) {
   avl_remove(&telnet_cmd_tree, &command->node);
@@ -179,6 +195,14 @@ olsr_telnet_stop(struct olsr_telnet_data *data) {
   }
 }
 
+/**
+ * Execute a telnet command.
+ * @param cmd pointer to name of command
+ * @param para pointer to parameter string
+ * @param out buffer for output of command
+ * @param remote pointer to address which triggers the execution
+ * @return result of telnet command
+ */
 enum olsr_telnet_result
 olsr_telnet_execute(const char *cmd, const char *para,
     struct autobuf *out, struct netaddr *remote) {
@@ -196,8 +220,11 @@ olsr_telnet_execute(const char *cmd, const char *para,
   return result;
 }
 
+/**
+ * Handler for configuration changes
+ */
 static void
-_config_changed(void) {
+_cb_config_changed(void) {
   struct olsr_stream_managed_config config;
   int ret = -1;
 
@@ -221,8 +248,13 @@ apply_config_failed:
   olsr_acl_remove(&config.acl);
 }
 
+/**
+ * Initialization of incoming telnet session
+ * @param session pointer to TCP session
+ * @return 0
+ */
 static int
-_telnet_init(struct olsr_stream_session *session) {
+_cb_telnet_init(struct olsr_stream_session *session) {
   struct olsr_telnet_session *telnet_session;
 
   /* get telnet session pointer */
@@ -239,8 +271,12 @@ _telnet_init(struct olsr_stream_session *session) {
   return 0;
 }
 
+/**
+ * Cleanup of telnet session
+ * @param session pointer to TCP session
+ */
 static void
-_telnet_cleanup(struct olsr_stream_session *session) {
+_cb_telnet_cleanup(struct olsr_stream_session *session) {
   struct olsr_telnet_session *telnet_session;
   struct olsr_telnet_cleanup *handler, *it;
 
@@ -260,8 +296,13 @@ _telnet_cleanup(struct olsr_stream_session *session) {
   }
 }
 
+/**
+ * Create error string for telnet session
+ * @param session pointer to TCP stream
+ * @param error TCP error code to generate
+ */
 static void
-_telnet_create_error(struct olsr_stream_session *session,
+_cb_telnet_create_error(struct olsr_stream_session *session,
     enum olsr_stream_errors error) {
   switch(error) {
     case STREAM_REQUEST_FORBIDDEN:
@@ -276,8 +317,13 @@ _telnet_create_error(struct olsr_stream_session *session,
   }
 }
 
+/**
+ * Handler for receiving data from telnet session
+ * @param session pointer to TCP session
+ * @return TCP session state
+ */
 static enum olsr_stream_session_state
-_telnet_receive_data(struct olsr_stream_session *session) {
+_cb_telnet_receive_data(struct olsr_stream_session *session) {
   static const char defaultCommand[] = "/link/neigh/topology/hna/mid/routes";
   static char tmpbuf[128];
 
@@ -398,6 +444,11 @@ _telnet_receive_data(struct olsr_stream_session *session) {
   return STREAM_SESSION_ACTIVE;
 }
 
+/**
+ * Helper function to call telnet command handler
+ * @param data pointer to telnet data
+ * @return telnet command result
+ */
 static enum olsr_telnet_result
 _telnet_handle_command(struct olsr_telnet_data *data) {
   struct olsr_telnet_command *cmd;
@@ -415,6 +466,14 @@ _telnet_handle_command(struct olsr_telnet_data *data) {
   return cmd->handler(data);
 }
 
+/**
+ * Checks for existing (and allowed) telnet command.
+ * Either name or cmd should be NULL, but not both.
+ * @param data pointer to telnet data
+ * @param name pointer to command name (might be NULL)
+ * @param cmd pointer to telnet command object (might be NULL)
+ * @return telnet command object or NULL if not found or forbidden
+ */
 static struct olsr_telnet_command *
 _check_telnet_command(struct olsr_telnet_data *data,
     const char *name, struct olsr_telnet_command *cmd) {
@@ -440,13 +499,23 @@ _check_telnet_command(struct olsr_telnet_data *data,
   return cmd;
 }
 
+/**
+ * Telnet command 'quit'
+ * @param data pointer to telnet data
+ * @return telnet command result
+ */
 static enum olsr_telnet_result
-_telnet_quit(struct olsr_telnet_data *data __attribute__((unused))) {
+_cb_telnet_quit(struct olsr_telnet_data *data __attribute__((unused))) {
   return TELNET_RESULT_QUIT;
 }
 
+/**
+ * Telnet command 'help'
+ * @param data pointer to telnet data
+ * @return telnet command result
+ */
 static enum olsr_telnet_result
-_telnet_help(struct olsr_telnet_data *data) {
+_cb_telnet_help(struct olsr_telnet_data *data) {
   struct olsr_telnet_command *ptr, *iterator;
 
   if (data->parameter != NULL && data->parameter[0] != 0) {
@@ -485,8 +554,13 @@ _telnet_help(struct olsr_telnet_data *data) {
   return TELNET_RESULT_ACTIVE;
 }
 
+/**
+ * Telnet command 'echo'
+ * @param data pointer to telnet data
+ * @return telnet command result
+ */
 static enum olsr_telnet_result
-_telnet_echo(struct olsr_telnet_data *data) {
+_cb_telnet_echo(struct olsr_telnet_data *data) {
 
   if (abuf_appendf(data->out, "%s\n",
       data->parameter == NULL ? "" : data->parameter) < 0) {
@@ -495,14 +569,23 @@ _telnet_echo(struct olsr_telnet_data *data) {
   return TELNET_RESULT_ACTIVE;
 }
 
+/**
+ * Telnet command 'timeout'
+ * @param data pointer to telnet data
+ * @return telnet command result
+ */
 static enum olsr_telnet_result
-_telnet_timeout(struct olsr_telnet_data *data) {
+_cb_telnet_timeout(struct olsr_telnet_data *data) {
   data->timeout_value = (uint32_t)strtoul(data->parameter, NULL, 10) * 1000;
   return TELNET_RESULT_ACTIVE;
 }
 
+/**
+ * Stop handler for repeating telnet commands
+ * @param data pointer to telnet data
+ */
 static void
-_telnet_repeat_stophandler(struct olsr_telnet_data *data) {
+_cb_telnet_repeat_stophandler(struct olsr_telnet_data *data) {
   olsr_timer_stop((struct olsr_timer_entry *)data->stop_data[0]);
   free(data->stop_data[1]);
 
@@ -512,8 +595,12 @@ _telnet_repeat_stophandler(struct olsr_telnet_data *data) {
   data->stop_data[2] = NULL;
 }
 
+/**
+ * Timer event handler for repeating telnet commands
+ * @param ptr pointer to custom data
+ */
 static void
-_telnet_repeat_timer(void *ptr) {
+_cb_telnet_repeat_timer(void *ptr) {
   struct olsr_telnet_data *telnet_data = ptr;
   struct olsr_telnet_session *session;
 
@@ -530,8 +617,13 @@ _telnet_repeat_timer(void *ptr) {
   olsr_stream_flush(&session->session);
 }
 
+/**
+ * Telnet command 'repeat'
+ * @param data pointer to telnet data
+ * @return telnet command result
+ */
 static enum olsr_telnet_result
-_telnet_repeat(struct olsr_telnet_data *data) {
+_cb_telnet_repeat(struct olsr_telnet_data *data) {
   struct olsr_timer_entry *timer;
   int interval = 0;
   char *ptr = NULL;
@@ -551,7 +643,7 @@ _telnet_repeat(struct olsr_telnet_data *data) {
   interval = atoi(data->parameter);
 
   timer = olsr_timer_start(interval * 1000, 0, data, _telnet_repeat_timerinfo);
-  data->stop_handler = _telnet_repeat_stophandler;
+  data->stop_handler = _cb_telnet_repeat_stophandler;
   data->stop_data[0] = timer;
   data->stop_data[1] = strdup(ptr);
   data->stop_data[2] = NULL;
@@ -575,14 +667,24 @@ _telnet_repeat(struct olsr_telnet_data *data) {
   return TELNET_RESULT_CONTINOUS;
 }
 
+/**
+ * Telnet command 'version'
+ * @param data pointer to telnet data
+ * @return telnet command result
+ */
 static enum olsr_telnet_result
-_telnet_version(struct olsr_telnet_data *data) {
+_cb_telnet_version(struct olsr_telnet_data *data) {
   olsr_builddata_printversion(data->out);
   return TELNET_RESULT_ACTIVE;
 }
 
+/**
+ * Telnet command 'plugin'
+ * @param data pointer to telnet data
+ * @return telnet command result
+ */
 static enum olsr_telnet_result
-_telnet_plugin(struct olsr_telnet_data *data) {
+_cb_telnet_plugin(struct olsr_telnet_data *data) {
   struct olsr_plugin *plugin, *iterator;
   const char *plugin_name = NULL;
 
index ac5a5de..51c5286 100644 (file)
@@ -95,6 +95,11 @@ EXPORT enum olsr_telnet_result olsr_telnet_execute(
     const char *cmd, const char *para,
     struct autobuf *out, struct netaddr *remote);
 
+/**
+ * Add a cleanup handler to a telnet session
+ * @param data pointer to telnet data
+ * @param cleanup pointer to initialized cleanup handler
+ */
 static INLINE void
 olsr_telnet_add_cleanup(struct olsr_telnet_data *data,
     struct olsr_telnet_cleanup *cleanup) {
@@ -102,6 +107,10 @@ olsr_telnet_add_cleanup(struct olsr_telnet_data *data,
   list_add_tail(&data->cleanup_list, &cleanup->node);
 }
 
+/**
+ * Removes a cleanup handler to a telnet session
+ * @param cleanup pointer to cleanup handler
+ */
 static INLINE void
 olsr_telnet_remove_cleanup(struct olsr_telnet_cleanup *cleanup) {
   list_remove(&cleanup->node);
index b82279a..68dcd51 100644 (file)
@@ -68,7 +68,8 @@ OLSR_SUBSYSTEM_STATE(olsr_timer_state);
 static uint32_t calc_jitter(unsigned int rel_time, uint8_t jitter_pct, unsigned int random_val);
 
 /**
- * Init datastructures for maintaining timers.
+ * Initialize timer scheduler subsystem
+ * @return -1 if an error happened, 0 otherwise
  */
 int
 olsr_timer_init(void)
@@ -145,9 +146,10 @@ olsr_timer_cleanup(void)
   olsr_memcookie_remove(timerinfo_cookie);
 }
 
+// TODO: remove malloc by using pointer to initialized timer_info?
 /**
  * Add a new group of timers to the scheduler
- * @param name
+ * @param name name of timer
  * @param callback timer event function
  * @param periodic true if the timer is periodic, false otherwise
  * @return new timer info
@@ -192,7 +194,6 @@ olsr_timer_remove(struct olsr_timer_info *info) {
 
 /**
  * Start a new timer.
- *
  * @param rel_time time expressed in milliseconds
  * @param jitter_pct expressed in percent
  * @param context for the callback function
@@ -201,7 +202,7 @@ olsr_timer_remove(struct olsr_timer_info *info) {
  */
 struct olsr_timer_entry *
 olsr_timer_start(unsigned int rel_time,
-                 uint8_t jitter_pct, void *context, struct olsr_timer_info *ti)
+    uint8_t jitter_pct, void *context, struct olsr_timer_info *ti)
 {
   struct olsr_timer_entry *timer;
 #if !defined(REMOVE_LOG_DEBUG)
@@ -248,7 +249,6 @@ olsr_timer_start(unsigned int rel_time,
 
 /**
  * Delete a timer.
- *
  * @param timer the olsr_timer_entry that shall be removed
  */
 void
@@ -280,8 +280,7 @@ olsr_timer_stop(struct olsr_timer_entry *timer)
 }
 
 /**
- * Change a olsr_timer_entry.
- *
+ * Change time when a timer should fire.
  * @param timer olsr_timer_entry to be changed.
  * @param rel_time new relative time expressed in units of milliseconds.
  * @param jitter_pct new jitter expressed in percent.
@@ -351,7 +350,7 @@ olsr_timer_set(struct olsr_timer_entry **timer_ptr,
 
 /**
  * Walk through the timer list and check if any timer is ready to fire.
- * Callback the provided function with the context pointer.
+ * Call the provided function with the context pointer.
  */
 void
 olsr_timer_walk(void)
@@ -461,11 +460,10 @@ olsr_timer_walk(void)
 
 /**
  * Decrement a relative timer by a random number range.
- *
  * @param the relative timer expressed in units of milliseconds.
  * @param the jitter in percent
- * @param cached result of random() at system init.
- * @return the absolute timer
+ * @param random_val cached random variable to calculate jitter
+ * @return the absolute time when timer will fire
  */
 static uint32_t
 calc_jitter(unsigned int rel_time, uint8_t jitter_pct, unsigned int random_val)
index 1c2767b..14cb1c2 100644 (file)
@@ -123,7 +123,7 @@ void olsr_timer_walk(void);
 
 EXPORT struct olsr_timer_info *olsr_timer_add(
     const char *name, timer_cb_func callback, bool periodic) __attribute__((warn_unused_result));
-void olsr_timer_remove(struct olsr_timer_info *);
+EXPORT void olsr_timer_remove(struct olsr_timer_info *);
 
 EXPORT void olsr_timer_set(struct olsr_timer_entry **, uint32_t, uint8_t,
     void *, struct olsr_timer_info *);
index 5ff32aa..5896a84 100644 (file)
@@ -369,7 +369,7 @@ mainloop(int argc, char **argv) {
     /* reload configuration if triggered */
     if (reload_config) {
       OLSR_INFO(LOG_MAIN, "Reloading configuration");
-      if (olsr_cfg_create_new_rawdb()) {
+      if (olsr_cfg_clear_rawdb()) {
         running = false;
       }
       else if (parse_commandline(argc, argv, true) == -1) {