Changeset 8:3e143f047f78 in freeDiameter

Timestamp:

Sep 18, 2009, 6:54:07 PM (15 years ago)

Author:

Sebastien Decugis <sdecugis@nict.go.jp>

Branch:

default

Phase:

public

Message:

Backup for the week-end

Files:

• CMakeLists.txt (modified) (3 diffs)
• cmake/Modules/FindGNUTLS.cmake (deleted)
• cmake/Modules/FindSCTP.cmake (modified) (1 diff)
• cmake/Modules/LibFindMacros.cmake (deleted)
• doc/freediameter.conf.sample (added)
• extensions/CMakeLists.txt (added)
• extensions/_sample/CMakeLists.txt (added)
• extensions/_sample/fini.c (added)
• extensions/_sample/sample.c (added)
• freeDiameter/CMakeLists.txt (modified) (2 diffs)
• freeDiameter/config.c (added)
• freeDiameter/extensions.c (added)
• freeDiameter/fD.h (modified) (1 diff)
• freeDiameter/fdd.l (added)
• freeDiameter/fdd.y (added)
• freeDiameter/main.c (modified) (2 diffs)
• freeDiameter/tests/CMakeLists.txt (modified) (3 diffs)
• freeDiameter/tests/testdict.c (modified) (3 diffs)
• freeDiameter/tests/testdisp.c (modified) (1 diff)
• freeDiameter/tests/testmesg.c (modified) (35 diffs)
• freeDiameter/tests/testqueues.c (moved) (moved from freeDiameter/tests/testmq.c) (24 diffs)
• freeDiameter/tests/tests.h (modified) (2 diffs)
• include/freeDiameter/CMakeLists.txt (modified) (1 diff)
• include/freeDiameter/extension.h (added)
• include/freeDiameter/freeDiameter-host.h.in (modified) (2 diffs)
• include/freeDiameter/freeDiameter.h (modified) (1 diff)
• include/freeDiameter/libfreeDiameter.h (modified) (8 diffs)
• libfreeDiameter/CMakeLists.txt (modified) (2 diffs)
• libfreeDiameter/queues.c (moved) (moved from libfreeDiameter/mqueues.c) (18 diffs)

CMakeLists.txt

@@ -3 +3 @@
 # Name of the project, and language
 PROJECT("freeDiameter" C)
+
+# Informations to display in daemon's help
+SET(FD_PROJECT_NAME freeDiameter)
+SET(FD_PROJECT_BINARY freeDiameterd)
+SET(FD_PROJECT_VERSION_MAJOR 0)
+SET(FD_PROJECT_VERSION_MINOR 1)
+SET(FD_PROJECT_VERSION_REV 0)
+SET(FD_PROJECT_COPYRIGHT "Copyright (c) 2008-2009, WIDE Project (www.wide.ad.jp) and NICT (www.nict.go.jp)")
 
 # Some subfolders may have tests
@@ -16 +24 @@
 ADD_DEFINITIONS(-D_GNU_SOURCE)
 
-# Location for the include files
-INCLUDE_DIRECTORIES(include)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/include)
-SUBDIRS(include/freeDiameter)
-
 # some subfolders use yacc and lex parsers
 SET(BISON_GENERATE_DEFINES TRUE)
@@ -33 +36 @@
 # how to do the check with cmake???
 
+# Location for the include files
+INCLUDE_DIRECTORIES(include)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/include)
+SUBDIRS(include/freeDiameter)
+
 # Location for the source code
 SUBDIRS(libfreeDiameter)

cmake/Modules/FindSCTP.cmake

@@ -6 +6 @@
 #  SCTP_LIBRARIES - link these to use SCTP
 
-include(LibFindMacros)
-
-# Use pkg-config to get hints about paths (Note: not yet supported?)
-# libfind_pkg_check_modules(SCTP_PKGCONF sctp)
+if (SCTP_INCLUDE_DIRS)
+  set(SCTP_FIND_QUIETLY TRUE)
+endif (SCTP_INCLUDE_DIRS)
 
 # Include dir
 find_path(SCTP_INCLUDE_DIR
   NAMES netinet/sctp.h
-  PATHS ${SCTP_PKGCONF_INCLUDE_DIRS}
 )
 
-# Finally the library itself
+# Library
 find_library(SCTP_LIBRARY
   NAMES sctp
-  PATHS ${SCTP_PKGCONF_LIBRARY_DIRS}
 )
 
 # Set the include dir variables and the libraries and let libfind_process do the rest.
 # NOTE: Singular variables for this library, plural for libraries this this lib depends on.
-set(SCTP_PROCESS_INCLUDES SCTP_INCLUDE_DIR)
-set(SCTP_PROCESS_LIBS SCTP_LIBRARY)
-libfind_process(SCTP)
+#set(SCTP_PROCESS_INCLUDES SCTP_INCLUDE_DIR)
+#set(SCTP_PROCESS_LIBS SCTP_LIBRARY)
+#libfind_process(SCTP)
+
+
+# handle the QUIETLY and REQUIRED arguments and set SCTP_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SCTP DEFAULT_MSG SCTP_LIBRARY SCTP_INCLUDE_DIR)
+
+# If we successfully found the sctp library then add the library to the
+# SCTP_LIBRARIES cmake variable otherwise set SCTP_LIBRARIES to nothing.
+IF(SCTP_FOUND)
+   SET( SCTP_LIBRARIES ${SCTP_LIBRARY} )
+ELSE(SCTP_FOUND)
+   SET( SCTP_LIBRARIES )
+ENDIF(SCTP_FOUND)
+
+
+# Lastly make it so that the SCTP_LIBRARY and SCTP_INCLUDE_DIR variables
+# only show up under the advanced options in the gui cmake applications.
+MARK_AS_ADVANCED( SCTP_LIBRARY SCTP_INCLUDE_DIR )
+

freeDiameter/CMakeLists.txt

@@ -2 +2 @@
 Project("freeDiameterd" C)
 
-SET(PROJECT_VERSION 0.1)
-SET(PROJECT_COPYRIGHT "Copyright (c) 2008-2009, WIDE Project (www.wide.ad.jp) and NICT (www.nict.go.jp)")
+# Configuration parser
+BISON_FILE(fdd.y)
+FLEX_FILE(fdd.l)
+SET_SOURCE_FILES_PROPERTIES(lex.fdd.c fdd.tab.c PROPERTIES COMPILE_FLAGS "-I ${CMAKE_CURRENT_SOURCE_DIR}")
 
 # List of source files
 SET(FD_COMMON_SRC
         fD.h
+        config.c
+        extensions.c
         dict_base_proto.c
         )
 
+SET(FD_COMMON_GEN_SRC
+                lex.fdd.c
+                fdd.tab.c
+                fdd.tab.h
+        )
+
+
 # Building the executable
-ADD_EXECUTABLE(freeDiameterd ${FD_COMMON_SRC} main.c)
+ADD_EXECUTABLE(freeDiameterd ${FD_COMMON_SRC} ${FD_COMMON_GEN_SRC} main.c)
 
 # The link command
@@ -20 +31 @@
 # Save the list of files, if needed
 SET(FD_COMMON_SRC ${FD_COMMON_SRC} PARENT_SCOPE)
+SET(FD_COMMON_GEN_SRC ${FD_COMMON_GEN_SRC} PARENT_SCOPE)
 
 # The unary tests directory

freeDiameter/fD.h

@@ -42 +42 @@
 #include <freeDiameter/freeDiameter.h>
 
+/* Events codespace for fd_g_config->g_fifo_main */
+enum {
+        FM_TERMINATE = 1000     /* request to terminate */
+};
+
+/* Configuration */
+int fd_conf_init();
+void fd_conf_dump();
+int fd_conf_parse();
+int fddparse(struct fd_config * conf); /* yacc generated */
+
+/* Extensions */
+int fd_ext_init();
+int fd_ext_add( char * filename, char * conffile );
+int fd_ext_load();
+int fd_ext_fini(void);
+
 /* Create all the dictionary objects defined in the Diameter base RFC. */
 int fd_dict_base_protocol(struct dictionary * dict);
 
-
 #endif /* _FD_H */

freeDiameter/main.c

@@ -36 +36 @@
 #include "fD.h"
 
