Changeset 658:f198d16fa7f4 in freeDiameter for libfdcore/events.c

Timestamp:

Jan 14, 2011, 3:15:23 PM (13 years ago)

Author:

Sebastien Decugis <sdecugis@nict.go.jp>

Branch:

default

Phase:

public

Message:

Initial commit for 1.1.0:

• Restructuring:
  • libfreeDiameter:
    • renamed folder & binary into libfdproto
    • renamed libfD.h into fdproto-internal.h
    • removed signals management (replaced by triggers in libfdcore)

• freeDiameter split into:
  • libfdcore (most contents)
    • renamed fD.h into fdcore-internal.h
    • added core.c for framework init/shutdown.
    • new triggers mechanism in events.c.

• freeDiameterd (main, command line parsing, signals management)

• tests:
  • now in top-level directory tests.

• other changes:
  • fd_dict_new now returns 0 on duplicate identical entries.
  • fixes in dict_legacy_xml
  • fixes in some dictionaries
  • moved FD_DEFAULT_CONF_FILENAME definition to freeDiameter-host.h

File:

• libfdcore/events.c (moved) (moved from freeDiameter/events.c) (3 diffs)

libfdcore/events.c

@@ -34 +34 @@
 *********************************************************************************************************/
 
-#include "fD.h"
+#include "fdcore-internal.h"
+
+/* Events are a subset of fifo queues, with a known type */
 
 int fd_event_send(struct fifo *queue, int code, size_t datasz, void * data)
@@ -110 +112 @@
                 case_str(FDEV_DUMP_CONFIG);
                 case_str(FDEV_DUMP_PEERS);
+                case_str(FDEV_TRIGGER);
                 
                 default:
@@ -117 +120 @@
 }
 
+/**********************************************************************/
+/* Trigged events */
+/* This allows extensions to register for / send triggers to other extensions */
+/* It is used for example for users interactions (through signals or ...) */
+
+/* Because the number of triggers is not expected to grow, we use a simple ordered chained list */
+static pthread_rwlock_t trig_rwl = PTHREAD_RWLOCK_INITIALIZER;
+static struct fd_list   trig_list = FD_LIST_INITIALIZER(trig_list); /* The list of triggers ordered by trigger value */
+struct trig_item {
+        struct fd_list  chain;
+        int             trig_value;
+        const char *    trig_module;
+        void            (*cb)(void);
+};      
+
+/* Add a new entry in the trigger list */
+int fd_event_trig_regcb(int trigger_val, const char * module, void (*cb)(void))
+{
+        struct trig_item * ti;
+        struct fd_list * li;
+        
+        TRACE_ENTRY("%d %p %p", trigger_val, module, cb);
+        CHECK_PARAMS( trigger_val && cb );
+        
+        /* Create a new trig_item */
+        CHECK_MALLOC( ti = malloc(sizeof(struct trig_item)) );
+        memset(ti, 0, sizeof(struct trig_item));
+        fd_list_init(&ti->chain, ti);
+        ti->trig_value = trigger_val;
+        ti->trig_module = module;
+        ti->cb = cb;
+        
+        /* Now insert in the list */
+        CHECK_POSIX( pthread_rwlock_wrlock(&trig_rwl) );
+        
+        for (li = trig_list.next; li != &trig_list; li = li->next) {
+                struct trig_item *t = li->o;
+                if (t->trig_value >= trigger_val)
+                        break;
+        }
+        
+        fd_list_insert_before(li, &ti->chain);
+        
+        CHECK_POSIX( pthread_rwlock_unlock(&trig_rwl) );
+
+        return 0;
+}
+
+void fd_event_trig_dump()
+{
+        struct fd_list * li;
+        if (!TRACE_BOOL(FULL))
+                return;
+        
+        CHECK_POSIX_DO( pthread_rwlock_rdlock(&trig_rwl),  );
+        
+        for (li = trig_list.next; li != &trig_list; li = li->next) {
+                struct trig_item *t = li->o;
+                fd_log_debug("  Trigger %d, module '%s': %p\n", t->trig_value, t->trig_module, t->cb);
+        }
+        
+        CHECK_POSIX_DO( pthread_rwlock_unlock(&trig_rwl),  );
+}
+
+static void *call_cb_detached(void * arg)
+{
+        void (*cb)(void) = arg;
+        fd_log_threadname("Trig'd callback thread");
+        TRACE_ENTRY("%p", arg);
+        (*cb)();
+        TRACE_DEBUG(ANNOYING, "Callback %p completed", cb);
+}
+
+int fd_event_trig_call_cb(int trigger_val)
+{
+        struct fd_list * li;
+        pthread_attr_t detached;
+        pthread_t th;
+        
+        CHECK_POSIX( pthread_attr_init(&detached) );
+        CHECK_POSIX( pthread_attr_setdetachstate(&detached, PTHREAD_CREATE_DETACHED) );
+        
+        CHECK_POSIX( pthread_rwlock_rdlock(&trig_rwl)  );
+        
+        for (li = trig_list.next; li != &trig_list; li = li->next) {
+                struct trig_item *t = li->o;
+                if (t->trig_value == trigger_val) {
+                        TRACE_DEBUG(FULL, "Trigger %d: Calling %p in %s", t->trig_value, t->cb, t->trig_module);
+                        CHECK_POSIX_DO( pthread_create( &th, &detached, call_cb_detached, t->cb ), break );
+                }
+                if (t->trig_value > trigger_val)
+                        break;
+        }
+        
+        CHECK_POSIX( pthread_rwlock_unlock(&trig_rwl)  );
+        
+        return 0;
+}
+
+int fd_event_trig_fini(void) {
+        
+        TRACE_ENTRY("");
+        
+        CHECK_POSIX( pthread_rwlock_wrlock(&trig_rwl) );
+        
+        while (!FD_IS_LIST_EMPTY(&trig_list)) {
+                struct fd_list * li = trig_list.next;
+                fd_list_unlink(li);
+                free(li);
+        }
+        
+        CHECK_POSIX( pthread_rwlock_unlock(&trig_rwl) );
+        
+        return 0;
+}