- added lam_ptr_t

- changed reactor i/f

This commit was SVN r546.

src/lam/constants.h

@@ -21,7 +21,8 @@ enum {
     LAM_ERR_NOT_SUPPORTED = -11,
     LAM_ERR_INTERUPTED = -12,
     LAM_ERR_WOULD_BLOCK = -13,
-    LAM_ERR_IN_ERRNO = -14
+    LAM_ERR_IN_ERRNO = -14,
+    LAM_ERR_UNREACH = -15
 };
 
 #endif /* LAM_CONSTANTS_H */

src/lam/types.h

@@ -10,6 +10,7 @@
 
 #include "lam_config.h"
 #include "lam/stdint.h"
+#include "lam/types.h"
 
 /*
  *  Increase FD_SETSIZE
@@ -35,5 +36,15 @@ typedef struct lam_fd_set_t lam_fd_set_t;
 typedef char* lam_job_handle_t;
 
 
+/*
+ * portable assignment of pointer to int
+ */
+
+typedef union {
+   uint64_t lval;
+   uint32_t ival;
+   void*    pval;
+} lam_ptr_t;
+
 #endif
 

src/lam/util/if.c

@@ -31,6 +31,7 @@ struct lam_if_t {
     int                 if_flags;
     struct sockaddr_in  if_addr;
     struct sockaddr_in  if_mask;
+    uint32_t            if_bandwidth;
 };
 typedef struct lam_if_t lam_if_t;
 
@@ -69,7 +70,7 @@ static int lam_ifinit(void)
         struct ifreq* ifr = (struct ifreq*)ptr;
         lam_if_t intf;
         lam_if_t *intf_ptr;
-        lam_list_init(&intf.if_item);
+        lam_list_item_init(&intf.if_item);
 
 #if defined(__APPLE__)
         ptr += (sizeof(ifr->ifr_name) + 
@@ -273,6 +274,31 @@ int lam_ifindextoaddr(int if_index, struct sockaddr* if_addr, int length)
 }
 
 
+/* 
+ *  Lookup the interface by kernel index and return the 
+ *  network mask assigned to the interface.
+ */
+
+int lam_ifindextomask(int if_index, struct sockaddr* if_mask, int length)
+{
+    lam_if_t* intf;
+    int rc = lam_ifinit();
+    if(rc != LAM_SUCCESS)
+        return rc;
+
+    for(intf =  (lam_if_t*)lam_list_get_first(&lam_if_list);
+        intf != (lam_if_t*)lam_list_get_end(&lam_if_list);
+        intf =  (lam_if_t*)lam_list_get_next(intf)) {
+        if(intf->if_index == if_index) {
+            memcpy(if_mask, &intf->if_mask, length);
+            return LAM_SUCCESS;
+        }
+    }
+    return LAM_ERROR;
+}
+
+
+
 /* 
  *  Lookup the interface by kernel index and return
  *  the associated name.

src/lam/util/if.h

@@ -72,5 +72,14 @@ int lam_ifindextoname(int if_index, char* if_name, int);
  */
 int lam_ifindextoaddr(int if_index, struct sockaddr*, int);
 
+/**
+ *  Lookup an interface by index and return its network mask.
+ *
+ *  @param if_index (IN)  Interface index
+ *  @param if_name (OUT)  Interface address buffer
+ *  @param size (IN)      Interface address buffer size
+ */
+int lam_ifindextomask(int if_index, struct sockaddr*, int);
+
 #endif
 

src/lam/util/reactor.c

@@ -9,7 +9,7 @@
 #include <errno.h>
 
 #include "lam_config.h"
-#include "lam/mem/malloc.h"
+#include "lam/constants.h"
 #include "lam/util/reactor.h"
 #include "lam/util/output.h"
 #include "lam/runtime/runtime.h"