+#include <signal.h>
+#include <getopt.h>
+
+
+/* Display package version */
+static void main_version_core(void)
+{
+        printf("%s, version %d.%d.%d"
+#ifdef HG_VERSION
+                " (r%s"
+# ifdef PACKAGE_HG_REVISION
+                "/%s"
+# endif /* PACKAGE_HG_VERSION */
+                ")"
+#endif /* HG_VERSION */
+                "\n", 
+                FD_PROJECT_NAME, FD_PROJECT_VERSION_MAJOR, FD_PROJECT_VERSION_MINOR, FD_PROJECT_VERSION_REV
+#ifdef HG_VERSION
+                , HG_VERSION
+# ifdef PACKAGE_HG_REVISION
+                , PACKAGE_HG_REVISION
+# endif /* PACKAGE_HG_VERSION */
+#endif /* HG_VERSION */
+                );
+}
+
+/* Display package version and general info */
+static void main_version(void)
+{
+        main_version_core();
+        printf( "%s\n", FD_PROJECT_COPYRIGHT);
+        printf( "\nSee " FD_PROJECT_NAME " homepage at http://aaa.koganei.wide.ad.jp/\n"
+                " for information, updates and bug reports on this software.\n");
+}
+
+/* Print command-line options */
+static void main_help( void )
+{
+        main_version_core();
+        printf( "  This daemon is an implementation of the Diameter protocol\n"
+                "  used for Authentication, Authorization, and Accounting (AAA).\n");
+        printf("\nUsage:  " FD_PROJECT_BINARY " [OPTIONS]...\n");
+        printf( "  -h, --help             Print help and exit\n"
+                "  -V, --version          Print version and exit\n"
+                "  -c, --config=filename  Read configuration from this file instead of the \n"
+                "                           default location (%s).\n", DEFAULT_CONF_FILE);
+        printf( "\nDebug:\n"
+                "  These options are mostly useful for developers\n"
+                "  -d, --debug            Increase verbosity of debug messages\n"
+                "  -q, --quiet            Decrease verbosity then remove debug messages\n");
+}
+
+/* Parse the command-line */
+static int main_cmdline(int argc, char *argv[])
+{
+        int c;
+        int option_index = 0;
+        
+        struct option long_options[] = {
+                { "help",       0, NULL, 'h' },
+                { "version",    0, NULL, 'V' },
+                { "config",     1, NULL, 'c' },
+                { "debug",      0, NULL, 'd' },
+                { "quiet",      0, NULL, 'q' },
+                { NULL, 0, NULL, 0 }
+        };
+        
+        TRACE_ENTRY("%d %p", argc, argv);
+        
+        /* Loop on arguments */
+        while (1) {
+                c = getopt_long (argc, argv, "hVc:dq", long_options, &option_index);
+                if (c == -1) 
+                        break;  /* Exit from the loop.  */
+                
+                switch (c) {
+                        case 'h':       /* Print help and exit.  */
+                                main_help();
+                                exit(0);
+
+                        case 'V':       /* Print version and exit.  */
+                                main_version();
+                                exit(0);
+
+                        case 'c':       /* Read configuration from this file instead of the default location..  */
+                                CHECK_PARAMS( optarg );
+                                fd_g_config->conf_file = optarg;
+                                break;
+
+                        case 'd':       /* Increase verbosity of debug messages.  */
+                                fd_g_debug_lvl++;
+                                break;
+                                
+                        case 'q':       /* Decrease verbosity then remove debug messages.  */
+                                fd_g_debug_lvl--;
+                                break;
+
+                        case '?':       /* Invalid option.  */
+                                /* `getopt_long' already printed an error message.  */
+                                TRACE_DEBUG(INFO, "getopt_long found an invalid character\n");
+                                return EINVAL;
+
+                        default:        /* bug: option not considered.  */
+                                TRACE_DEBUG(INFO, "A command-line option is missing in parser: %c\n", c);
+                                ASSERT(0);
+                                return EINVAL;
+                }
+        }
+                
+        return 0;
+        
+}
+
+#ifdef HAVE_SIGNALENT_H
+const char *const signalstr[] = {
+# include "signalent.h"
+};
+const int nsignalstr = sizeof signalstr / sizeof signalstr[0];
+# define SIGNALSTR(sig) (((sig) < nsignalstr) ? signalstr[(sig)] : "unknown")
+#else /* HAVE_SIGNALENT_H */
+# define SIGNALSTR(sig) ("")
+#endif /* HAVE_SIGNALENT_H */
+
+
+/* signal handler */
+static void * sig_hdl(void * arg)
+{
+        sigset_t sig_main;
+        int sig = 0;
+        
+        TRACE_ENTRY();
+        fd_log_threadname("Main signal handler");
+        
+        sigemptyset(&sig_main);
+        sigaddset(&sig_main, SIGINT);
+        sigaddset(&sig_main, SIGTERM);
+        
+        CHECK_SYS_DO(  sigwait(&sig_main, &sig), TRACE_DEBUG(INFO, "Error in sigwait function") );
+        
+        TRACE_DEBUG(INFO, "Received signal %s (%d), exiting", SIGNALSTR(sig), sig);
+        CHECK_FCT_DO( fd_event_send(fd_g_config->g_fifo_main, FM_TERMINATE, NULL), exit(2) );
+        return NULL;
+}
+        
+/* The static configuration structure */
+static struct fd_config conf;
+struct fd_config * fd_g_config = &conf;
+
 /* Entry point */
 int main(int argc, char * argv[])
 {
+        int ret;
+        pthread_t sig_th;
+        sigset_t sig_all;
+        
+        memset(fd_g_config, 0, sizeof(struct fd_config));
+        sigfillset(&sig_all);
+        CHECK_POSIX(  pthread_sigmask(SIG_BLOCK, &sig_all, NULL)  );
+        
         /* Initialize the library */
         CHECK_FCT( fd_lib_init() );
@@ -44 +200 @@
         /* Name this thread */
         fd_log_threadname("Main");
-
-        /* Initialize the dictionary */
-        CHECK_FCT( fd_dict_init(&fd_g_dict) );
+        
+        /* Initialize the config */
+        CHECK_FCT( fd_conf_init() );
+
+        /* Parse the command-line */
+        CHECK_FCT(  main_cmdline(argc, argv)  );
+        
+        /* Allow SIGINT and SIGTERM from this point */
+        CHECK_POSIX(  pthread_create(&sig_th, NULL, sig_hdl, NULL)  );
         
         /* Add definitions of the base protocol */
-        CHECK_FCT( fd_dict_base_protocol(fd_g_dict) );
-        
-        TRACE_DEBUG(INFO, "freeDiameter daemon initialized.");
-        
-        return 0;
-}
+        CHECK_FCT( fd_dict_base_protocol(fd_g_config->g_dict) );
+        
+        /* Initialize other modules */
+        CHECK_FCT(  fd_ext_init()  );
+        
+        /* Parse the configuration file */
+        CHECK_FCT( fd_conf_parse() );
+        
+        /* Load the dynamic extensions */
+        CHECK_FCT(  fd_ext_load()  );
+        
+        /* Start the peer state machines */
+        
+        
+        /* Now, just wait for events */
+        TRACE_DEBUG(INFO, FD_PROJECT_BINARY " daemon initialized.");
+        fd_conf_dump();
+        while (1) {
+                int code;
+                CHECK_FCT_DO(  fd_event_get(fd_g_config->g_fifo_main, &code, NULL),  break  );
+                switch (code) {
+                        case FM_TERMINATE:
+                                ret = 0;
+                                goto end;
+                        
+                        default:
+                                TRACE_DEBUG(INFO, "Unexpected event in the daemon (%d), terminating.\n", code);
+                                ret = -1;
+                                goto end;
+                }
+        }
+        
+end:
+        TRACE_DEBUG(INFO, FD_PROJECT_BINARY " daemon is stopping...");
+        
+        /* cleanups */
+        CHECK_FCT( fd_thr_term(&sig_th) );
+        
+        return ret;
+}

freeDiameter/tests/CMakeLists.txt

@@ -15 +15 @@
         testdict
         testmesg
-        testmq
+        testqueues
         testsess
         testdisp
@@ -29 +29 @@
 INCLUDE_DIRECTORIES( "../../libfreeDiameter" )
 
+BISON_FILE(../fdd.y)
+FLEX_FILE(../fdd.l)
+
 SET(TEST_COMMON_SRC "")
 
@@ -35 +38 @@
 ENDFOREACH(SRC_FILE)
 
-# FOREACH( SRC_FILE ${FD_COMMON_GEN_SRC})
-#    SET(TEST_COMMON_SRC ${TEST_COMMON_SRC} "${CMAKE_CURRENT_BINARY_DIR}/../${SRC_FILE}")
-# ENDFOREACH(SRC_FILE)
+FOREACH( SRC_FILE ${FD_COMMON_GEN_SRC})
+   SET(TEST_COMMON_SRC ${TEST_COMMON_SRC} "${CMAKE_CURRENT_BINARY_DIR}/../${SRC_FILE}")
+ENDFOREACH(SRC_FILE)
 
 FOREACH( SRC_FILE ${LFD_SRC})

freeDiameter/tests/testdict.c

@@ -67 +67 @@
                 
                 /* Create two vendors */
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_VENDOR, &vendor1_data , NULL, &obj1 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_VENDOR, &vendor2_data , NULL, NULL ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_VENDOR, &vendor1_data , NULL, &obj1 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_VENDOR, &vendor2_data , NULL, NULL ) );
                 
                 /* Check we always retrieve the correct vendor object */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, &obj2, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, &obj2, ENOENT ) );
                 CHECK( obj1, obj2);
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 1", &obj2, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 1", &obj2, ENOENT ) );
                 CHECK( obj1, obj2);
                 
                 /* Check the error conditions */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, NULL, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, NULL, ENOENT ) );
                 
                 vendor_id = 735673; /* Not defined */
-                CHECK( ENOENT, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, NULL, ENOENT ) );
-                CHECK( ENOENT, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", NULL, ENOENT ) );
-                CHECK( ENOENT, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, &obj2, ENOENT ) );
-                CHECK( ENOENT, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", &obj2, ENOENT ) );
-                CHECK( ENOTSUP, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", &obj2, ENOTSUP ) );
+                CHECK( ENOENT, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, NULL, ENOENT ) );
+                CHECK( ENOENT, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", NULL, ENOENT ) );
+                CHECK( ENOENT, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, &obj2, ENOENT ) );
+                CHECK( ENOENT, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", &obj2, ENOENT ) );
+                CHECK( ENOTSUP, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", &obj2, ENOTSUP ) );
                 
                 /* Check the get_* functions */
@@ -94 +94 @@
                 
                 /* Create the application with vendor1 as parent */
-                CHECK( EINVAL, fd_dict_new ( fd_g_dict, DICT_APPLICATION, &app1_data , (struct dict_object *)"bad object", &obj2 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_APPLICATION, &app1_data , obj1, &obj2 ) );
+                CHECK( EINVAL, fd_dict_new ( fd_g_config->g_dict, DICT_APPLICATION, &app1_data , (struct dict_object *)"bad object", &obj2 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_APPLICATION, &app1_data , obj1, &obj2 ) );
                 
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_VENDOR, VENDOR_OF_APPLICATION, obj2, &obj3, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_VENDOR, VENDOR_OF_APPLICATION, obj2, &obj3, ENOENT ) );
                 CHECK( obj1, obj3);
                 
@@ -112 +112 @@
                 struct dict_avp_data example_avp_data = { 999999, 0, "Example-AVP", AVP_FLAG_VENDOR , 0, AVP_TYPE_GROUPED };
 
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_AVP, AVP_BY_NAME, "Origin-Host", &origin_host_avp, ENOENT ) );
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_AVP, AVP_BY_NAME, "Session-Id", &session_id_avp, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME, "Origin-Host", &origin_host_avp, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME, "Session-Id", &session_id_avp, ENOENT ) );
                 
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &example_avp_data , NULL, &example_avp_avp ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &example_avp_data , NULL, &example_avp_avp ) );
                 
                 rule_data.rule_avp = origin_host_avp;
                 rule_data.rule_min = 1;
                 rule_data.rule_max = 1;
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_RULE, &rule_data, example_avp_avp, NULL ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_RULE, &rule_data, example_avp_avp, NULL ) );
                 
                 rule_data.rule_avp = session_id_avp;
                 rule_data.rule_min = 1;
                 rule_data.rule_max = -1;
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_RULE, &rule_data, example_avp_avp, NULL ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_RULE, &rule_data, example_avp_avp, NULL ) );
                 
                 CHECK( 0, fd_dict_iterate_rules ( example_avp_avp, &nbr, iter_test) );

