From d78ddd7cf26df554f2b70fdeff1ed75e237c754b Mon Sep 17 00:00:00 2001 From: Tim Woodall Date: Mon, 26 Jan 2004 18:41:37 +0000 Subject: [PATCH] - added lam_ptr_t - changed reactor i/f This commit was SVN r546. --- src/lam/constants.h | 3 ++- src/lam/types.h | 11 ++++++++ src/lam/util/if.c | 28 ++++++++++++++++++- src/lam/util/if.h | 9 +++++++ src/lam/util/reactor.c | 61 +++++++++++++++++++++--------------------- src/lam/util/reactor.h | 20 +++++++------- 6 files changed, 90 insertions(+), 42 deletions(-) diff --git a/src/lam/constants.h b/src/lam/constants.h index 0985f91bda..8ff2ae4fae 100644 --- a/src/lam/constants.h +++ b/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 */ diff --git a/src/lam/types.h b/src/lam/types.h index c66ce8486c..715881f8bc 100644 --- a/src/lam/types.h +++ b/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 diff --git a/src/lam/util/if.c b/src/lam/util/if.c index b5f918ca68..132715945b 100644 --- a/src/lam/util/if.c +++ b/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. diff --git a/src/lam/util/if.h b/src/lam/util/if.h index 70290bc106..1a6f126930 100644 --- a/src/lam/util/if.h +++ b/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 diff --git a/src/lam/util/reactor.c b/src/lam/util/reactor.c index cf73e24dfb..34a6e008a7 100644 --- a/src/lam/util/reactor.c +++ b/src/lam/util/reactor.c @@ -9,7 +9,7 @@ #include #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); - rd->rd_base.super.obj_class = &lam_reactor_descriptor_cls; + SUPER_INIT(rd, &lam_list_item_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 { - descriptor = (lam_reactor_descriptor_t*)LAM_MALLOC(sizeof(lam_reactor_descriptor_t)); - lam_reactor_descriptor_init(descriptor); + } else { + descriptor = OBJ_CREATE(lam_reactor_descriptor_t, &lam_reactor_descriptor_cls); } 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); - r->r_base.obj_class = &lam_reactor_cls; + SUPER_INIT(r, &lam_object_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; } diff --git a/src/lam/util/reactor.h b/src/lam/util/reactor.h index ab3cb4d67d..21cab9bdaa 100644 --- a/src/lam/util/reactor.h +++ b/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 (*rl_send_handler_fn_t)(int sd, void* user); -typedef void (*rl_except_handler_fn_t)(int sd, void* user); +typedef void (*lam_rl_recv_handler_fn_t)(void* user, int sd); +typedef void (*lam_rl_send_handler_fn_t)(void* user, int sd); +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; - rl_send_handler_fn_t rl_send_handler; - rl_except_handler_fn_t rl_except_handler; + lam_rl_recv_handler_fn_t rl_recv_handler; + lam_rl_send_handler_fn_t rl_send_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); -bool lam_reactor_remove(lam_reactor_t*, int sd, int flags); +int lam_reactor_insert(lam_reactor_t*, int sd, lam_reactor_listener_t*, void* user, 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);