@@ -24,37 +24,39 @@ const int LAM_NOTIFY_ALL = 7;
 
                                                                             
 lam_class_info_t lam_reactor_cls = {
-    "lam_reactor_t", &lam_object_cls, (class_init_t)lam_reactor_init,
+    "lam_reactor_t", 
+    &lam_object_cls, 
+    (class_init_t)lam_reactor_init,
     (class_destroy_t)lam_reactor_destroy
 };
                                                                                                                 
 lam_class_info_t lam_reactor_descriptor_cls = {
-    "lam_reactor_t", &lam_list_item_cls, (class_init_t)lam_reactor_descriptor_init,
+    "lam_reactor_t", 
+    &lam_list_item_cls, 
+    (class_init_t)lam_reactor_descriptor_init,
     (class_destroy_t)lam_reactor_descriptor_destroy
 };
 
                                                                                                                 
 void lam_reactor_descriptor_init(lam_reactor_descriptor_t* rd)
 {
-    lam_list_item_init(&rd->rd_base);
+    SUPER_INIT(rd, &lam_list_item_cls);
-    rd->rd_base.super.obj_class = &lam_reactor_descriptor_cls;
 }
 
 
 void lam_reactor_descriptor_destroy(lam_reactor_descriptor_t* rd)
 {
-    lam_list_item_destroy(&rd->rd_base);
+    SUPER_DESTROY(rd, &lam_list_item_cls);
 }
 
 
 static inline lam_reactor_descriptor_t* lam_reactor_get_descriptor(lam_reactor_t* r, int sd)
 {
     lam_reactor_descriptor_t *descriptor;
-    if(lam_list_get_size(&r->r_free))
+    if(lam_list_get_size(&r->r_free)) {
         descriptor = (lam_reactor_descriptor_t*)lam_list_remove_first(&r->r_free);
-    else {
+    } else {
-        descriptor = (lam_reactor_descriptor_t*)LAM_MALLOC(sizeof(lam_reactor_descriptor_t));
+        descriptor = OBJ_CREATE(lam_reactor_descriptor_t, &lam_reactor_descriptor_cls);
-        lam_reactor_descriptor_init(descriptor);
     }
     if (NULL == descriptor) {
       return 0;
@@ -70,8 +72,7 @@ static inline lam_reactor_descriptor_t* lam_reactor_get_descriptor(lam_reactor_t
 
 void lam_reactor_init(lam_reactor_t* r)
 { 
-    lam_obj_init(&r->r_base);
+    SUPER_INIT(r, &lam_object_cls);
-    r->r_base.obj_class = &lam_reactor_cls;
 
     lam_mutex_init(&r->r_mutex);
     lam_list_init(&r->r_active);
@@ -96,16 +97,16 @@ void lam_reactor_destroy(lam_reactor_t* r)
     lam_list_destroy(&r->r_free);
     lam_list_destroy(&r->r_pending);
     lam_fh_destroy(&r->r_hash);
-    lam_obj_destroy(&r->r_base);
+    SUPER_DESTROY(r, &lam_object_cls);
 }
 
 
-bool lam_reactor_insert(lam_reactor_t* r, int sd, lam_reactor_listener_t* listener, void* user, int flags)
+int lam_reactor_insert(lam_reactor_t* r, int sd, lam_reactor_listener_t* listener, void* user, int flags)
 {
-#ifndef NDEBUG
+#if LAM_ENABLE_DEBUG > 0
     if(sd < 0 || sd > LAM_FD_SETSIZE) {
       lam_output(0, "lam_reactor_insert(%d) invalid descriptor", sd);
-      return false;
+      return LAM_ERR_BAD_PARAM;
     }
 #endif
 
@@ -115,9 +116,9 @@ bool lam_reactor_insert(lam_reactor_t* r, int sd, lam_reactor_listener_t* listen
         descriptor = lam_reactor_get_descriptor(r, sd);
         if(descriptor == 0) {
             lam_mutex_unlock(&r->r_mutex);
-            return false;
+            return LAM_ERR_OUT_OF_RESOURCE;
         }
-        lam_list_append(&r->r_pending, &descriptor->rd_base);
+        lam_list_append(&r->r_pending, &descriptor->super);
         lam_fh_set_value_for_ikey(&r->r_hash,descriptor,sd);
     }
 
@@ -139,16 +140,16 @@ bool lam_reactor_insert(lam_reactor_t* r, int sd, lam_reactor_listener_t* listen
     }
     r->r_changes++;
     lam_mutex_unlock(&r->r_mutex);
-    return true;
+    return LAM_SUCCESS;
 }
 
 
-bool lam_reactor_remove(lam_reactor_t* r, int sd, int flags)
+int lam_reactor_remove(lam_reactor_t* r, int sd, int flags)
 {
-#ifndef NDEBUG
+#if LAM_ENABLE_DEBUG > 0
     if(sd < 0 || sd > LAM_FD_SETSIZE) {
       lam_output(0, "lam_reactor_remove(%d) invalid descriptor", sd);
-      return false;
+      return LAM_ERR_BAD_PARAM;
     }
 #endif
 
@@ -157,7 +158,7 @@ bool lam_reactor_remove(lam_reactor_t* r, int sd, int flags)
     if (NULL == descriptor) {
       lam_output(0, "lam_reactor_remove(%d): descriptor not registered", sd);
       lam_mutex_unlock(&r->r_mutex);
-      return false;
+      return LAM_ERR_BAD_PARAM;
     }
     descriptor->rd_flags &= ~flags;
     if(flags & LAM_NOTIFY_RECV) {
@@ -174,7 +175,7 @@ bool lam_reactor_remove(lam_reactor_t* r, int sd, int flags)
     }
     r->r_changes++;
     lam_mutex_unlock(&r->r_mutex);
-    return true;
+    return LAM_SUCCESS;
 }
 
 
@@ -194,15 +195,15 @@ void lam_reactor_dispatch(lam_reactor_t* r, int cnt, lam_fd_set_t* rset, lam_fd_
         int rd = descriptor->rd; 
         int flags = 0;
         if(LAM_FD_ISSET(rd, rset) && descriptor->rd_flags & LAM_NOTIFY_RECV) {
-            descriptor->rd_recv->rl_recv_handler(rd, descriptor->rd_recv_user);
+            descriptor->rd_recv->rl_recv_handler(descriptor->rd_recv_user, rd);
             flags |= LAM_NOTIFY_RECV;
         }
         if(LAM_FD_ISSET(rd, sset) && descriptor->rd_flags & LAM_NOTIFY_SEND) {
-            descriptor->rd_send->rl_send_handler(rd, descriptor->rd_send_user);
+            descriptor->rd_send->rl_send_handler(descriptor->rd_send_user, rd);
             flags |= LAM_NOTIFY_SEND;
         }
         if(LAM_FD_ISSET(rd, eset) && descriptor->rd_flags & LAM_NOTIFY_EXCEPT) {
-            descriptor->rd_except->rl_except_handler(rd, descriptor->rd_except_user);
+            descriptor->rd_except->rl_except_handler(descriptor->rd_except_user, rd);
             flags |= LAM_NOTIFY_EXCEPT;
         }
         if(flags) cnt--;
@@ -222,7 +223,7 @@ void lam_reactor_dispatch(lam_reactor_t* r, int cnt, lam_fd_set_t* rset, lam_fd_
             lam_fh_remove_value_for_ikey(&r->r_hash, descriptor->rd);
             lam_list_remove(&r->r_active, (lam_list_item_t*)descriptor);
             if(lam_list_get_size(&r->r_free) < MAX_DESCRIPTOR_POOL_SIZE) {
-                lam_list_append(&r->r_free, &descriptor->rd_base);
+                lam_list_append(&r->r_free, &descriptor->super);
             } else {
                 lam_reactor_descriptor_destroy(descriptor);
                 LAM_FREE(descriptor);
@@ -237,13 +238,13 @@ void lam_reactor_dispatch(lam_reactor_t* r, int cnt, lam_fd_set_t* rset, lam_fd_
         if(descriptor->rd_flags == 0) {
             lam_fh_remove_value_for_ikey(&r->r_hash, descriptor->rd);
             if(lam_list_get_size(&r->r_free) < MAX_DESCRIPTOR_POOL_SIZE) {
-                lam_list_append(&r->r_free, &descriptor->rd_base);
+                lam_list_append(&r->r_free, &descriptor->super);
             } else {
                 lam_reactor_descriptor_destroy(descriptor);
                 LAM_FREE(descriptor);
             }
         } else {
-            lam_list_append(&r->r_active, &descriptor->rd_base);
+            lam_list_append(&r->r_active, &descriptor->super);
             if(descriptor->rd > r->r_max)
                 r->r_max = descriptor->rd;
         }

src/lam/util/reactor.h

@@ -26,20 +26,20 @@ extern lam_class_info_t lam_reactor_cls;
  */
 
 struct lam_reactor_listener_t;
-typedef void (*rl_recv_handler_fn_t)(int sd, void* user);
+typedef void (*lam_rl_recv_handler_fn_t)(void* user, int sd);
-typedef void (*rl_send_handler_fn_t)(int sd, void* user);
+typedef void (*lam_rl_send_handler_fn_t)(void* user, int sd);
-typedef void (*rl_except_handler_fn_t)(int sd, void* user);
+typedef void (*lam_rl_except_handler_fn_t)(void* user, int sd);
 
 struct lam_reactor_listener_t {
-    rl_recv_handler_fn_t   rl_recv_handler;
+    lam_rl_recv_handler_fn_t   rl_recv_handler;
-    rl_send_handler_fn_t   rl_send_handler;
+    lam_rl_send_handler_fn_t   rl_send_handler;
-    rl_except_handler_fn_t rl_except_handler;
+    lam_rl_except_handler_fn_t rl_except_handler;
 };
 typedef struct lam_reactor_listener_t lam_reactor_listener_t;
 
 
 struct lam_reactor_descriptor_t {
-    lam_list_item_t         rd_base;
+    lam_list_item_t         super;
     int                     rd;
     volatile int            rd_flags;
     lam_reactor_listener_t* rd_recv;
@@ -57,7 +57,7 @@ void lam_reactor_descriptor_destroy(lam_reactor_descriptor_t*);
 
 
 struct lam_reactor_t {
-    lam_object_t       r_base;
+    lam_object_t       super;
     lam_mutex_t        r_mutex;
     lam_list_t         r_active;
     lam_list_t         r_free;
@@ -76,8 +76,8 @@ typedef struct lam_reactor_t lam_reactor_t;
 void lam_reactor_init(lam_reactor_t*);
 void lam_reactor_destroy(lam_reactor_t*);
 
-bool lam_reactor_insert(lam_reactor_t*, int sd, lam_reactor_listener_t*, void* user, int flags);
+int  lam_reactor_insert(lam_reactor_t*, int sd, lam_reactor_listener_t*, void* user, int flags);
-bool lam_reactor_remove(lam_reactor_t*, int sd, int flags);
+int  lam_reactor_remove(lam_reactor_t*, int sd, int flags);
 void lam_reactor_poll(lam_reactor_t*);
 void lam_reactor_run(lam_reactor_t*);
 void lam_reactor_dispatch(lam_reactor_t* r, int cnt, lam_fd_set_t* rset, lam_fd_set_t* sset, lam_fd_set_t* eset);