freeDiameter/tests/testdisp.c

@@ -128 +128 @@
                 struct dict_enumval_data enu2_data = { "ENU test 2", { .u32 = 2 }};
                 
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_APPLICATION, &app1_data, NULL, &app1 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_APPLICATION, &app2_data, NULL, &app2 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_COMMAND, &cmd1_data, NULL, &cmd1 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_COMMAND, &cmd2_data, NULL, &cmd2 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_TYPE, &type_data, NULL, &enutype ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp1_data, NULL,    &avp1 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp2_data, enutype, &avp2 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_ENUMVAL, &enu1_data, enutype, &enu1 ) );
-                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_ENUMVAL, &enu2_data, enutype, &enu2 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_APPLICATION, &app1_data, NULL, &app1 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_APPLICATION, &app2_data, NULL, &app2 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_COMMAND, &cmd1_data, NULL, &cmd1 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_COMMAND, &cmd2_data, NULL, &cmd2 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_TYPE, &type_data, NULL, &enutype ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp1_data, NULL,    &avp1 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp2_data, enutype, &avp2 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_ENUMVAL, &enu1_data, enutype, &enu1 ) );
+                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_ENUMVAL, &enu2_data, enutype, &enu2 ) );
         }
         

freeDiameter/tests/testmesg.c

@@ -51 +51 @@
 
                 /* Now find the ACR dictionary object */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Accounting-Request", &acr_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Accounting-Request", &acr_model, ENOENT ) );
 
                 /* Create the instance, using the templates */
@@ -71 +71 @@
 
                 /* Now find the ACR dictionary object */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_AVP, AVP_BY_NAME, "Proxy-Info", &pi_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME, "Proxy-Info", &pi_model, ENOENT ) );
 
                 /* Create the instance, using the templates */
@@ -133 +133 @@
 
                 /* Now find the dictionary object */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_AVP, AVP_BY_NAME, "Route-Record", &rr_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME, "Route-Record", &rr_model, ENOENT ) );
 
                 /* Create the instance, using the templates */
@@ -161 +161 @@
 
                 /* Now find the ACR dictionary object */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Accounting-Request", &acr_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Accounting-Request", &acr_model, ENOENT ) );
 
                 /* Create the instance, using the templates */
@@ -173 +173 @@
                 {
                         struct dict_vendor_data vendor_data = { 73565, "Vendor test" };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_VENDOR, &vendor_data , NULL, &vendor ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_VENDOR, &vendor_data , NULL, &vendor ) );
                 }
                 
                 {
                         struct dict_application_data app_data = { 73566, "Application test" };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_APPLICATION, &app_data , vendor, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_APPLICATION, &app_data , vendor, NULL ) );
                 }
                 
                 {
                         struct dict_avp_data avp_data = { 73567, 0, "AVP Test - no vendor - f32", 0, 0, AVP_TYPE_FLOAT32 };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
                 }
                 
@@ -190 +190 @@
                         struct dict_type_data type_data = { AVP_TYPE_INTEGER64, "Int64 test" };
                         struct dict_avp_data  avp_data = { 73568, 73565, "AVP Test - i64", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_INTEGER64 };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_TYPE, &type_data , NULL, &type ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_TYPE, &type_data , NULL, &type ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , type, NULL ) );
                 }
                 
@@ -202 +202 @@
                         struct dict_avp_data     avp_data = { 73569, 73565, "AVP Test - enumi32", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_INTEGER32 };
                         
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_TYPE, &type_data , NULL, &type ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , type, NULL ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_ENUMVAL, &val1 , type, NULL ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_ENUMVAL, &val2 , type, NULL ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_ENUMVAL, &val3 , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_TYPE, &type_data , NULL, &type ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_ENUMVAL, &val1 , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_ENUMVAL, &val2 , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_ENUMVAL, &val3 , type, NULL ) );
                 }
                         
@@ -213 +213 @@
                         struct dict_type_data type_data = { AVP_TYPE_OCTETSTRING, "OS test" };
                         struct dict_avp_data  avp_data = { 73570, 73565, "AVP Test - os", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_OCTETSTRING };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_TYPE, &type_data , NULL, &type ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_TYPE, &type_data , NULL, &type ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , type, NULL ) );
                 }
                 
@@ -225 +225 @@
                         struct dict_avp_data     avp_data = { 73571, 73565, "AVP Test - enumos", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_OCTETSTRING };
                         
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_TYPE, &type_data , NULL, &type ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , type, NULL ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_ENUMVAL, &val1 , type, NULL ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_ENUMVAL, &val2 , type, NULL ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_ENUMVAL, &val3 , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_TYPE, &type_data , NULL, &type ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_ENUMVAL, &val1 , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_ENUMVAL, &val2 , type, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_ENUMVAL, &val3 , type, NULL ) );
                 }
                 
@@ -236 +236 @@
                         struct dict_avp_data avp_data = { 73572, 73565, "AVP Test - grouped", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_GROUPED };
                         
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, &gavp ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, &gavp ) );
                         
                         /* Macro to search AVP and create a rule */             
@@ -243 +243 @@
                                 struct dict_avp_request _req = { (_vendor), 0, (_avpname) };                    \
                                 struct dict_rule_data _data;                                                    \
-                                CHECK( 0, fd_dict_search( fd_g_dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &_req, &_avp, ENOENT));\
+                                CHECK( 0, fd_dict_search( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &_req, &_avp, ENOENT));\
                                 _data.rule_avp = _avp;                                                          \
                                 _data.rule_position = (_pos);                                                   \
@@ -249 +249 @@
                                 _data.rule_min = (_min);                                                        \
                                 _data.rule_max = (_max);                                                        \
-                                CHECK( 0, fd_dict_new ( fd_g_dict, DICT_RULE, &_data , (_parent), NULL ) );     \
+                                CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_RULE, &_data , (_parent), NULL ) );   \
                         }
                         
@@ -261 +261 @@
                         struct dict_cmd_data  cmd_data = { 73573, "Test-Command-Request", CMD_FLAG_REQUEST, CMD_FLAG_REQUEST };
                         
-                        CHECK( 0, fd_dict_search ( fd_g_dict, DICT_APPLICATION, APPLICATION_BY_NAME, "Application test", &application, ENOENT ) );
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_COMMAND, &cmd_data , application, &command ) );
+                        CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_APPLICATION, APPLICATION_BY_NAME, "Application test", &application, ENOENT ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_COMMAND, &cmd_data , application, &command ) );
                         ADD_RULE(command, 0,     "AVP Test - no vendor - f32",  RULE_FIXED_HEAD, -1,  1,  1);
                         ADD_RULE(command, 73565, "AVP Test - i64",              RULE_REQUIRED,   -1, -1,  0);
@@ -275 +275 @@
                         struct dict_avp_data  avp_data = { 73574, 73565, "AVP Test - rules", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_GROUPED };
                         
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, &gavp ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, &gavp ) );
                         
                         ADD_RULE(gavp,     0, "AVP Test - no vendor - f32", RULE_FIXED_HEAD,   0, 1, 1);
@@ -303 +303 @@
                 union avp_value      value;
                 
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Test-Command-Request", &cmd_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Test-Command-Request", &cmd_model, ENOENT ) );
                 
                 /* Check an error is trigged if the AVP has no value set */
                 {
-                        CHECK( 0, fd_dict_search ( fd_g_dict, DICT_AVP,     AVP_BY_NAME,     "AVP Test - no vendor - f32", &avp_model, ENOENT ) );
+                        CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_AVP,     AVP_BY_NAME,     "AVP Test - no vendor - f32", &avp_model, ENOENT ) );
                         
                         CHECK( 0, fd_msg_new ( cmd_model, 0, &msg ) );
@@ -329 +329 @@
                                 struct dict_object * _avp = NULL;                                               \
                                 struct dict_avp_request _req = { (_avpvendor), 0, (_avpname) };                 \
-                                CHECK( 0, fd_dict_search( fd_g_dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &_req, &_avp, ENOENT));\
+                                CHECK( 0, fd_dict_search( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &_req, &_avp, ENOENT));\
                                 CHECK( 0, fd_msg_avp_new ( _avp, 0, &_avpi ) );                                 \
                                 CHECK( 0, fd_msg_avp_add ( (_parent), (_position), _avpi ) );                   \
@@ -378 +378 @@
                                 
                                 CHECK( 0, fd_msg_model ( avpi, &avp_model ) );
-                                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
+                                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
                                 memset(&request, 0, sizeof(request));
                                 request.type_obj = type_model;
                                 request.search.enum_name = "i32 const test (val 2)";
-                                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
+                                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
                                 CHECK( 0, fd_dict_getval ( value_model, &request.search ) );
                                 CHECK( 0, fd_msg_avp_setvalue ( avpi, &request.search.enum_value ) );
@@ -399 +399 @@
                                 
                                 CHECK( 0, fd_msg_model ( avpi, &avp_model ) );
-                                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
+                                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
                                 memset(&request, 0, sizeof(request));
                                 request.type_obj = type_model;
                                 request.search.enum_name = "i32 const test (val -5)";
-                                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
+                                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
                                 CHECK( 0, fd_dict_getval ( value_model, &request.search ) );
                                 CHECK( 0, fd_msg_avp_setvalue ( avpi, &request.search.enum_value ) );
@@ -458 +458 @@
                                 
                                 CHECK( 0, fd_msg_model ( avpi, &avp_model ) );
-                                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
+                                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
                                 memset(&request, 0, sizeof(request));
                                 request.type_obj = type_model;
                                 request.search.enum_name = "os const test (waaad)";
-                                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
+                                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
                                 CHECK( 0, fd_dict_getval ( value_model, &request.search ) );
                                 CHECK( 0, fd_msg_avp_setvalue ( avpi, &request.search.enum_value ) );
@@ -483 +483 @@
                                 
                                 CHECK( 0, fd_msg_model ( avpi, &avp_model ) );
-                                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
+                                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
                                 memset(&request, 0, sizeof(request));
                                 request.type_obj = type_model;
                                 request.search.enum_name = "os const test (waa)";
-                                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
+                                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
                                 CHECK( 0, fd_dict_getval ( value_model, &request.search ) );
                                 CHECK( 0, fd_msg_avp_setvalue ( avpi, &request.search.enum_value ) );
@@ -654 +654 @@
                         
                         /* Now find the ACR dictionary object */
