Navigation

Changes in / [657:c21e7b896c67:659:8556139321b3] in freeDiameter


Ignore:
Files:
55 added
54 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • CMakeLists.txt

    r647 r658  
    1111# Version of the source code
    1212SET(FD_PROJECT_VERSION_MAJOR 1)
    13 SET(FD_PROJECT_VERSION_MINOR 0)
    14 SET(FD_PROJECT_VERSION_REV 4)
     13SET(FD_PROJECT_VERSION_MINOR 1)
     14SET(FD_PROJECT_VERSION_REV 0)
    1515
    1616# Version of the API with the library
    17 SET(FD_PROJECT_VERSION_API 3)
     17SET(FD_PROJECT_VERSION_API 4)
    1818
    1919# The test framework, using CTest and CDash.
    … …  
    3131SET(INSTALL_HEADERS_SUFFIX              include/freeDiameter    CACHE PATH "Directory where the headers are installed (relative to CMAKE_INSTALL_PREFIX).")
    3232SET(INSTALL_DAEMON_SUFFIX               bin                     CACHE PATH "Directory where the daemon binary is installed (relative to CMAKE_INSTALL_PREFIX).")
    33 SET(INSTALL_LIBRARY_SUFFIX              lib                     CACHE PATH "Directory where the libfreeDiameter library is installed (relative to CMAKE_INSTALL_PREFIX).")
     33SET(INSTALL_LIBRARY_SUFFIX              lib                     CACHE PATH "Directory where the freeDiameter libraries are installed (relative to CMAKE_INSTALL_PREFIX).")
    3434SET(INSTALL_EXTENSIONS_SUFFIX   ${INSTALL_LIBRARY_SUFFIX}/freeDiameter  CACHE PATH "Directory where the extensions are installed / searched (relative to CMAKE_INSTALL_PREFIX).")
    3535
    … …  
    7777
    7878# Location for the source code
    79 SUBDIRS(libfreeDiameter)
    80 SUBDIRS(freeDiameter)
     79SUBDIRS(libfdproto)
     80SUBDIRS(libfdcore)
     81SUBDIRS(freeDiameterd)
    8182
    8283# Extensions (there is no use of freeDiameter without any extension)
    8384SUBDIRS(extensions)
     85
     86# The unary tests directory
     87IF ( BUILD_TESTING )
     88        SUBDIRS(tests)
     89ENDIF ( BUILD_TESTING )
     90

  • contrib/debian/control

    r631 r658  
    1313Architecture: any
    1414Depends: ${shlibs:Depends}, ${misc:Depends}
    15 Description: The libfreeDiameter library.
    16  This library is required by all freeDiameter components.
     15Description: The freeDiameter libraries.
     16 This package contains the libraries required by all freeDiameter components.
    1717 It may also be useful for other projects which need to
    1818 perform operations on Diameter messages.

  • contrib/debian/freediameter-common.install

    r328 r658  
    1 usr/lib/libfreeDiameter.so*
     1usr/lib/libfdproto.so*
     2usr/lib/libfdcore.so*

  • extensions/dbg_interactive/CMakeLists.txt

    r641 r658  
    1616SET(SWIG_MODULE_fDpy_EXTRA_DEPS
    1717        ${CMAKE_BINARY_DIR}/include/freeDiameter/freeDiameter-host.h
    18         ${CMAKE_SOURCE_DIR}/include/freeDiameter/libfreeDiameter.h
    19         ${CMAKE_SOURCE_DIR}/include/freeDiameter/freeDiameter.h
     18        ${CMAKE_SOURCE_DIR}/include/freeDiameter/libfdcore.h
     19        ${CMAKE_SOURCE_DIR}/include/freeDiameter/libfdproto.h
    2020        lists.i
    2121        dictionary.i

  • extensions/dbg_interactive/dbg_interactive.c

    r639 r658  
    5959        fd_log_threadname ( "fDpy" );
    6060       
    61         CHECK_FCT_DO(fd_wait_initialization_complete(), goto end);
     61        CHECK_FCT_DO(fd_core_waitstartcomplete(), goto end);
    6262       
    6363        fd_log_debug("\nStarting interactive python interpreter [experimental].\n");

  • extensions/dbg_interactive/dbg_interactive.i

    r641 r658  
    159159 *********************************************************/
    160160%include "freeDiameter/freeDiameter-host.h"
    161 %include "freeDiameter/libfreeDiameter.h"
    162 %include "freeDiameter/freeDiameter.h"
     161%include "freeDiameter/libfdproto.h"
     162%include "freeDiameter/libfdcore.h"
    163163
    164164/* Most of the functions from the API are not directly usable "as is".

  • extensions/dbg_monitor/dbg_monitor.c

    r258 r658  
    7878
    7979/* Function called on receipt of MONITOR_SIGNAL */
    80 static void got_sig(int signal)
     80static void got_sig()
    8181{
    8282        fd_log_debug("[dbg_monitor] Dumping extra information\n");
    … …  
    9292       
    9393        /* Catch signal SIGUSR1 */
    94         CHECK_FCT( fd_sig_register(MONITOR_SIGNAL, "dbg_monitor", got_sig));
     94        CHECK_FCT( fd_event_trig_regcb(MONITOR_SIGNAL, "dbg_monitor", got_sig));
    9595       
    9696        CHECK_POSIX( pthread_create( &thr, NULL, mn_thr, NULL ) );

  • extensions/dict_eap/dict_eap.c

    r10 r658  
    296296                                        268,                                    /* Code */
    297297                                        "Diameter-EAP-Request",                 /* Name */
    298                                         CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_RETRANSMIT | CMD_FLAG_ERROR,   /* Fixed flags */
     298                                        CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */
    299299                                        CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE                   /* Fixed flag values */
    300300                                        };

  • extensions/dict_legacy_xml/dict_lxml_xml.c

    r616 r658  
    933933                                        { TRACE_DEBUG(INFO, "Invalid 'type' tag found without 'name' attribute."); goto xml_tree_error; } );
    934934                               
     935                                /* Check there is only 1 type */
     936                                if (!FD_IS_LIST_EMPTY(&data->cur_avp->type)) {
     937                                        TRACE_DEBUG(INFO, "Multiple 'type' tags found for AVP.");
     938                                        goto xml_tree_error;
     939                                }
     940                               
     941                                /* Add the new type */
    935942                                CHECK_FCT_DO( new_avptype(&data->cur_avp->type, xname),
    936943                                        { TRACE_DEBUG(INFO, "An error occurred while parsing a type tag. Entry ignored."); goto xml_tree_error; } )
    … …  
    10111018        }
    10121019        data->error_depth += 1;
     1020        if (data->cur_app || data->cur_cmd || data->cur_avp) {
     1021                TRACE_DEBUG(INFO, "Error encountered while parsing tag of:");
     1022                if (data->cur_app)
     1023                        fd_log_debug("  Application: '%s'\n", data->cur_app->name);
     1024                if (data->cur_cmd)
     1025                        fd_log_debug("  Command    : '%s'\n", data->cur_cmd->name);
     1026                if (data->cur_avp)
     1027                        fd_log_debug("  AVP        : '%s'\n", data->cur_avp->name);
     1028        }
    10131029        return;
    10141030}
    … …  
    13871403               
    13881404                /* Now create the new rule */
    1389                 CHECK_FCT( fd_dict_new ( fD_dict, DICT_RULE, &rd, parent, NULL ) );
     1405                CHECK_FCT_DO( ret = fd_dict_new ( fD_dict, DICT_RULE, &rd, parent, NULL ),
     1406                        { TRACE_DEBUG(INFO, "Error creating rule for sub-AVP '%s'", r->avpname); return ret; } );
    13901407                if (nb_added)
    13911408                        *nb_added += 1;
    … …  
    13981415static int rules_to_fD(struct dictionary * fD_dict, struct dict_object * parent, struct fd_list * fixed, struct fd_list * required, struct fd_list * optional, int * nb_added)
    13991416{
     1417        int ret;
     1418       
    14001419        TRACE_ENTRY("%p %p %p %p %p %p", fD_dict, parent, fixed, required, optional, nb_added);
    14011420       
    14021421        /* Process the rules */
    1403         CHECK_FCT( rules_to_fD_onelist(fD_dict, parent, RULE_FIXED_HEAD, fixed, nb_added) );
    1404         CHECK_FCT( rules_to_fD_onelist(fD_dict, parent, RULE_REQUIRED, required, nb_added) );
    1405         CHECK_FCT( rules_to_fD_onelist(fD_dict, parent, RULE_OPTIONAL, optional, nb_added) );
     1422        CHECK_FCT_DO( ret = rules_to_fD_onelist(fD_dict, parent, RULE_FIXED_HEAD, fixed, nb_added),
     1423                { TRACE_DEBUG(INFO, "Error processing FIXED rules"); return ret; } );
     1424        CHECK_FCT_DO( ret = rules_to_fD_onelist(fD_dict, parent, RULE_REQUIRED, required, nb_added),
     1425                { TRACE_DEBUG(INFO, "Error processing REQUIRED rules"); return ret; } );
     1426        CHECK_FCT_DO( ret = rules_to_fD_onelist(fD_dict, parent, RULE_OPTIONAL, optional, nb_added),
     1427                { TRACE_DEBUG(INFO, "Error processing OPTIONAL rules"); return ret; } );
    14061428       
    14071429        return 0;
    … …  
    14251447        ad.avp_vendor = a->vendor;
    14261448        ad.avp_name   = (char *)a->name;
    1427         ad.avp_flag_mask = a->fmask;
     1449        ad.avp_flag_mask = a->fmask | AVP_FLAG_VENDOR;
    14281450        ad.avp_flag_val  = a->flags;
    14291451       
    14301452        if (!FD_IS_LIST_EMPTY(&a->type)) {
    14311453                /* special exception: we use per-AVP enumerated types in fD */
    1432                 if (strcasecmp("Enumerated", (char *)((struct t_avptype *)a->type.next)->type_name))
     1454                if (!strcasecmp("Enumerated", (char *)((struct t_avptype *)a->type.next)->type_name))
     1455                        goto enumerated;
     1456                /* Let's allow "Unsigned32" instead of "Enumerated" also... */
     1457                if ((!FD_IS_LIST_EMPTY(&a->enums)) && (!strcasecmp("Unsigned32", (char *)((struct t_avptype *)a->type.next)->type_name)))
    14331458                        goto enumerated;
    14341459               
    … …  
    14411466                        || !FD_IS_LIST_EMPTY(&a->grouped_fixed) ) {
    14421467                        /* The AVP has rules, it is a grouped AVP */
    1443                         CHECK_PARAMS( FD_IS_LIST_EMPTY(&a->enums) );
     1468                        CHECK_PARAMS_DO( FD_IS_LIST_EMPTY(&a->enums),
     1469                                { TRACE_DEBUG(INFO, "Conflict: The AVP '%s' has both enum values and rules.", ad.avp_name); return EINVAL; } );
    14441470                        ad.avp_basetype = AVP_TYPE_GROUPED;
    14451471                } else {
    14461472                        /* It should be an enumerated AVP... */
    14471473                        if (FD_IS_LIST_EMPTY(&a->enums)) {
    1448                                 TRACE_DEBUG(INFO, "[dict_legacy_xml] Error: Missing type information for AVP '%s'", ad.avp_name);
     1474                                TRACE_DEBUG(INFO, "Error: Missing type information for AVP '%s'", ad.avp_name);
    14491475                                return EINVAL;
    14501476                        } else {
    … …  
    14921518        /* Now, the inner elements, if any */
    14931519       
     1520        if ( (!FD_IS_LIST_EMPTY(&a->enums)) && (ad.avp_basetype != AVP_TYPE_UNSIGNED32)) {
     1521                TRACE_DEBUG(INFO, "AVP '%s' type is not an Unsigned32 but it has enum values (invalid in this extension).", ad.avp_name);
     1522                return EINVAL;
     1523        }
     1524
    14941525        /* In case of enumeration, define the enum values */
    1495         ASSERT( FD_IS_LIST_EMPTY(&a->enums) || (type && (ad.avp_basetype == AVP_TYPE_UNSIGNED32)) ); /* u32 type must be defined for enumerators */
    14961526        for (li = a->enums.next; li != &a->enums; li = li->next) {
    14971527                struct t_enum * e = (struct t_enum *)li;
    … …  
    15021532                ed.enum_value.u32 = e->code;
    15031533               
    1504                 CHECK_FCT( fd_dict_new ( fD_dict, DICT_ENUMVAL, &ed, type, NULL ) );
     1534                CHECK_FCT_DO( ret = fd_dict_new ( fD_dict, DICT_ENUMVAL, &ed, type, NULL ),
     1535                        {
     1536                                TRACE_DEBUG(INFO, "Error defining constant value '%s' for AVP '%s': %s", ed.enum_name, ad.avp_name, strerror(ret));
     1537                                return ret;
     1538                        } );
    15051539                if (nb_added)
    15061540                        *nb_added += 1;
    … …  
    15111545          || !FD_IS_LIST_EMPTY(&a->grouped_required)
    15121546          || !FD_IS_LIST_EMPTY(&a->grouped_fixed) ) {
    1513                 CHECK_PARAMS( ad.avp_basetype == AVP_TYPE_GROUPED );
    1514                 CHECK_FCT( rules_to_fD(fD_dict, prev, &a->grouped_fixed, &a->grouped_required, &a->grouped_optional, nb_added) );
     1547                CHECK_PARAMS_DO( ad.avp_basetype == AVP_TYPE_GROUPED,
     1548                        { TRACE_DEBUG(INFO, "Got rules for non-grouped AVP '%s'", ad.avp_name); return EINVAL;} );
     1549                CHECK_FCT_DO( ret = rules_to_fD(fD_dict, prev, &a->grouped_fixed, &a->grouped_required, &a->grouped_optional, nb_added),
     1550                        { TRACE_DEBUG(INFO, "Error processing rules for AVP '%s': %s", ad.avp_name, strerror(ret)); return ret; } );
    15151551        }
    15161552       
    … …  
    15361572        snprintf(cmdname, sizeof(cmdname), "%s-Request", (char *)c->name);
    15371573        cd.cmd_name = &cmdname[0];
    1538         cd.cmd_flag_mask = c->fmask | CMD_FLAG_REQUEST;
     1574        cd.cmd_flag_mask = c->fmask | CMD_FLAG_REQUEST | CMD_FLAG_ERROR;
    15391575        cd.cmd_flag_val  = c->flags | CMD_FLAG_REQUEST;
    15401576       
    … …  
    15641600        snprintf(cmdname, sizeof(cmdname), "%s-Answer", (char *)c->name);
    15651601        cd.cmd_flag_val &= ~CMD_FLAG_REQUEST;
     1602        cd.cmd_flag_mask &= ~CMD_FLAG_ERROR;
    15661603       
    15671604        ret = fd_dict_new ( fD_dict, DICT_COMMAND, &cd, fd_appl, &ans );
    … …  
    15851622rules:
    15861623        /* Now process the rules inside the command */
    1587         CHECK_FCT( rules_to_fD(fD_dict, req, &c->reqrules_fixed, &c->reqrules_required, &c->reqrules_optional, nb_added) );
    1588         CHECK_FCT( rules_to_fD(fD_dict, ans, &c->ansrules_fixed, &c->ansrules_required, &c->ansrules_optional, nb_added) );
     1624        CHECK_FCT_DO( ret = rules_to_fD(fD_dict, req, &c->reqrules_fixed, &c->reqrules_required, &c->reqrules_optional, nb_added),
     1625                        {
     1626                                TRACE_DEBUG(INFO, "Error converting data from request rules: %s", strerror(ret));
     1627                                return ret;
     1628                        }   );
     1629        CHECK_FCT_DO( ret = rules_to_fD(fD_dict, ans, &c->ansrules_fixed, &c->ansrules_required, &c->ansrules_optional, nb_added),
     1630                        {
     1631                                TRACE_DEBUG(INFO, "Error converting data from answer rules: %s", strerror(ret));
     1632                                return ret;
     1633                        }   );
    15891634       
    15901635        /* Done */
    … …  
    16411686        /* First, define all the types */
    16421687        for (li = a->types.next; li != &a->types; li = li->next) {
    1643                 CHECK_FCT( typdefn_to_fD((struct t_typedefn *)li, fD_dict, prev, NULL, nb_added) );
     1688                CHECK_FCT_DO( ret = typdefn_to_fD((struct t_typedefn *)li, fD_dict, prev, NULL, nb_added),
     1689                        {
     1690                                TRACE_DEBUG(INFO, "Error converting data from typedefn '%s': %s", ((struct t_typedefn *)li)->name, strerror(ret));
     1691                                return ret;
     1692                        }  );
    16441693        }
    16451694       
    16461695        /* Then, AVPs, enums, and grouped AVP rules */
    16471696        for (li = a->avps.next; li != &a->avps; li = li->next) {
    1648                 CHECK_FCT( avp_to_fD((struct t_avp *)li, fD_dict, prev, NULL, nb_added) );
     1697                CHECK_FCT_DO( ret = avp_to_fD((struct t_avp *)li, fD_dict, prev, NULL, nb_added),
     1698                        {
     1699                                TRACE_DEBUG(INFO, "Error converting data from AVP '%s': %s", ((struct t_avp *)li)->name, strerror(ret));
     1700                                return ret;
     1701                        }  );
    16491702        }
    16501703       
    16511704        /* Finally, the commands and rules */
    16521705        for (li = a->commands.next; li != &a->commands; li = li->next) {
    1653                 CHECK_FCT( cmd_to_fD((struct t_cmd *)li, fD_dict, prev, NULL, nb_added) );
     1706                CHECK_FCT_DO( ret = cmd_to_fD((struct t_cmd *)li, fD_dict, prev, NULL, nb_added),
     1707                        {
     1708                                TRACE_DEBUG(INFO, "Error converting data from command '%s': %s", ((struct t_cmd *)li)->name, strerror(ret));
     1709                                return ret;
     1710                        }  );
    16541711        }
    16551712       
    … …  
    16621719{
    16631720        struct fd_list * li;
     1721        int ret;
    16641722       
    16651723        TRACE_ENTRY("%p %p %p", fD_dict, xmldict, nb_added);
    … …  
    16711729        /* Create all the vendors */
    16721730        for (li = xmldict->vendors.next; li != &xmldict->vendors; li = li->next) {
    1673                 CHECK_FCT( vend_to_fD((struct t_vend *)li, fD_dict, NULL, nb_added) );
     1731                CHECK_FCT_DO( ret = vend_to_fD((struct t_vend *)li, fD_dict, NULL, nb_added),
     1732                        {
     1733                                TRACE_DEBUG(INFO, "Error converting data from vendor '%s': %s", ((struct t_vend *)li)->name, strerror(ret));
     1734                                return ret;
     1735                        } );
    16741736        }
    16751737       
    16761738        /* Now, process each application */
    1677         CHECK_FCT( appl_to_fD(&xmldict->base_and_applications, fD_dict, NULL, nb_added) );
     1739        CHECK_FCT_DO( ret = appl_to_fD(&xmldict->base_and_applications, fD_dict, NULL, nb_added),
     1740                        {
     1741                                TRACE_DEBUG(INFO, "Error converting data from Base application: %s", strerror(ret));
     1742                                return ret;
     1743                        } );
    16781744        for (li = xmldict->base_and_applications.chain.next; li != &xmldict->base_and_applications.chain; li = li->next) {
    1679                 CHECK_FCT( appl_to_fD((struct t_appl *) li, fD_dict, NULL, nb_added) );
     1745                CHECK_FCT_DO( ret = appl_to_fD((struct t_appl *) li, fD_dict, NULL, nb_added),
     1746                        {
     1747                                TRACE_DEBUG(INFO, "Error converting data from application '%s': %s", ((struct t_appl *)li)->name, strerror(ret));
     1748                                return ret;
     1749                        }  );
    16801750        }
    16811751       
    … …  
    17251795        }
    17261796       
    1727         TRACE_DEBUG(FULL, "XML file parsing complete.");
     1797        TRACE_DEBUG(FULL, "XML file parsing, 1st pass completed.");
    17281798        if (TRACE_BOOL(ANNOYING)) {
    17291799                dump_dict(&data.dict);
    … …  
    17311801       
    17321802        /* Now, convert all the objects from the temporary tree into the freeDiameter dictionary */
    1733         CHECK_FCT_DO( dict_to_fD(fd_g_config->cnf_dict, &data.dict, &ret), { del_dict_contents(&data.dict); return -1; } );
    1734        
    1735         TRACE_DEBUG(FULL, "Conversion to freeDiameter internal format complete.");
     1803        CHECK_FCT_DO( dict_to_fD(fd_g_config->cnf_dict, &data.dict, &ret),
     1804                {
     1805                        TRACE_DEBUG(INFO, "Error while converting data read from file '%s'", xmlfilename);
     1806                        del_dict_contents(&data.dict);
     1807                        return -1;
     1808                } );
     1809       
     1810        TRACE_DEBUG(FULL, "Conversion from '%s' to freeDiameter internal format complete.", xmlfilename);
    17361811        if (TRACE_BOOL(ANNOYING)) {
    17371812                fd_dict_dump(fd_g_config->cnf_dict);

  • extensions/dict_nasreq/dict_nasreq.c

    r523 r658  
    30053005                                        265,                                    /* Code */
    30063006                                        "AA-Request",                           /* Name */
    3007                                         CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_RETRANSMIT | CMD_FLAG_ERROR,   /* Fixed flags */
     3007                                        CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */
    30083008                                        CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE                   /* Fixed flag values */
    30093009                                        };

  • extensions/test_app/ta_bench.c

    r575 r658  
    208208
    209209/* The function called when the signal is received */
    210 static void ta_bench_start(int sig) {
     210static void ta_bench_start() {
    211211        struct timespec end_time, now;
    212212        struct ta_stats start, end;
    … …  
    274274        CHECK_SYS( sem_init( &ta_sem, 0, ta_conf->bench_concur) );
    275275
    276         CHECK_FCT( fd_sig_register(ta_conf->signal, "test_app.bench", ta_bench_start ) );
     276        CHECK_FCT( fd_event_trig_regcb(ta_conf->signal, "test_app.bench", ta_bench_start ) );
    277277       
    278278        return 0;
    … …  
    281281void ta_bench_fini(void)
    282282{
    283         CHECK_FCT_DO( fd_sig_unregister(ta_conf->signal), /* continue */ );
     283        // CHECK_FCT_DO( fd_sig_unregister(ta_conf->signal), /* continue */ );
    284284       
    285285        CHECK_SYS_DO( sem_destroy(&ta_sem), );

  • extensions/test_app/ta_cli.c

    r639 r658  
    136136
    137137/* Create a test message */
    138 static void ta_cli_test_message(int sig)
     138static void ta_cli_test_message()
    139139{
    140140        struct msg * req = NULL;
    … …  
    236236        CHECK_FCT( fd_sess_handler_create(&ta_cli_reg, free, NULL) );
    237237       
    238         CHECK_FCT( fd_sig_register(ta_conf->signal, "test_app.cli", ta_cli_test_message ) );
     238        CHECK_FCT( fd_event_trig_regcb(ta_conf->signal, "test_app.cli", ta_cli_test_message ) );
    239239       
    240240        return 0;
    … …  
    243243void ta_cli_fini(void)
    244244{
    245         CHECK_FCT_DO( fd_sig_unregister(ta_conf->signal), /* continue */ );
     245        // CHECK_FCT_DO( fd_sig_unregister(ta_conf->signal), /* continue */ );
    246246       
    247247        CHECK_FCT_DO( fd_sess_handler_destroy(&ta_cli_reg, NULL), /* continue */ );

  • extensions/test_sip/test_sip.c

    r639 r658  
    215215       
    216216        CHECK_FCT(fd_sess_handler_create(&ts_sess_hdl, free, NULL));
    217         //CHECK_FCT( fd_sig_register(30, "test_sip", (void *)test_sipSL_LIR_cb ) );
    218         CHECK_FCT( fd_sig_register(30, "test_sip", (void *)test_sip_SAR_cb ) );
    219         CHECK_FCT( fd_sig_register(31, "test_sip", (void *)test_sip_LIR_cb ) );
     217        //CHECK_FCT( fd_event_trig_regcb(30, "test_sip", (void *)test_sipSL_LIR_cb ) );
     218        CHECK_FCT( fd_event_trig_regcb(30, "test_sip", (void *)test_sip_SAR_cb ) );
     219        CHECK_FCT( fd_event_trig_regcb(31, "test_sip", (void *)test_sip_LIR_cb ) );
    220220       
    221221        return 0;

  • include/freeDiameter/CMakeLists.txt

    r561 r658  
    11#CMake configuration for freeDiameter include directory
    22
    3 Project("freeDiameter include directory" C)
     3Project("freeDiameter includes directory" C)
    44
    55########################
    … …  
    6868ENDIF (HAVE_CLOCK_GETTIME)
    6969
    70 # LFD_LIBS = libraries required by the libfreeDiameter.
    71 SET(LFD_LIBS ${CLOCK_GETTIME_LIBS} ${CMAKE_THREAD_LIBS_INIT})
     70# LFDPROTO_LIBS = libraries required by the libfdproto.
     71SET(LFDPROTO_LIBS ${CLOCK_GETTIME_LIBS} ${CMAKE_THREAD_LIBS_INIT})
    7272
    7373
    … …  
    9898
    9999
    100 # FD_LIBS = libraries required by the daemon
    101 SET(FD_LIBS ${CMAKE_DL_LIBS} ${SCTP_LIBRARIES})
     100# Require GNU TLS for building the library
     101FIND_PACKAGE(GnuTLS REQUIRED)
     102INCLUDE_DIRECTORIES(${GNUTLS_INCLUDE_DIR})
     103
     104find_path(GCRYPT_INCLUDE_DIR NAMES gcrypt.h)
     105If ( NOT GCRYPT_INCLUDE_DIR )
     106        MESSAGE(SEND_ERROR "Unable to find gcrypt.h, please install libgcrypt-dev or equivalent")
     107Endif ( NOT GCRYPT_INCLUDE_DIR )
     108MARK_AS_ADVANCED(GCRYPT_INCLUDE_DIR)
     109INCLUDE_DIRECTORIES(${GCRYPT_INCLUDE_DIR})
     110
     111# Also we need libgcrypt to... display its version :(
     112find_library(GCRYPT_LIBRARY
     113  NAMES gcrypt
     114)
     115If ( NOT GCRYPT_LIBRARY )
     116        MESSAGE(SEND_ERROR "Unable to find libgcrypt, please install libgcrypt or equivalent")
     117Endif ( NOT GCRYPT_LIBRARY )
     118
     119
     120# LFDCORE_LIBS = libraries required by the libfdcore
     121SET(LFDCORE_LIBS ${CMAKE_DL_LIBS} ${SCTP_LIBRARIES} ${GCRYPT_LIBRARY} ${GNUTLS_LIBRARIES})
    102122
    103123##########################
    … …  
    111131
    112132# Save some variables for the other directories
    113 SET(FD_LIBS  ${FD_LIBS} PARENT_SCOPE)
    114 SET(LFD_LIBS ${LFD_LIBS} PARENT_SCOPE)
     133SET(LFDPROTO_LIBS ${LFDPROTO_LIBS} PARENT_SCOPE)
     134SET(LFDCORE_LIBS  ${LFDCORE_LIBS} PARENT_SCOPE)
    115135SET(CMAKE_THREAD_LIBS_INIT ${CMAKE_THREAD_LIBS_INIT} PARENT_SCOPE)
    116136
    … …  
    119139
    120140# The headers from this directory are required to develop new extensions for freeDiameter.
    121 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/freeDiameter-host.h libfreeDiameter.h freeDiameter.h extension.h
     141INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/freeDiameter-host.h libfdproto.h libfdcore.h extension.h
    122142        DESTINATION ${INSTALL_HEADERS_SUFFIX}
    123143        COMPONENT freeDiameter-dev)

  • include/freeDiameter/extension.h

    r8 r658  
    33* Author: Sebastien Decugis <sdecugis@nict.go.jp>                                                        *
    44*                                                                                                        *
    5 * Copyright (c) 2009, WIDE Project and NICT                                                              *
     5* Copyright (c) 2011, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
    … …  
    3939/* Include definition of freeDiameter API */
    4040#include <freeDiameter/freeDiameter-host.h>
    41 #include <freeDiameter/freeDiameter.h>
     41#include <freeDiameter/libfdcore.h>
    4242
    4343/* Macro that define the entry point of the extension */

  • include/freeDiameter/freeDiameter-host.h.in

    r648 r658  
    7575#cmakedefine DEFAULT_EXTENSIONS_PATH "@DEFAULT_EXTENSIONS_PATH@"
    7676
     77#ifndef FD_DEFAULT_CONF_FILENAME
     78#define FD_DEFAULT_CONF_FILENAME "freeDiameter.conf"
     79#endif /* FD_DEFAULT_CONF_FILENAME */
     80
    7781#endif /* FD_IS_CONFIG */
Note: See TracChangeset for help on using the changeset viewer.