Navigation

Changeset 1088:1d1a20a0779d in freeDiameter for extensions


Ignore:
Timestamp:
May 5, 2013, 4:25:27 AM (11 years ago)
Author:
Sebastien Decugis <sdecugis@freediameter.net>
Branch:
default
Phase:
public
Message:

Second part of changeset 1083, now the code compiles again. Still missing some functions implementation, though

Location:
extensions
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • extensions/_sample/sample.c

    r974 r1088  
    8585                CHECK_FCT( fd_dict_new ( fd_g_config->cnf_dict, DICT_RULE, &rule_data, example_avp_avp, NULL ));
    8686               
    87                 fd_dict_dump_object(example_avp_avp);
    8887        }
    8988        TRACE_DEBUG(INFO, "'Example-AVP' created without error");

  • extensions/app_diameap/diameap_server.c

    r1027 r1088  
    8585
    8686
    87 void diameap_cli_sess_cleanup(void * arg, char * sid, void * opaque)
    88 {
    89 
    90         struct diameap_sess_data_sm * diameap_sess_data =
    91                         (struct diameap_sess_data_sm *) arg;
     87void diameap_cli_sess_cleanup(struct sess_state * diameap_sess_data, os0_t sid, void * opaque)
     88{
     89
    9290        CHECK_PARAMS_DO( diameap_sess_data, return );
    9391
    … …  
    141139static int diameap_initialize_diameap_sm(
    142140                struct diameap_state_machine * diameap_sm,
    143                 struct diameap_sess_data_sm * diameap_sess_data)
     141                struct sess_state * diameap_sess_data)
    144142{
    145143        TRACE_ENTRY("%p %p", diameap_sm, diameap_sess_data);
    … …  
    10171015
    10181016static int diameap_sess_data_new(
    1019                 struct diameap_sess_data_sm *diameap_sess_data,
     1017                struct sess_state *diameap_sess_data,
    10201018                struct diameap_state_machine *diameap_sm)
    10211019{
    … …  
    30643062        TRACE_ENTRY("%p %p %p %p", rmsg, ravp, sess, action);
    30653063
    3066         struct diameap_sess_data_sm * diameap_sess_data = NULL;
     3064        struct sess_state * diameap_sess_data = NULL;
    30673065        struct diameap_state_machine * diameap_sm = NULL;
    30683066        struct diameap_eap_interface eap_i;
    … …  
    32583256                        TRACE_DEBUG(FULL+1,"%sStoring DiamEAP session data.",DIAMEAP_EXTENSION)
    32593257                        ;
    3260                         CHECK_MALLOC(diameap_sess_data = malloc(sizeof(struct diameap_sess_data_sm)))
    3261                         ;
    3262                         memset(diameap_sess_data, 0, sizeof(struct diameap_sess_data_sm));
     3258                        CHECK_MALLOC(diameap_sess_data = malloc(sizeof(struct sess_state)))
     3259                        ;
     3260                        memset(diameap_sess_data, 0, sizeof(struct sess_state));
    32633261                        diameap_sess_data_new(diameap_sess_data, diameap_sm);
    32643262
    … …  
    33893387
    33903388        /*create handler for sessions */
    3391         CHECK_FCT(fd_sess_handler_create(&diameap_server_reg, diameap_cli_sess_cleanup, NULL));
     3389        CHECK_FCT(fd_sess_handler_create(&diameap_server_reg, diameap_cli_sess_cleanup, NULL, NULL));
    33923390
    33933391        /* Register the callback */

  • extensions/app_diameap/diameap_server.h

    r441 r1088  
    4040#define DIAMEAP_SERVER_H_
    4141
    42 
     42 
    4343/* session data structure to store */
    44 struct diameap_sess_data_sm
     44struct sess_state
    4545{
    4646        int invalid_eappackets; /* Number of invalid EAP Packet received*/

  • extensions/app_radgw/rgwx_acct.c

    r1027 r1088  
    160160};
    161161
     162static DECLARE_FD_DUMP_PROTOTYPE(acct_conf_session_state_dump, struct sess_state * st)
     163{
     164        return fd_dump_extend( FD_DUMP_STD_PARAMS, "[rgwx sess_state](@%p): aai:%x str:%d TC:%u", st, st->auth_appl, st->send_str, st->term_cause);
     165}
     166
    162167/* Initialize the plugin */
    163168static int acct_conf_parse(char * conffile, struct rgwp_config ** state)
    … …  
    172177        memset(new, 0, sizeof(struct rgwp_config));
    173178       
    174         CHECK_FCT( fd_sess_handler_create( &new->sess_hdl, free, NULL ) );
     179        CHECK_FCT( fd_sess_handler_create( &new->sess_hdl, (void *)free, acct_conf_session_state_dump, NULL ) );
    175180        new->confstr = conffile;
    176181       

  • extensions/app_radgw/rgwx_auth.c

    r1027 r1088  
    125125};
    126126
     127struct sess_state {
     128        char req_auth[16];
     129};
     130
     131
    127132/* Initialize the plugin */
    128133static int auth_conf_parse(char * confstr, struct rgwp_config ** state)
    … …  
    137142        memset(new, 0, sizeof(struct rgwp_config));
    138143       
    139         CHECK_FCT( fd_sess_handler_create( &new->sess_hdl, free, NULL ) );
     144        CHECK_FCT( fd_sess_handler_create( &new->sess_hdl, (void *)free, NULL, NULL ) );
    140145        new->confstr = confstr;
    141146       
    … …  
    10571062        /* Store the request identifier in the session (if provided) */
    10581063        {
    1059                 unsigned char * req_auth;
    1060                 CHECK_MALLOC(req_auth = malloc(16));
    1061                 memcpy(req_auth, &rad_req->hdr->authenticator[0], 16);
     1064                struct sess_state  *st;
     1065                CHECK_MALLOC(st = malloc(sizeof(struct sess_state)));
     1066                memcpy(st->req_auth, &rad_req->hdr->authenticator[0], 16);
    10621067               
    1063                 CHECK_FCT( fd_sess_state_store( cs->sess_hdl, sess, &req_auth ) );
     1068                CHECK_FCT( fd_sess_state_store( cs->sess_hdl, sess, &st ) );
    10641069        }
    10651070       
    … …  
    10771082        int no_str = 0; /* indicate if an STR is required for this server */
    10781083        uint8_t tuntag = 0;
    1079         unsigned char * req_auth = NULL;
     1084        struct sess_state  *st;
    10801085        int error_cause = 0;
    10811086        struct session * sess;
    … …  
    10891094        CHECK_FCT( fd_msg_sess_get(fd_g_config->cnf_dict, *diam_ans, &sess, NULL) );
    10901095        if (sess) {
    1091                 CHECK_FCT( fd_sess_state_retrieve( cs->sess_hdl, sess, &req_auth ) );
     1096                CHECK_FCT( fd_sess_state_retrieve( cs->sess_hdl, sess, &st ) );
    10921097                CHECK_FCT( fd_sess_getsid(sess, &sid, &sidlen) );
    10931098        } /* else ? */
    … …  
    17591764                                                                                       
    17601765                                                                                        /* We need the request authenticator */
    1761                                                                                         CHECK_PARAMS(req_auth);
     1766                                                                                        CHECK_PARAMS(st);
    17621767
    17631768                                                                                        /* Retrieve the shared secret */
    … …  
    17781783                                                                                        addr[0] = secret;
    17791784                                                                                        len[0] = secret_len;
    1780                                                                                         addr[1] = req_auth;
     1785                                                                                        addr[1] = st->req_auth;
    17811786                                                                                        len[1] = 16;
    17821787                                                                                        addr[2] = &buf[1];
    … …  
    18531858
    18541859                                                /* We need the request authenticator */
    1855                                                 CHECK_PARAMS(req_auth);
     1860                                                CHECK_PARAMS(st);
    18561861
    18571862                                                /* Retrieve the shared secret */
    … …  
    18661871                                                send_len = ahdr->avp_value->os.len - recv_len;
    18671872                                               
    1868                                                 if ( ! radius_msg_add_mppe_keys(*rad_fw, req_auth, secret, secret_len,
     1873                                                if ( ! radius_msg_add_mppe_keys(*rad_fw, st->req_auth, secret, secret_len,
    18691874                                                                ahdr->avp_value->os.data + recv_len, send_len,
    18701875                                                                ahdr->avp_value->os.data, recv_len) ) {
    … …  
    19251930       
    19261931        CHECK_FCT( fd_msg_free( aoh ) );
    1927         free(req_auth);
     1932        free(st);
    19281933       
    19291934        if (error_cause) {

  • extensions/app_radgw/rgwx_echodrop.c

    r996 r1088  
    3838#include "rgwx_echodrop.h"
    3939
     40struct sess_state {
     41        struct fd_list sentinel;
     42};
     43
    4044/* If a session is destroyed, empty the list of ed_saved_attribute */
    41 static void state_delete(void * arg, char * sid, void * opaque) {
    42         struct fd_list * list = (struct fd_list *)arg;
    43        
    44         CHECK_PARAMS_DO( list, return );
    45        
    46         while (!FD_IS_LIST_EMPTY(list)) {
    47                 struct ed_saved_attribute * esa = (struct ed_saved_attribute *)(list->next);
     45static void state_delete(struct sess_state * arg, os0_t sid, void * opaque) {
     46        while (!FD_IS_LIST_EMPTY(&arg->sentinel)) {
     47                struct ed_saved_attribute * esa = (struct ed_saved_attribute *)(arg->sentinel.next);
    4848                fd_list_unlink(&esa->chain);
    4949                free(esa);
    5050        }
    51         free(list);
    52 }
    53 
     51        free(arg);
     52}
     53
     54static DECLARE_FD_DUMP_PROTOTYPE(ed_session_state_dump, struct sess_state * st)
     55{
     56        struct fd_list * li;
     57        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "[rgwx sess_state](@%p):\n", st), return NULL);   
     58        for (li = st->sentinel.next; li != &st->sentinel; li = li->next) {
     59                struct ed_saved_attribute * esa = (struct ed_saved_attribute *)(li);
     60                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "[rgwx sess_state {esa}] t:%2hhx l:%2hhx d:", esa->attr.type, esa->attr.length), return NULL);
     61                CHECK_MALLOC_DO( fd_dump_extend_hexdump(FD_DUMP_STD_PARAMS, (&esa->attr.length) + 1, esa->attr.length - 2, 0,0), return NULL);
     62                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
     63        }
     64}
    5465
    5566/* Initialize the plugin and parse the configuration. */
    … …  
    6980       
    7081        /* Create the session handler */
    71         CHECK_FCT( fd_sess_handler_create( &new->sess_hdl, state_delete, NULL ) );
     82        CHECK_FCT( fd_sess_handler_create( &new->sess_hdl, state_delete, ed_session_state_dump, NULL ) );
    7283       
    7384        /* Parse the configuration file */
    … …  
    217228        if (!FD_IS_LIST_EMPTY(&echo_list)) {
    218229                struct session * sess;
     230                struct sess_state * st;
    219231               
    220232                CHECK_FCT( fd_msg_sess_get(fd_g_config->cnf_dict, *diam_fw, &sess, NULL) );
    … …  
    229241               
    230242                /* Move the values in a dynamically allocated list */
    231                 CHECK_MALLOC( li = malloc(sizeof(struct fd_list)) );
    232                 fd_list_init(li, NULL);
    233                 fd_list_move_end(li, &echo_list);
     243                CHECK_MALLOC( st = malloc(sizeof(struct sess_state)) );
     244                fd_list_init(&st->sentinel, NULL);
     245                fd_list_move_end(&st->sentinel, &echo_list);
    234246               
    235247                /* Save the list in the session */
    236                 CHECK_FCT( fd_sess_state_store( cs->sess_hdl, sess, &li ) );
     248                CHECK_FCT( fd_sess_state_store( cs->sess_hdl, sess, &st ) );
    237249        }
    238250       
    … …  
    243255static int ed_diam_ans( struct rgwp_config * cs, struct msg ** diam_ans, struct radius_msg ** rad_fw, struct rgw_client * cli )
    244256{
    245         struct fd_list * list = NULL;
    246257        struct session * sess;
     258        struct sess_state * st;
    247259       
    248260        TRACE_ENTRY("%p %p %p %p", cs, diam_ans, rad_fw, cli);
    … …  
    258270       
    259271        /* Now try and retrieve any data from the session */
    260         CHECK_FCT( fd_sess_state_retrieve( cs->sess_hdl, sess, &list ) );
    261         if (list == NULL) {
     272        CHECK_FCT( fd_sess_state_retrieve( cs->sess_hdl, sess, &st ) );
     273        if (st == NULL) {
    262274                /* No attribute saved in the session, just return */
    263275                return 0;
    … …  
    268280        CHECK_PARAMS( rad_fw && *rad_fw);
    269281       
    270         while (! FD_IS_LIST_EMPTY(list) ) {
    271                 struct ed_saved_attribute * esa = (struct ed_saved_attribute *)(list->next);
     282        while (! FD_IS_LIST_EMPTY(&st->sentinel) ) {
     283                struct ed_saved_attribute * esa = (struct ed_saved_attribute *)(st->sentinel.next);
    272284               
    273285                fd_list_unlink(&esa->chain);
    … …  
    280292                free(esa);
    281293        }
    282         free(list);
     294        free(st);
    283295
    284296        return 0;

  • extensions/app_radgw/rgwx_sip.c

    r1027 r1088  
    134134               
    135135        } dict; /* cache of the dictionary objects we use */
    136         struct session_handler * sess_hdl; /* We store RADIUS request authenticator information in the session */
    137136        char * confstr;
    138137        //Chained list of nonce
    … …  
    258257        memset(new, 0, sizeof(struct rgwp_config));
    259258       
    260         CHECK_FCT( fd_sess_handler_create( &new->sess_hdl, free, NULL ) );
    261259        new->confstr = conffile;
    262260       
    … …  
    312310        CHECK_PARAMS_DO( state, return );
    313311       
    314         CHECK_FCT_DO( fd_sess_handler_destroy( &state->sess_hdl, NULL ),  );
    315        
    316312        nonce_deletelistnonce(state);
    317313        CHECK_POSIX_DO(pthread_mutex_destroy(&state->nonce_mutex), /*continue*/);
    … …  
    320316        return;
    321317}
    322 
    323318
    324319/* Handle an incoming RADIUS request */
    … …  
    717712        //fd_msg_dump_walk(1,*diam_fw);
    718713       
    719         /* Store the request identifier in the session */
    720         {
    721                 unsigned char * req_sip;
    722                 CHECK_MALLOC(req_sip = malloc(16));
    723                 memcpy(req_sip, &rad_req->hdr->authenticator[0], 16);
    724                
    725                 CHECK_FCT( fd_sess_state_store( cs->sess_hdl, sess, &req_sip ) );
    726         }
    727        
    728714       
    729715        return 0;
    … …  
    857843        }
    858844       
    859         CHECK_FCT( fd_sess_state_retrieve( cs->sess_hdl, sess, &req_sip ) );
    860         free(req_sip);
    861        
    862845        return 0;
    863846}

  • extensions/app_sip/app_sip.c

    r1027 r1088  
    5050
    5151struct disp_hdl * app_sip_default_hdl=NULL;
    52 struct session_handler * ds_sess_hdl;
    5352
    5453//configuration stucture
    … …  
    213212                return EINVAL;
    214213       
    215         CHECK_FCT(fd_sess_handler_create(&ds_sess_hdl, free, NULL));
    216        
    217214        //Creation of thread for Registration Termination       
    218215        if(pthread_create(&rtr_thread, NULL,rtr_socket, NULL))
    … …  
    238235       
    239236        (void) fd_disp_unregister(&app_sip_MAR_hdl, NULL);
    240         CHECK_FCT_DO( fd_sess_handler_destroy(&ds_sess_hdl, NULL),return);
    241237       
    242238       

  • extensions/app_sip/app_sip.h

    r1034 r1088  
    212212#define CODE_SIP_USER_DATA_TYPE 388
    213213#define CODE_SIP_AOR    122
    214 
    215 struct ds_nonce
    216 {
    217         char *nonce;
    218 };
    219214
    220215//Storage for some useful AVPs

  • extensions/app_sip/multimediaauth.c

    r639 r1088  
    3636#include "app_sip.h"
    3737
     38struct sess_state
     39{
     40        char *nonce;
     41};
     42
    3843
    3944int app_sip_MAR_cb( struct msg ** msg, struct avp * paramavp, struct session * sess, void * opaque, enum disp_action * act)
    … …  
    5661       
    5762        //The nonce we will store and retrieve in session
    58         struct ds_nonce *storednonce=NULL;
     63        struct sess_state *storednonce=NULL;
    5964       
    6065       
    … …  
    362367                                                                       
    363368                                                                        //We store the nonce (storednonce structure) inside the session
    364                                                                         storednonce=malloc(sizeof(struct ds_nonce));
    365                                                                         memset(storednonce,0,sizeof(struct ds_nonce));
     369                                                                        storednonce=malloc(sizeof(struct sess_state));
     370                                                                        memset(storednonce,0,sizeof(struct sess_state));
    366371                                                                        CHECK_MALLOC(storednonce->nonce=malloc(NONCE_SIZE*2+1));
    367372                                                                        memcpy(storednonce->nonce,(char *)nonce,NONCE_SIZE*2+1);

  • extensions/dbg_interactive/dictionary.i

    r979 r1088  
    6060        }
    6161        void dump() {
    62                 fd_dict_dump($self);
     62                char * buf = NULL;
     63                size_t len;
     64                printf("%s", fd_dict_dump(&buf, &len, NULL, $self));
     65                free(buf);
    6366        }
    6467        PyObject * vendors_list() {
    … …  
    128131%extend dict_object {
    129132        void dump() {
    130                 fd_dict_dump_object($self);
     133                char * buf = NULL;
     134                size_t len;
     135                printf("%s", fd_dict_dump_object(&buf, &len, NULL, $self));
     136                free(buf);
    131137        }
    132138        enum dict_object_type gettype() {

  • extensions/dbg_interactive/endpoints.i

    r978 r1088  
    126126       
    127127        void dump() {
    128                 fd_ep_dump_one( "", $self );
     128                char * buf = NULL;
     129                size_t len;
     130                printf("%s", fd_ep_dump_one(&buf, &len, NULL, $self));
     131                free(buf);
    129132        }
    130133}

  • extensions/dbg_interactive/messages.i

    r1078 r1088  
    291291        /* Dump */
    292292        void dump (int tree = 1) {
    293                 if (tree)
    294                         fd_msg_dump_walk(0, $self);
    295                 else
    296                         fd_msg_dump_one(0, $self);
     293                char * buf = NULL;
     294                size_t len;
     295                printf("%s", fd_msg_dump_treeview(&buf, &len, NULL, $self, NULL, 0, tree));
     296                free(buf);
    297297        }
    298298       
    … …  
    570570        /* Dump */
    571571        void dump (int tree = 1) {
    572                 if (tree)
    573                         fd_msg_dump_walk(0, $self);
    574                 else
    575                         fd_msg_dump_one(0, $self);
     572                char * buf = NULL;
     573                size_t len;
     574                printf("%s", fd_msg_dump_treeview(&buf, &len, NULL, $self, NULL, 0, tree));
     575                free(buf);
    576576        }
    577577       

  • extensions/dbg_interactive/sessions.i

    r1013 r1088  
    3939
    4040%{
     41struct sess_state {
     42        PyObject * pystate;
     43};
     44
    4145/* call it (might be called from a different thread than the interpreter, when session times out) */
    42 static void call_the_python_cleanup_callback(session_state * state, os0_t sid, void * cb) {
     46static void call_the_python_cleanup_callback(struct sess_state * state, os0_t sid, void * cb) {
    4347        PyObject *result;
    4448        if (!cb) {
    … …  
    6771                Py_XINCREF(PyCb);
    6872               
    69                 ret = fd_sess_handler_create_internal ( &hdl, call_the_python_cleanup_callback, PyCb );
     73                ret = fd_sess_handler_create ( &hdl, call_the_python_cleanup_callback, NULL, PyCb );
    7074                if (ret != 0) {
    7175                        DI_ERROR(ret, NULL, NULL);
    … …  
    8791        }
    8892        void dump() {
    89                 fd_sess_dump_hdl(0, $self);
     93                char * buf = NULL;
     94                size_t len;
     95                printf("%s", fd_sess_dump_hdl(&buf, &len, NULL, $self));
     96                free(buf);
    9097        }
    9198}
    … …  
    166173        }
    167174        void dump() {
    168                 fd_sess_dump(0, $self);
     175                char * buf = NULL;
     176                size_t len = 0;
     177                printf("%s", fd_sess_dump(&buf, &len, NULL, $self, 1) );
     178                free(buf);
    169179        }
    170180        void store(struct session_handler * handler, PyObject * DISOWN) {
    171181                int ret;
    172                 void * store = DISOWN;
     182                struct sess_state * st = NULL;
     183                st = malloc(sizeof(struct sess_state));
     184                st->pystate = DISOWN;
    173185                Py_XINCREF(DISOWN);
    174                 ret = fd_sess_state_store_internal(handler, $self, (void *) &store);
     186                ret = fd_sess_state_store(handler, $self, (void *) &st);
    175187                if (ret != 0) {
    176188                        DI_ERROR(ret, NULL, NULL);
    … …  
    180192        PyObject * retrieve(struct session_handler * handler) {
    181193                int ret;
     194                struct sess_state * st = NULL;
    182195                PyObject * state = NULL;
    183                 ret = fd_sess_state_retrieve_internal(handler, $self, (void *) &state);
    184                 if (ret != 0) {
    185                         DI_ERROR(ret, NULL, NULL);
    186                         return NULL;
    187                 }
    188                 if (state == NULL) {
     196                ret = fd_sess_state_retrieve_internal(handler, $self, (void *) &st);
     197                if (ret != 0) {
     198                        DI_ERROR(ret, NULL, NULL);
     199                        return NULL;
     200                }
     201                if (st == NULL) {
    189202                        Py_INCREF(Py_None);
    190203                        return Py_None;
    191204                }
     205                state = st->pystate;
     206                free(st);
    192207                return state;
    193208        }

  • extensions/dbg_monitor/dbg_monitor.c

    r1083 r1088  
    7878        int i = 0;
    7979        fd_log_threadname("Monitor thread");
     80        char * buf = NULL;
     81        size_t len;
    8082       
    8183        /* Loop */
    … …  
    111113                        struct peer_hdr * p = (struct peer_hdr *)li->o;
    112114                       
    113                         fd_peer_dump(p, NONE);
     115                        TRACE_DEBUG(INFO, "%s", fd_peer_dump(&buf, &len, NULL, p, 1));
    114116                       
    115117                        CHECK_FCT_DO( fd_stat_getstats(STAT_P_PSM, p, &current_count, &limit_count, &highest_count, &total_count, &total, &blocking, &last), );
    … …  
    123125                CHECK_FCT_DO( pthread_rwlock_unlock(&fd_g_peers_rw), /* continue */ );
    124126               
    125                 CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_SERV, 0, NULL), /* continue */);
     127                TRACE_DEBUG(INFO, "[dbg_monitor] Dumping servers information");
     128                TRACE_DEBUG(INFO, "%s", fd_servers_dump(&buf, &len, NULL));
     129               
    126130                sleep(1);
    127131        }
    128132       
     133        free(buf);
    129134        return NULL;
    130135}
    … …  
    133138static void got_sig()
    134139{
    135         fd_log_debug("[dbg_monitor] Dumping extra information");
    136         CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_DICT, 0, NULL), /* continue */);
    137         CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_CONFIG, 0, NULL), /* continue */);
    138         CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_EXT, 0, NULL), /* continue */);
     140        char * buf = NULL;
     141        size_t len;
     142        TRACE_DEBUG(INFO, "[dbg_monitor] Dumping config information");
     143        TRACE_DEBUG(INFO, "%s", fd_conf_dump(&buf, &len, NULL));
     144        TRACE_DEBUG(INFO, "[dbg_monitor] Dumping extensions information");
     145        TRACE_DEBUG(INFO, "%s", fd_ext_dump(&buf, &len, NULL));
     146        TRACE_DEBUG(INFO, "[dbg_monitor] Dumping dictionary information");
     147        TRACE_DEBUG(INFO, "%s", fd_dict_dump(&buf, &len, NULL, fd_g_config->cnf_dict));
     148        free(buf);
    139149}
    140150

  • extensions/dict_legacy_xml/dict_lxml_xml.c

    r974 r1088  
    18091809       
    18101810        TRACE_DEBUG(FULL, "Conversion from '%s' to freeDiameter internal format complete.", xmlfilename);
    1811         if (TRACE_BOOL(ANNOYING)) {
    1812                 fd_dict_dump(fd_g_config->cnf_dict);
    1813         }
    18141811       
    18151812        /* Done */

  • extensions/test_app/ta_cli.c

    r930 r1088  
    4646static struct session_handler * ta_cli_reg = NULL;
    4747
    48 struct ta_mess_info {
     48struct sess_state {
    4949        int32_t         randval;        /* a random value to store in Test-AVP */
    5050        struct timespec ts;             /* Time of sending the message */
    … …  
    5454static void ta_cb_ans(void * data, struct msg ** msg)
    5555{
    56         struct ta_mess_info * mi = NULL;
     56        struct sess_state * mi = NULL;
    5757        struct timespec ts;
    5858        struct session * sess;
    … …  
    177177        struct avp * avp;
    178178        union avp_value val;
    179         struct ta_mess_info * mi = NULL, *svg;
     179        struct sess_state * mi = NULL, *svg;
    180180        struct session *sess = NULL;
    181181       
    … …  
    191191       
    192192        /* Create the random value to store with the session */
    193         mi = malloc(sizeof(struct ta_mess_info));
     193        mi = malloc(sizeof(struct sess_state));
    194194        if (mi == NULL) {
    195195                fd_log_debug("malloc failed: %s", strerror(errno));
    … …  
    265265int ta_cli_init(void)
    266266{
    267         CHECK_FCT( fd_sess_handler_create(&ta_cli_reg, free, NULL) );
     267        CHECK_FCT( fd_sess_handler_create(&ta_cli_reg, (void *)free, NULL, NULL) );
    268268       
    269269        CHECK_FCT( fd_event_trig_regcb(ta_conf->signal, "test_app.cli", ta_cli_test_message ) );

  • extensions/test_sip/test_sip.c

    r972 r1088  
    5454
    5555struct disp_hdl * test_sip_default_hdl=NULL;
    56 struct session_handler * ts_sess_hdl;
    5756
    5857//configuration stucture
    … …  
    214213        */
    215214       
    216         CHECK_FCT(fd_sess_handler_create(&ts_sess_hdl, free, NULL));
    217215        //CHECK_FCT( fd_event_trig_regcb(30, "test_sip", (void *)test_sipSL_LIR_cb ) );
    218216        CHECK_FCT( fd_event_trig_regcb(30, "test_sip", (void *)test_sip_SAR_cb ) );
Note: See TracChangeset for help on using the changeset viewer.