-                        CHECK( 0, fd_dict_search ( fd_g_dict, DICT_AVP, AVP_BY_NAME, "AVP Test - no vendor - f32", &avp_model, ENOENT ) );
+                        CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME, "AVP Test - no vendor - f32", &avp_model, ENOENT ) );
                         
                         CPYBUF();
@@ -680 +680 @@
                                 buf_cpy[5] = 0x11;
                                 CHECK( 0, fd_msg_parse_buffer( &buf_cpy, 344, &msg) );
-                                CHECK( ENOTSUP, fd_msg_parse_dict( msg, fd_g_dict ) );
+                                CHECK( ENOTSUP, fd_msg_parse_dict( msg, fd_g_config->g_dict ) );
                                 
                                 /* reset */
@@ -695 +695 @@
                                 /* Check that we cannot support this message now */
                                 CHECK( 0, fd_msg_parse_buffer( &buf_cpy, 344, &msg) );
-                                CHECK( ENOTSUP, fd_msg_parse_dict( msg, fd_g_dict ) );
+                                CHECK( ENOTSUP, fd_msg_parse_dict( msg, fd_g_config->g_dict ) );
                                 
                                 /* reset */
@@ -709 +709 @@
                                 /* Check that we can support this message now */
                                 CHECK( 0, fd_msg_parse_buffer( &buf_cpy, 344, &msg) );
-                                CHECK( 0, fd_msg_parse_dict( msg, fd_g_dict ) );
+                                CHECK( 0, fd_msg_parse_dict( msg, fd_g_config->g_dict ) );
                                 
                                 #if 0
@@ -720 +720 @@
                         
                         CHECK( 0, fd_msg_parse_buffer( &buf, 344, &msg) );
-                        CHECK( 0, fd_msg_parse_dict( msg, fd_g_dict ) );
+                        CHECK( 0, fd_msg_parse_dict( msg, fd_g_config->g_dict ) );
                         #if 0
                         fd_msg_dump_walk(0, msg);
@@ -730 +730 @@
                         struct dict_object * rule;
                         
-                        CHECK( 0, fd_msg_parse_rules( msg, fd_g_dict, &rule ) );
+                        CHECK( 0, fd_msg_parse_rules( msg, fd_g_config->g_dict, &rule ) );
                         
                         /* Use the "AVP Test - rules" AVP to test the rules */
@@ -749 +749 @@
                                 
                                 /* Check the message is still conform */
-                                CHECK( 0, fd_msg_parse_rules( msg, fd_g_dict, &rule ) );
+                                CHECK( 0, fd_msg_parse_rules( msg, fd_g_config->g_dict, &rule ) );
                                 
                                 /* The first avp is optional in fixed position, so remove it and check the message is still OK */
                                 CHECK( 0, fd_msg_browse ( tavp, MSG_BRW_FIRST_CHILD, &childavp, NULL) );
                                 CHECK( 0, fd_msg_free ( childavp ) );
-                                CHECK( 0, fd_msg_parse_rules( msg, fd_g_dict, &rule ) );
+                                CHECK( 0, fd_msg_parse_rules( msg, fd_g_config->g_dict, &rule ) );
                                 ADD_AVP( tavp, MSG_BRW_FIRST_CHILD, childavp,     0, "AVP Test - no vendor - f32" );
                                 
@@ -761 +761 @@
                                 #define CHECK_CONFLICT( _msg, _ruleavp, _avpvendor )            {                               \
                                         struct dict_object * _rule;                                                             \
-                                        CHECK( EBADMSG,  fd_msg_parse_rules( _msg, fd_g_dict, &_rule ) );                       \
+                                        CHECK( EBADMSG,  fd_msg_parse_rules( _msg, fd_g_config->g_dict, &_rule ) );                     \
                                         if ((_ruleavp) == NULL) {                                                               \
                                                 CHECK( NULL, _rule);                                                            \
@@ -768 +768 @@
                                                 struct dict_object *    _avp;                                                   \
                                                 struct dict_avp_request _req = { (_avpvendor), 0, (_ruleavp) };                 \
-                                                CHECK( 0, fd_dict_search( fd_g_dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &_req, &_avp, ENOENT));  \
+                                                CHECK( 0, fd_dict_search( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &_req, &_avp, ENOENT));        \
                                                 CHECK( 0, fd_dict_getval( _rule, &_ruledata ) );                                \
                                                 CHECK( _avp, _ruledata.rule_avp );                                              \
@@ -824 +824 @@
                                         
                                         /* The message is still conform */
-                                        CHECK( 0, fd_msg_parse_rules( msg, fd_g_dict, &rule ) );
+                                        CHECK( 0, fd_msg_parse_rules( msg, fd_g_config->g_dict, &rule ) );
                                         
                                         /* Now break the rule */
@@ -865 +865 @@
                 
                 /* Find the CER dictionary object */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &cer_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &cer_model, ENOENT ) );
 
                 /* Now find the Host-IP-Address dictionary object */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_AVP, AVP_BY_NAME, "Host-IP-Address", &hia_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_AVP, AVP_BY_NAME, "Host-IP-Address", &hia_model, ENOENT ) );
 
                 /* Create the msg instance */
@@ -945 +945 @@
                 /* Ok, now let's recreate the message */
                 CHECK( 0, fd_msg_parse_buffer( &buf, 64, &cer) );
-                CHECK( 0, fd_msg_parse_dict( cer, fd_g_dict ) );
+                CHECK( 0, fd_msg_parse_dict( cer, fd_g_config->g_dict ) );
                 
                 /* Get the pointers to the first and last AVP */
@@ -972 +972 @@
                 {
                         struct dict_avp_data avp_data = { 91001, 0, "AVP Test 2 - os", 0, 0, AVP_TYPE_OCTETSTRING };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
                 }
                 {
                         struct dict_avp_data avp_data = { 91002, 0, "AVP Test 2 - i32", 0, 0, AVP_TYPE_INTEGER32 };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
                 }
                 {
                         struct dict_avp_data avp_data = { 91003, 0, "AVP Test 2 - i64", 0, 0, AVP_TYPE_INTEGER64 };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
                 }
                 {
                         struct dict_avp_data avp_data = { 91004, 0, "AVP Test 2 - u32", 0, 0, AVP_TYPE_UNSIGNED32 };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
                 }
                 {
                         struct dict_avp_data avp_data = { 91005, 0, "AVP Test 2 - u64", 0, 0, AVP_TYPE_UNSIGNED64 };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
                 }
                 {
                         struct dict_avp_data avp_data = { 91006, 0, "AVP Test 2 - f32", 0, 0, AVP_TYPE_FLOAT32 };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
                 }
                 {
                         struct dict_avp_data avp_data = { 91007, 0, "AVP Test 2 - f64", 0, 0, AVP_TYPE_FLOAT64 };
-                        CHECK( 0, fd_dict_new ( fd_g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
+                        CHECK( 0, fd_dict_new ( fd_g_config->g_dict, DICT_AVP, &avp_data , NULL, NULL ) );
                 }
                 
@@ -1010 +1010 @@
                         struct msg_hdr     * msgdata = NULL;
 
-                        CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Test-Command-Request", &cmd_model, ENOENT ) );
+                        CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Test-Command-Request", &cmd_model, ENOENT ) );
 
                         /* Create a message */
@@ -1175 +1175 @@
                         
                         CHECK( 0, fd_msg_parse_buffer( &buf, 148, &msg) );
-                        CHECK( 0, fd_msg_parse_dict( msg, fd_g_dict ) );
+                        CHECK( 0, fd_msg_parse_dict( msg, fd_g_config->g_dict ) );
                         #if 0
                         fd_msg_dump_walk(0, msg);

freeDiameter/tests/testqueues.c

@@ -38 +38 @@
 /* Structure for testing threshold function */
 static struct thrh_test {
-        struct mqueue * queue; /* pointer to the queue */
+        struct fifo *   queue; /* pointer to the queue */
         int             h_calls; /* number of calls of h_cb */
         int             l_calls; /* number of calls of l_cb */
@@ -44 +44 @@
 
 /* Callbacks for threasholds test */
-void thrh_cb_h(struct mqueue *queue, void **data)
+void thrh_cb_h(struct fifo *queue, void **data)
 {
         if (thrh_td.h_calls == thrh_td.l_calls) {
@@ -57 +57 @@
         thrh_td.h_calls ++;
 }
-void thrh_cb_l(struct mqueue *queue, void **data)
+void thrh_cb_l(struct fifo *queue, void **data)
 {
         CHECK( 1, data ? 1 : 0 );
@@ -76 +76 @@
 /* Structure that is passed to the test function */
 struct test_data {
-        struct mqueue     * queue; /* pointer to the queue */
+        struct fifo     * queue; /* pointer to the queue */
         pthread_barrier_t * bar;   /* if not NULL, barrier to synchronize before getting messages */
         struct timespec   * ts;    /* if not NULL, use a timedget instead of a get */
@@ -100 +100 @@
         for (i=0; i< td->nbr; i++) {
                 if (td->ts != NULL) {
-                        CHECK( 0, fd_mq_timedget(td->queue, &msg, td->ts) );
+                        CHECK( 0, fd_fifo_timedget(td->queue, &msg, td->ts) );
                 } else {
-                        CHECK( 0, fd_mq_get(td->queue, &msg) );
+                        CHECK( 0, fd_fifo_get(td->queue, &msg) );
                 }
         }
@@ -128 +128 @@
                 struct dict_object * dwr_model = NULL;
 
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Accounting-Request",                  &acr_model, ENOENT ) );
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request",       &cer_model, ENOENT ) );
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Device-Watchdog-Request",             &dwr_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Accounting-Request",                        &acr_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request",     &cer_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Device-Watchdog-Request",           &dwr_model, ENOENT ) );
                 CHECK( 0, fd_msg_new ( acr_model, 0, &msg1 ) );
                 CHECK( 0, fd_msg_new ( cer_model, 0, &msg2 ) );
@@ -138 +138 @@
         /* Basic operation */
         {
-                struct mqueue * queue = NULL;
+                struct fifo * queue = NULL;
                 int count;
                 struct msg * msg  = NULL;
                 
                 /* Create the queue */
-                CHECK( 0, fd_mq_new(&queue) );
+                CHECK( 0, fd_fifo_new(&queue) );
                 
                 /* Check the count is 0 */
-                CHECK( 0, fd_mq_length(queue, &count) );
+                CHECK( 0, fd_fifo_length(queue, &count) );
                 CHECK( 0, count);
                 
                 /* Now enqueue */
                 msg = msg1;
-                CHECK( 0, fd_mq_post(queue, &msg) );
+                CHECK( 0, fd_fifo_post(queue, &msg) );
                 msg = msg2;
-                CHECK( 0, fd_mq_post(queue, &msg) );
+                CHECK( 0, fd_fifo_post(queue, &msg) );
                 msg = msg3;
-                CHECK( 0, fd_mq_post(queue, &msg) );
+                CHECK( 0, fd_fifo_post(queue, &msg) );
                 
                 /* Check the count is 3 */
-                CHECK( 0, fd_mq_length(queue, &count) );
+                CHECK( 0, fd_fifo_length(queue, &count) );
                 CHECK( 3, count);
                 
-                /* Retrieve the first message using fd_mq_get */
-                CHECK( 0, fd_mq_get(queue, &msg) );
+                /* Retrieve the first message using fd_fifo_get */
+                CHECK( 0, fd_fifo_get(queue, &msg) );
                 CHECK( msg1, msg);
-                CHECK( 0, fd_mq_length(queue, &count) );
+                CHECK( 0, fd_fifo_length(queue, &count) );
                 CHECK( 2, count);
                 
-                /* Retrieve the second message using fd_mq_timedget */
+                /* Retrieve the second message using fd_fifo_timedget */
                 CHECK(0, clock_gettime(CLOCK_REALTIME, &ts));
                 ts.tv_sec += 1; /* Set the timeout to 1 second */
-                CHECK( 0, fd_mq_timedget(queue, &msg, &ts) );
+                CHECK( 0, fd_fifo_timedget(queue, &msg, &ts) );
                 CHECK( msg2, msg);
-                CHECK( 0, fd_mq_length(queue, &count) );
+                CHECK( 0, fd_fifo_length(queue, &count) );
                 CHECK( 1, count);
                 
                 /* Retrieve the third message using meq_tryget */
-                CHECK( 0, fd_mq_tryget(queue, &msg) );
+                CHECK( 0, fd_fifo_tryget(queue, &msg) );
                 CHECK( msg3, msg);
-                CHECK( 0, fd_mq_length(queue, &count) );
+                CHECK( 0, fd_fifo_length(queue, &count) );
                 CHECK( 0, count);
                 
                 /* Check that another meq_tryget does not block */
-                CHECK( EWOULDBLOCK, fd_mq_tryget(queue, &msg) );
-                CHECK( 0, fd_mq_length(queue, &count) );
+                CHECK( EWOULDBLOCK, fd_fifo_tryget(queue, &msg) );
+                CHECK( 0, fd_fifo_length(queue, &count) );
                 CHECK( 0, count);
                 
                 /* We're done for basic tests */
-                CHECK( 0, fd_mq_del(&queue) );
+                CHECK( 0, fd_fifo_del(&queue) );
         }
         
@@ -194 +194 @@
 #define NBR_MSG         200
 #define NBR_THREADS     60
-                struct mqueue           *queue = NULL;
+                struct fifo             *queue = NULL;
                 pthread_barrier_t        bar;
                 struct test_data         td_1;
@@ -205 +205 @@
                 
                 /* Create the queue */
-                CHECK( 0, fd_mq_new(&queue) );
+                CHECK( 0, fd_fifo_new(&queue) );
                 
                 /* Create the barrier */
@@ -215 +215 @@
                 
                 /* Create the messages */
-                CHECK( 0, fd_dict_search ( fd_g_dict, DICT_COMMAND, CMD_BY_NAME, "Device-Watchdog-Request",             &dwr_model, ENOENT ) );
+                CHECK( 0, fd_dict_search ( fd_g_config->g_dict, DICT_COMMAND, CMD_BY_NAME, "Device-Watchdog-Request",           &dwr_model, ENOENT ) );
                 for (i = 0; i < NBR_MSG * NBR_THREADS * 2; i++) {
                         CHECK( 0, fd_msg_new ( dwr_model, 0, &msgs[i] ) );
@@ -248 +248 @@
                 for (i=0; i < NBR_MSG * NBR_THREADS * 2; i++) {
                         msg = msgs[i];
-                        CHECK( 0, fd_mq_post(queue, &msg) );
+                        CHECK( 0, fd_fifo_post(queue, &msg) );
                 }
                 
@@ -257 +257 @@
                 
                 /* Check the count of the queue is back to 0 */
-                CHECK( 0, fd_mq_length(queue, &count) );
+                CHECK( 0, fd_fifo_length(queue, &count) );
                 CHECK( 0, count);
                 
                 /* Destroy this queue and the messages */
-                CHECK( 0, fd_mq_del(&queue) );
+                CHECK( 0, fd_fifo_del(&queue) );
                 for (i=0; i < NBR_MSG * NBR_THREADS * 2; i++) {
                         CHECK( 0, fd_msg_free(  msgs[i] ) );
@@ -269 +269 @@
         /* Test thread cancelation */
         {
-                struct mqueue           *queue = NULL;
+                struct fifo             *queue = NULL;
                 pthread_barrier_t        bar;
                 struct test_data         td;
@@ -275 +275 @@
                 
                 /* Create the queue */
-                CHECK( 0, fd_mq_new(&queue) );
+                CHECK( 0, fd_fifo_new(&queue) );
                 
                 /* Create the barrier */
@@ -332 +332 @@
                 
                 /* Destroy the queue */
-                CHECK( 0, fd_mq_del(&queue) );
+                CHECK( 0, fd_fifo_del(&queue) );
         }
         
         /* Test the threashold function */
         {
-                struct mqueue * queue = NULL;
+                struct fifo * queue = NULL;
                 int i;
                 struct msg * msg  = NULL;
                 
                 /* Create the queue */
-                CHECK( 0, fd_mq_new(&queue) );
+                CHECK( 0, fd_fifo_new(&queue) );
                 
                 /* Prepare the test data */
@@ -349 +349 @@
                 
                 /* Set the thresholds for the queue */
-                CHECK( 0, fd_mq_setthrhd ( queue, NULL, 6, thrh_cb_h, 4, thrh_cb_l ) );
+                CHECK( 0, fd_fifo_setthrhd ( queue, NULL, 6, thrh_cb_h, 4, thrh_cb_l ) );
                 
                 /* Post 5 messages, no cb must be called. */
                 for (i=0; i<5; i++) {
                         msg = msg1;
-                        CHECK( 0, fd_mq_post(queue, &msg) );
+                        CHECK( 0, fd_fifo_post(queue, &msg) );
                 } /* 5 msg in queue */
                 CHECK( 0, thrh_td.h_calls );
@@ -361 +361 @@
                 /* Get all these messages, and check again */
                 for (i=0; i<5; i++) {
-                        CHECK( 0, fd_mq_get(queue, &msg) );
+                        CHECK( 0, fd_fifo_get(queue, &msg) );
                 } /* 0 msg in queue */
                 CHECK( 0, thrh_td.h_calls );
@@ -369 +369 @@
                 for (i=0; i<6; i++) {
                         msg = msg1;
-                        CHECK( 0, fd_mq_post(queue, &msg) );
+                        CHECK( 0, fd_fifo_post(queue, &msg) );
                 } /* 6 msg in queue */
                 CHECK( 1, thrh_td.h_calls );
@@ -376 +376 @@
                 /* Remove 2 messages, to reach the low threshold */
                 for (i=0; i<2; i++) {
-                        CHECK( 0, fd_mq_get(queue, &msg) );
+                        CHECK( 0, fd_fifo_get(queue, &msg) );
                 } /* 4 msg in queue */
                 CHECK( 1, thrh_td.h_calls );
@@ -384 +384 @@
                 for (i=0; i<2; i++) {
                         msg = msg1;
-                        CHECK( 0, fd_mq_post(queue, &msg) );
+                        CHECK( 0, fd_fifo_post(queue, &msg) );
                 } /* 6 msg in queue */
                 CHECK( 2, thrh_td.h_calls );
@@ -392 +392 @@
                 for (i=0; i<6; i++) {
                         msg = msg1;
-                        CHECK( 0, fd_mq_post(queue, &msg) );
+                        CHECK( 0, fd_fifo_post(queue, &msg) );
                 } /* 12 msg in queue */
                 CHECK( 3, thrh_td.h_calls );
@@ -398 +398 @@
                 for (i=0; i<5; i++) {
                         msg = msg1;
-                        CHECK( 0, fd_mq_post(queue, &msg) );
+                        CHECK( 0, fd_fifo_post(queue, &msg) );
                 } /* 17 msg in queue */
                 CHECK( 3, thrh_td.h_calls );
@@ -405 +405 @@
                 /* Now the queue goes back to 0 messages */
                 for (i=0; i<17; i++) {
-                        CHECK( 0, fd_mq_get(queue, &msg) );
+                        CHECK( 0, fd_fifo_get(queue, &msg) );
                 } /* 0 msg in queue */
                 CHECK( 3, thrh_td.h_calls );
@@ -411 +411 @@
                 
                 /* We're done for this test */
-                CHECK( 0, fd_mq_del(&queue) );
+                CHECK( 0, fd_fifo_del(&queue) );
         }
         

freeDiameter/tests/tests.h

@@ -75 +75 @@
 
 static int test_verbo = 0;
+static struct fd_config conf;
+struct fd_config * fd_g_config = &conf;
 
 /* Define the standard check routines */
@@ -97 +99 @@
 
 /* Minimum inits */
-#define INIT_FD() {                                     \
-        CHECK( 0, fd_lib_init() );                      \
-        fd_log_threadname(basename(__FILE__));          \
-        CHECK( 0, fd_dict_init(&fd_g_dict) );           \
-        CHECK( 0, fd_dict_base_protocol(fd_g_dict) );   \
-        parse_cmdline(argc, argv);                      \
+#define INIT_FD() {                                             \
+        memset(fd_g_config, 0, sizeof(struct fd_config));       \
+        CHECK( 0, fd_lib_init() );                              \
+        fd_log_threadname(basename(__FILE__));                  \
+        CHECK( 0, fd_conf_init() );                             \
+        CHECK( 0, fd_dict_base_protocol(fd_g_config->g_dict) ); \
+        parse_cmdline(argc, argv);                              \
 }
 

include/freeDiameter/CMakeLists.txt

@@ -72 +72 @@
 CHECK_INCLUDE_FILES (malloc.h HAVE_MALLOC_H)
 
+# signalent.h ? -- found in strace distrib; just for nice signal names...
+CHECK_INCLUDE_FILES (signalent.h HAVE_SIGNALENT_H)
+
 # The default configuration file name
 IF (NOT DEFAULT_CONF_FILE)

include/freeDiameter/freeDiameter-host.h.in

@@ -40 +40 @@
 #cmakedefine HAVE_NTOHLL
 #cmakedefine HAVE_MALLOC_H
+#cmakedefine HAVE_SIGNALENT_H
 
 #cmakedefine HOST_BIG_ENDIAN @HOST_BIG_ENDIAN@
@@ -45 +46 @@
 #cmakedefine DISABLE_SCTP
 
-#cmakedefine PROJECT_NAME "@PROJECT_NAME@"
-#cmakedefine CMAKE_PROJECT_NAME "@CMAKE_PROJECT_NAME@"
-#cmakedefine PROJECT_VERSION "@PROJECT_VERSION@"
-#cmakedefine PROJECT_COPYRIGHT "@PROJECT_COPYRIGHT@"
+#cmakedefine FD_PROJECT_BINARY "@FD_PROJECT_BINARY@"
+#cmakedefine FD_PROJECT_NAME "@FD_PROJECT_NAME@"
+#cmakedefine FD_PROJECT_VERSION_MAJOR @FD_PROJECT_VERSION_MAJOR@
+#ifndef FD_PROJECT_VERSION_MAJOR
+# define FD_PROJECT_VERSION_MAJOR 0
+#endif /*FD_PROJECT_VERSION_MAJOR*/
+#cmakedefine FD_PROJECT_VERSION_MINOR @FD_PROJECT_VERSION_MINOR@
+#ifndef FD_PROJECT_VERSION_MINOR
+# define FD_PROJECT_VERSION_MINOR 0
+#endif /*FD_PROJECT_VERSION_MINOR*/
+#cmakedefine FD_PROJECT_VERSION_REV   @FD_PROJECT_VERSION_REV@
+#ifndef FD_PROJECT_VERSION_REV
+# define FD_PROJECT_VERSION_REV 0
+#endif /*FD_PROJECT_VERSION_REV*/
+/* HG_VERSION */
+/* PACKAGE_HG_REVISION */
+#cmakedefine FD_PROJECT_COPYRIGHT "@FD_PROJECT_COPYRIGHT@"
 
 #cmakedefine DEFAULT_CONF_FILE "@DEFAULT_CONF_FILE@"
 
+
 #endif /* FD_IS_CONFIG */

include/freeDiameter/freeDiameter.h

@@ -41 +41 @@
 
 
-/* The global dictionary */
-extern struct dictionary * fd_g_dict;
-
+/* Structure to hold the configuration of the freeDiameter daemon */
+struct fd_config {
+        int              eyec;          /* Eye catcher: EYEC_CONFIG */
+        char            *conf_file;     /* Configuration file to parse, default is DEFAULT_CONF_FILE */
+        
+        char            *diam_id;       /* Diameter Identity of the local peer (FQDN -- UTF-8) */
+        size_t           diam_id_len;   /* length of the previous string */
+        char            *diam_realm;    /* Diameter realm of the local peer, default to realm part of diam_id */
+        size_t           diam_realm_len;/* length of the previous string */
+        
+        uint16_t         loc_port;      /* the local port for legacy Diameter (default: 3868) in host byte order */
+        uint16_t         loc_port_tls;  /* the local port for Diameter/TLS (default: 3869) in host byte order */
+        uint16_t         loc_sctp_str;  /* default max number of streams for SCTP associations (def: 30) */
+        struct fd_list   loc_endpoints; /* the local endpoints to bind the server to. list of struct fd_endpoint. default is empty (bind all) */
+        struct {
+                unsigned no_ip4 : 1;    /* disable IP */
+                unsigned no_ip6 : 1;    /* disable IPv6 */
+                unsigned no_tcp : 1;    /* disable use of TCP */
+                unsigned no_sctp: 1;    /* disable the use of SCTP */
+                unsigned pr_tcp : 1;    /* prefer TCP over SCTP */
+                unsigned tls_alg: 1;    /* TLS algorithm for initiated cnx. 0: separate port. 1: inband-security (old) */
+                unsigned no_fwd : 1;    /* the peer does not relay messages (0xffffff app id) */
+        }                flags;
+        
+        unsigned int     timer_tc;      /* The value in seconds of the default Tc timer */
+        unsigned int     timer_tw;      /* The value in seconds of the default Tw timer */
+        
+        uint32_t         or_state_id;   /* The value to use in Origin-State-Id, default to random value */
+        struct dictionary *g_dict;      /* pointer to the global dictionary */
+        struct fifo       *g_fifo_main; /* FIFO queue of events in the daemon main (struct fd_event items) */
+};
+
+#define EYEC_CONFIG     0xC011F16
+
+/* The pointer to access the global configuration, initalized in main */
+extern struct fd_config *fd_g_config;
+
+/* Endpoints */
+struct fd_endpoint {
+        struct fd_list  chain;  /* link in loc_endpoints list */
+        sSS             ss;     /* the socket information. */
+};
+
+/* Events */
+struct fd_event {
+        int      code; /* codespace depends on the queue */
+        void    *data;
+};
+
+/* send an event */
+static __inline__ int fd_event_send(struct fifo *queue, int code, void * data)
+{
+        struct fd_event * ev;
+        CHECK_MALLOC( ev = malloc(sizeof(struct fd_event)) );
+        ev->code = code;
+        ev->data = data;
+        CHECK_FCT( fd_fifo_post(queue, &ev) );
+        return 0;
+}
+/* receive an event */
+static __inline__ int fd_event_get(struct fifo *queue, int *code, void ** data)
+{
+        struct fd_event * ev;
+        CHECK_FCT( fd_fifo_get(queue, &ev) );
+        if (code)
+                *code = ev->code;
+        if (data)
+                *data = ev->data;
+        free(ev);
+        return 0;
+}
 
 /***************************************/

include/freeDiameter/libfreeDiameter.h

@@ -37 +37 @@
  *
  * This library is meant to be used by both the freeDiameter daemon and its extensions.
- *
  * It provides the tools to manipulate Diameter messages and related data.
- *
  * This file should always be included as #include <freeDiameter/libfreeDiameter.h>
+ *
+ * The file contains the following parts:
+ *      DEBUG
+ *      MACROS
+ *      THREADS
+ *      LISTS
+ *      DICTIONARY
+ *      SESSIONS
+ *      MESSAGES
+ *      DISPATCH
+ *      QUEUES
  */
 
@@ -297 +306 @@
 #define sSA6    struct sockaddr_in6
 
-/* Dump one sockaddr */
-#define sSA_DUMP( level, text, sa ) {                           \
+/* Dump one sockaddr Node information */
+#define sSA_DUMP_NODE( sa, flag ) {                             \
         sSA * __sa = (sSA *)(sa);                               \
-        char *__str, __addrbuf[INET6_ADDRSTRLEN];               \
+        char __addrbuf[INET6_ADDRSTRLEN];                       \
         if (__sa) {                                             \
           int __rc = getnameinfo(__sa,                          \
@@ -308 +317 @@
                         NULL,                                   \
                         0,                                      \
-                        0);                                     \
+                        flag);                                  \
           if (__rc)                                             \
-                __str = (char *)gai_strerror(__rc);             \
+                fd_log_debug((char *)gai_strerror(__rc));       \
           else                                                  \
-                __str = &__addrbuf[0];                          \
+                fd_log_debug(&__addrbuf[0]);                    \
         } else {                                                \
-                __str = "(NULL / ANY)";                         \
+                fd_log_debug("(NULL / ANY)");                   \
         }                                                       \
-        TRACE_DEBUG(level, text "%s", __str);                   \
 }
+/* if needed, add sSA_DUMP_SERVICE */
 
 /* The sockaddr length of a sSS structure */
@@ -2275 +2284 @@
 
 /*============================================================*/
-/*                    MESSAGE QUEUES                          */
+/*                     QUEUES                                 */
 /*============================================================*/
 
-/* Management of queues of messages */
-
-/* A message queue is an opaque object */
-struct mqueue;
-
-/*
- * FUNCTION:    fd_mq_new
- *
- * PARAMETERS:
- *  queue       : Upon success, a pointer to the new message queue is saved here.
- *
- * DESCRIPTION: 
- *  Create a new empty message queue.
+/* Management of FIFO queues of elements */
+
+/* A queue is an opaque object */
+struct fifo;
+
+/*
+ * FUNCTION:    fd_fifo_new
+ *
+ * PARAMETERS:
+ *  queue       : Upon success, a pointer to the new queue is saved here.
+ *
+ * DESCRIPTION: 
+ *  Create a new empty queue.
  *
  * RETURN VALUE :
- *  0           : The message queue has been initialized successfully.
+ *  0           : The queue has been initialized successfully.
  *  EINVAL      : The parameter is invalid.
  *  ENOMEM      : Not enough memory to complete the creation.  
  */
-int fd_mq_new ( struct mqueue ** queue );
-
-/*
- * FUNCTION:    fd_mq_del
- *
- * PARAMETERS:
- *  queue       : Pointer to an empty message queue to delete.
- *
- * DESCRIPTION: 
- *  Destroys a message queue. This is only possible if no thread is waiting for a message,
+int fd_fifo_new ( struct fifo ** queue );
+
+/*
+ * FUNCTION:    fd_fifo_del
+ *
+ * PARAMETERS:
+ *  queue       : Pointer to an empty queue to delete.
+ *
+ * DESCRIPTION: 
+ *  Destroys a queue. This is only possible if no thread is waiting for an element,
  * and the queue is empty.
  *
  * RETURN VALUE:
- *  0           : The message queue has been destroyed successfully.
+ *  0           : The queue has been destroyed successfully.
  *  EINVAL      : The parameter is invalid.
  */
-int fd_mq_del ( struct mqueue  ** queue );
-
-/*
- * FUNCTION:    fd_mq_length
- *
- * PARAMETERS:
- *  queue       : The queue from which to retrieve the length.
- *  length      : Upon success, the current number of messages in the queue is stored here.
- *
- * DESCRIPTION: 
- *  Retrieve the number of messages pending in a queue.
+int fd_fifo_del ( struct fifo  ** queue );
+
+/*
+ * FUNCTION:    fd_fifo_length
+ *
+ * PARAMETERS:
+ *  queue       : The queue from which to retrieve the number of elements.
+ *  length      : Upon success, the current number of elements in the queue is stored here.
+ *
+ * DESCRIPTION: 
+ *  Retrieve the number of elements in a queue.
  *
  * RETURN VALUE:
@@ -2329 +2338 @@
  *  EINVAL      : A parameter is invalid.
  */
-int fd_mq_length ( struct mqueue * queue, int * length );
-int fd_mq_length_noerr ( struct mqueue * queue ); /* alternate with no error checking */
-
-/*
- * FUNCTION:    fd_mq_setthrhd
+int fd_fifo_length ( struct fifo * queue, int * length );
+int fd_fifo_length_noerr ( struct fifo * queue ); /* no error checking version */
+
+/*
+ * FUNCTION:    fd_fifo_setthrhd
  *
  * PARAMETERS:
@@ -2345 +2354 @@
  * DESCRIPTION: 
  *  This function allows to adjust the number of producer / consumer threads of a queue.
- * If the consumer are slower than the producers, the number of messages in the queue increase.
+ * If the consumer are slower than the producers, the number of elements in the queue increase.
  * By setting a "high" value, we allow a callback to be called when this number is too high.
  * The typical use would be to create an additional consumer thread in this callback.
  * If the queue continues to grow, the callback will be called again when the length is 2 * high, then 3*high, ... N * high
- * (the callback itself may implement a limit on the number of consumers that can be created)
+ * (the callback itself should implement a limit on the number of consumers that can be created)
  * When the queue starts to decrease, and the number of elements go under ((N - 1) * high + low, the l_cb callback is called
- * and would typially stop one of the consumer threads. If the queue continue to reduce, l_cb is again called at (N-2)*high + low,
+ * and would typially stop one of the consumer threads. If the queue continues to reduce, l_cb is again called at (N-2)*high + low,
  * and so on.
  *
@@ -2357 +2366 @@
  * l_cb when the length of the queue is becoming < low.
  *
- * Note that the callbacks are called synchronously, during fd_mq_post or fd_mq_get. Their operation should be quick.
+ * Note that the callbacks are called synchronously, during fd_fifo_post or fd_fifo_get. Their operation should be quick.
  *
  * RETURN VALUE:
@@ -2363 +2372 @@
  *  EINVAL      : A parameter is invalid.
  */
-int fd_mq_setthrhd ( struct mqueue * queue, void * data, uint16_t high, void (*h_cb)(struct mqueue *, void **), uint16_t low, void (*l_cb)(struct mqueue *, void **) );
-
-/*
- * FUNCTION:    fd_mq_post
- *
- * PARAMETERS:
- *  queue       : The queue in which the message must be posted.
- *  msg         : The message that is put in the queue.
- *
- * DESCRIPTION: 
- *  A message is added in a queue. Messages are retrieved from the queue (in FIFO order)
- *  with the fd_mq_get, fd_mq_tryget, or fd_mq_timedget functions.
- *
- * RETURN VALUE:
- *  0           : The message is queued.
+int fd_fifo_setthrhd ( struct fifo * queue, void * data, uint16_t high, void (*h_cb)(struct fifo *, void **), uint16_t low, void (*l_cb)(struct fifo *, void **) );
+
+/*
+ * FUNCTION:    fd_fifo_post
+ *
+ * PARAMETERS:
+ *  queue       : The queue in which the element must be posted.
+ *  item        : The element that is put in the queue.
+ *
+ * DESCRIPTION: 
+ *  An element is added in a queue. Elements are retrieved from the queue in FIFO order
+ *  with the fd_fifo_get, fd_fifo_tryget, or fd_fifo_timedget functions.
+ *
+ * RETURN VALUE:
+ *  0           : The element is queued.
  *  EINVAL      : A parameter is invalid.
  *  ENOMEM      : Not enough memory to complete the operation.
  */
-int fd_mq_post ( struct mqueue * queue, struct msg ** msg );
-
-/*
- * FUNCTION:    fd_mq_get
- *
- * PARAMETERS:
- *  queue       : The queue from which the message must be retrieved.
- *  msg         : On return, the first message of the queue is stored here.
- *
- * DESCRIPTION: 
- *  This function retrieves a message from a queue. If the queue is empty, the function will block the 
- * thread until a new message is posted to the queue, or until the thread is canceled (in which case the 
+int fd_fifo_post_int ( struct fifo * queue, void ** item );
+#define fd_fifo_post(queue, item) \
+        fd_fifo_post_int((queue), (void *)(item))
+
+/*
+ * FUNCTION:    fd_fifo_get
+ *
+ * PARAMETERS:
+ *  queue       : The queue from which the first element must be retrieved.
+ *  item        : On return, the first element of the queue is stored here.
+ *
+ * DESCRIPTION: 
+ *  This function retrieves the first element from a queue. If the queue is empty, the function will block the 
+ * thread until a new element is posted to the queue, or until the thread is canceled (in which case the 
  * function does not return).
  *
  * RETURN VALUE:
- *  0           : A new message has been retrieved.
- *  EINVAL      : A parameter is invalid.
- */
-int fd_mq_get ( struct mqueue * queue, struct msg ** msg );
-
-/*
- * FUNCTION:    fd_mq_tryget
- *
- * PARAMETERS:
- *  queue       : The queue from which the message must be retrieved.
+ *  0           : A new element has been retrieved.
+ *  EINVAL      : A parameter is invalid.
+ */
+int fd_fifo_get_int ( struct fifo * queue, void ** item );
+#define fd_fifo_get(queue, item) \
+        fd_fifo_get_int((queue), (void *)(item))
+
+/*
+ * FUNCTION:    fd_fifo_tryget
+ *
+ * PARAMETERS:
+ *  queue       : The queue from which the element must be retrieved.
  *  msg         : On return, the message is stored here.
  *
  * DESCRIPTION: 
- *  This function is similar to fd_mq_get, except that it will not block if 
+ *  This function is similar to fd_fifo_get, except that it will not block if 
  * the queue is empty, but return EWOULDBLOCK instead.
  *
  * RETURN VALUE:
- *  0           : A new message has been retrieved.
+ *  0           : A new element has been retrieved.
  *  EINVAL      : A parameter is invalid.
  *  EWOULDBLOCK : The queue was empty.
  */
-int fd_mq_tryget ( struct mqueue * queue, struct msg ** msg );
-
-/*
- * FUNCTION:    fd_mq_timedget
- *
- * PARAMETERS:
- *  queue       : The queue from which the message must be retrieved.
- *  msg         : On return, the message is stored here.
- *  abstime     : the absolute time until which we allow waiting for a message.
- *
- * DESCRIPTION: 
- *  This function is similar to fd_mq_get, except that it will block if the queue is empty 
+int fd_fifo_tryget_int ( struct fifo * queue, void ** item );
+#define fd_fifo_tryget(queue, item) \
+        fd_fifo_tryget_int((queue), (void *)(item))
+
+/*
+ * FUNCTION:    fd_fifo_timedget
+ *
+ * PARAMETERS:
+ *  queue       : The queue from which the element must be retrieved.
+ *  item        : On return, the element is stored here.
+ *  abstime     : the absolute time until which we allow waiting for an item.
+ *
+ * DESCRIPTION: 
+ *  This function is similar to fd_fifo_get, except that it will block if the queue is empty 
  * only until the absolute time abstime (see pthread_cond_timedwait for + info).
  * If the queue is still empty when the time expires, the function returns ETIMEDOUT
  *
  * RETURN VALUE:
- *  0           : A new message has been retrieved.
- *  EINVAL      : A parameter is invalid.
- *  ETIMEDOUT   : The time out has passed and no message has been received.
- */
-int fd_mq_timedget ( struct mqueue * queue, struct msg ** msg, const struct timespec *abstime );
+ *  0           : A new item has been retrieved.
+ *  EINVAL      : A parameter is invalid.
+ *  ETIMEDOUT   : The time out has passed and no item has been received.
+ */
+int fd_fifo_timedget_int ( struct fifo * queue, void ** item, const struct timespec *abstime );
+#define fd_fifo_timedget(queue, item, abstime) \
+        fd_fifo_timedget_int((queue), (void *)(item), (abstime))
 
 #endif /* _LIBFREEDIAMETER_H */

libfreeDiameter/CMakeLists.txt

@@ -1 +1 @@
 # Name of the subproject
 Project("libfreeDiameter" C)
-
-SET(PROJECT_COPYRIGHT "Copyright (c) 2008-2009, WIDE Project (www.wide.ad.jp) and NICT (www.nict.go.jp)")
 
 # List of source files for the library
@@ -13 +11 @@
         log.c
         messages.c
-        mqueues.c
+        queues.c
         sessions.c
         )

libfreeDiameter/queues.c

@@ -34 +34 @@
 *********************************************************************************************************/
 
-/* Messages queues module.
+/* FIFO queues module.
  *
  * The threads that call these functions must be in the cancellation state PTHREAD_CANCEL_ENABLE and type PTHREAD_CANCEL_DEFERRED.
@@ -42 +42 @@
  *  -> shutdown any process that can add into the queue first.
  *  -> pthread_cancel any thread that could be waiting on the queue.
- *  -> consume any message that is in the queue, using meq_tryget.
- *  -> then destroy the queue using meq_del.
+ *  -> consume any element that is in the queue, using fd_qu_tryget_int.
+ *  -> then destroy the queue using fd_mq_del.
  */
 
 #include "libfD.h"
 
-/* Definition of a message queue object */
-struct mqueue {
-        int             eyec;   /* An eye catcher, also used to check a queue is valid. MQ_EYEC */
+/* Definition of a FIFO queue object */
+struct fifo {
+        int             eyec;   /* An eye catcher, also used to check a queue is valid. FIFO_EYEC */
         
         pthread_mutex_t mtx;    /* Mutex protecting this queue */
         pthread_cond_t  cond;   /* condition variable of the list */
         
-        struct fd_list  list;   /* sentinel for the list of messages */
+        struct fd_list  list;   /* sentinel for the list of elements */
         int             count;  /* number of objects in the list */
-        int             thrs;   /* number of threads waiting for a new message (when count is 0) */
+        int             thrs;   /* number of threads waiting for a new element (when count is 0) */
         
         uint16_t        high;   /* High level threshold (see libfreeDiameter.h for details) */
         uint16_t        low;    /* Low level threshhold */
         void            *data;  /* Opaque pointer for threshold callbacks */
-        void            (*h_cb)(struct mqueue *, void **); /* The callbacks */
-        void            (*l_cb)(struct mqueue *, void **);
+        void            (*h_cb)(struct fifo *, void **); /* The callbacks */
+        void            (*l_cb)(struct fifo *, void **);
         int             highest;/* The highest count value for which h_cb has been called */
 };
 
 /* The eye catcher value */
-#define MQ_EYEC 0xe7ec1130
+#define FIFO_EYEC       0xe7ec1130
 
 /* Macro to check a pointer */
-#define CHECK_QUEUE( _queue ) (( (_queue) != NULL) && ( (_queue)->eyec == MQ_EYEC) )
-
-
-/* Create a new message queue */
-int fd_mq_new ( struct mqueue ** queue )
-{
-        struct mqueue * new;
+#define CHECK_FIFO( _queue ) (( (_queue) != NULL) && ( (_queue)->eyec == FIFO_EYEC) )
+
+
+/* Create a new queue */
+int fd_fifo_new ( struct fifo ** queue )
+{
+        struct fifo * new;
         
         TRACE_ENTRY( "%p", queue );
@@ -84 +84 @@
         
         /* Create a new object */
-        CHECK_MALLOC( new = malloc (sizeof (struct mqueue) )  );
+        CHECK_MALLOC( new = malloc (sizeof (struct fifo) )  );
         
         /* Initialize the content */
-        memset(new, 0, sizeof(struct mqueue));
-        
-        new->eyec = MQ_EYEC;
+        memset(new, 0, sizeof(struct fifo));
+        
+        new->eyec = FIFO_EYEC;
         CHECK_POSIX( pthread_mutex_init(&new->mtx, NULL) );
         CHECK_POSIX( pthread_cond_init(&new->cond, NULL) );
@@ -100 +100 @@
 }
 
-/* Delete a message queue. It must be unused. */ 
-int fd_mq_del ( struct mqueue  ** queue )
-{
-        struct mqueue * q;
+/* Delete a queue. It must be unused. */ 
+int fd_fifo_del ( struct fifo  ** queue )
+{
+        struct fifo * q;
         
         TRACE_ENTRY( "%p", queue );
 
-        CHECK_PARAMS( queue && CHECK_QUEUE( *queue ) );
+        CHECK_PARAMS( queue && CHECK_FIFO( *queue ) );
         
         q = *queue;
@@ -139 +139 @@
 
 /* Get the length of the queue */
-int fd_mq_length ( struct mqueue * queue, int * length )
+int fd_fifo_length ( struct fifo * queue, int * length )
 {
         TRACE_ENTRY( "%p %p", queue, length );
         
         /* Check the parameters */
-        CHECK_PARAMS( CHECK_QUEUE( queue ) && length );
+        CHECK_PARAMS( CHECK_FIFO( queue ) && length );
         
         /* lock the queue */
@@ -160 +160 @@
 
 /* alternate version with no error checking */
-int fd_mq_length_noerr ( struct mqueue * queue )
-{
-        if ( !CHECK_QUEUE( queue ) )
+int fd_fifo_length_noerr ( struct fifo * queue )
+{
+        if ( !CHECK_FIFO( queue ) )
                 return 0;
         
@@ -169 +169 @@
 
 /* Set the thresholds of the queue */
-int fd_mq_setthrhd ( struct mqueue * queue, void * data, uint16_t high, void (*h_cb)(struct mqueue *, void **), uint16_t low, void (*l_cb)(struct mqueue *, void **) )
+int fd_fifo_setthrhd ( struct fifo * queue, void * data, uint16_t high, void (*h_cb)(struct fifo *, void **), uint16_t low, void (*l_cb)(struct fifo *, void **) )
 {
         TRACE_ENTRY( "%p %p %hu %p %hu %p", queue, data, high, h_cb, low, l_cb );
         
         /* Check the parameters */
-        CHECK_PARAMS( CHECK_QUEUE( queue ) && (high > low) && (queue->data == NULL) );
+        CHECK_PARAMS( CHECK_FIFO( queue ) && (high > low) && (queue->data == NULL) );
         
         /* lock the queue */
@@ -193 +193 @@
 }
 
-/* Post a new message in the queue */
-int fd_mq_post ( struct mqueue * queue, struct msg ** msg )
+/* Post a new item in the queue */
+int fd_fifo_post_int ( struct fifo * queue, void ** item )
 {
         struct fd_list * new;
         int call_cb = 0;
         
-        TRACE_ENTRY( "%p %p", queue, msg );
-        
-        /* Check the parameters */
-        CHECK_PARAMS( CHECK_QUEUE( queue ) && msg && *msg );
+        TRACE_ENTRY( "%p %p", queue, item );
+        
+        /* Check the parameters */
+        CHECK_PARAMS( CHECK_FIFO( queue ) && item && *item );
         
         /* Create a new list item */
         CHECK_MALLOC(  new = malloc (sizeof (struct fd_list))  );
         
-        fd_list_init(new, *msg);
-        *msg = NULL;
-        
-        /* lock the queue */
-        CHECK_POSIX(  pthread_mutex_lock( &queue->mtx )  );
-        
-        /* Add the new message at the end */
+        fd_list_init(new, *item);
+        *item = NULL;
+        
+        /* lock the queue */
+        CHECK_POSIX(  pthread_mutex_lock( &queue->mtx )  );
+        
+        /* Add the new item at the end */
         fd_list_insert_before( &queue->list, new);
         queue->count++;
@@ -237 +237 @@
 }
 
-/* Pop the first message from the queue */
-static struct msg * mq_pop(struct mqueue * queue)
-{
-        struct msg * ret = NULL;
+/* Pop the first item from the queue */
+static void * mq_pop(struct fifo * queue)
+{
+        void * ret = NULL;
         struct fd_list * li;
         
@@ -247 +247 @@
         fd_list_unlink(li = queue->list.next);
         queue->count--;
-        ret = (struct msg *)(li->o);
+        ret = li->o;
         free(li);
         
@@ -254 +254 @@
 
 /* Check if the low watermark callback must be called. */
-static int test_l_cb(struct mqueue * queue)
+static __inline__ int test_l_cb(struct fifo * queue)
 {
         if ((queue->high == 0) || (queue->low == 0) || (queue->l_cb == 0))
@@ -267 +267 @@
 }
 
-/* Try poping a message */
-int fd_mq_tryget ( struct mqueue * queue, struct msg ** msg )
+/* Try poping an item */
+int fd_fifo_tryget_int ( struct fifo * queue, void ** item )
 {
         int wouldblock = 0;
         int call_cb = 0;
         
-        TRACE_ENTRY( "%p %p", queue, msg );
-        
-        /* Check the parameters */
-        CHECK_PARAMS( CHECK_QUEUE( queue ) && msg );
+        TRACE_ENTRY( "%p %p", queue, item );
+        
+        /* Check the parameters */
+        CHECK_PARAMS( CHECK_FIFO( queue ) && item );
         
         /* lock the queue */
@@ -283 +283 @@
         /* Check queue status */
         if (queue->count > 0) {
-                /* There are messages in the queue, so pick the first one */
-                *msg = mq_pop(queue);
+                /* There are elements in the queue, so pick the first one */
+                *item = mq_pop(queue);
                 call_cb = test_l_cb(queue);
         } else {
                 wouldblock = 1;
-                *msg = NULL;
+                *item = NULL;
         }
                 
@@ -303 +303 @@
 
 /* This handler is called when a thread is blocked on a queue, and cancelled */
-static void mq_cleanup(void * queue)
-{
-        struct mqueue * q = (struct mqueue *)queue;
+static void fifo_cleanup(void * queue)
+{
+        struct fifo * q = (struct fifo *)queue;
         TRACE_ENTRY( "%p", queue );
         
         /* Check the parameter */
-        if ( ! CHECK_QUEUE( q )) {
+        if ( ! CHECK_FIFO( q )) {
                 TRACE_DEBUG(INFO, "Invalid queue, skipping handler");
                 return;
@@ -324 +324 @@
 }
 
-/* The internal function for meq_timedget and meq_get */
-static int mq_tget ( struct mqueue * queue, struct msg ** msg, int istimed, const struct timespec *abstime)
+/* The internal function for fd_fifo_timedget and fd_fifo_get */
+static int fifo_tget ( struct fifo * queue, void ** item, int istimed, const struct timespec *abstime)
 {
         int timedout = 0;
@@ -331 +331 @@
         
         /* Check the parameters */
-        CHECK_PARAMS( CHECK_QUEUE( queue ) && msg && (abstime || !istimed) );
-        
-        /* Initialize the msg value */
-        *msg = NULL;
+        CHECK_PARAMS( CHECK_FIFO( queue ) && item && (abstime || !istimed) );
+        
+        /* Initialize the return value */
+        *item = NULL;
         
         /* lock the queue */
@@ -342 +342 @@
         /* Check queue status */
         if (queue->count > 0) {
-                /* There are messages in the queue, so pick the first one */
-                *msg = mq_pop(queue);
+                /* There are items in the queue, so pick the first one */
+                *item = mq_pop(queue);
                 call_cb = test_l_cb(queue);
         } else {
                 int ret = 0;
-                /* We have to wait for a new message */
+                /* We have to wait for a new item */
                 queue->thrs++ ;
-                pthread_cleanup_push( mq_cleanup, queue);
+                pthread_cleanup_push( fifo_cleanup, queue);
                 if (istimed) {
                         ret = pthread_cond_timedwait( &queue->cond, &queue->mtx, abstime );
@@ -379 +379 @@
 }
 
-/* Get the next available message, block until there is one */
-int fd_mq_get ( struct mqueue * queue, struct msg ** msg )
-{
-        TRACE_ENTRY( "%p %p", queue, msg );
-        return mq_tget(queue, msg, 0, NULL);
-}
-
-/* Get the next available message, block until there is one, or the timeout expires */
-int fd_mq_timedget ( struct mqueue * queue, struct msg ** msg, const struct timespec *abstime )
-{
-        TRACE_ENTRY( "%p %p %p", queue, msg, abstime );
-        return mq_tget(queue, msg, 1, abstime);
-}
-
+/* Get the next available item, block until there is one */
+int fd_fifo_get_int ( struct fifo * queue, void ** item )
+{
+        TRACE_ENTRY( "%p %p", queue, item );
+        return fifo_tget(queue, item, 0, NULL);
+}
+
+/* Get the next available item, block until there is one, or the timeout expires */
+int fd_fifo_timedget_int ( struct fifo * queue, void ** item, const struct timespec *abstime )
+{
+        TRACE_ENTRY( "%p %p %p", queue, item, abstime );
+        return fifo_tget(queue, item, 1, abstime);
+}
+