Navigation

Changeset 156:e2dc300819b3 in freeDiameter


Ignore:
Timestamp:
Jan 20, 2010, 4:04:25 PM (14 years ago)
Author:
Sebastien Decugis <sdecugis@nict.go.jp>
Branch:
default
Phase:
public
Message:

Fix overwriten thread location

Files:
8 edited

Legend:

Unmodified
Added
Removed

  • freeDiameter/cnxctx.c

    r155 r156  
    12581258#ifndef DISABLE_SCTP
    12591259                if (conn->cc_sctp_para.pairs > 1) {
    1260                         /* Master session */
     1260                        /* Bye on master session */
    12611261                        CHECK_GNUTLS_DO( gnutls_bye(conn->cc_tls_para.session, GNUTLS_SHUT_WR), /* Continue */ );
    12621262                       

  • freeDiameter/dict_base_proto.c

    r119 r156  
    144144}
    145145
     146static void Address_dump(union avp_value * avp_value)
     147{
     148        fd_log_debug("*todo: dump address*");
     149}
     150
     151static void UTF8String_dump(union avp_value * avp_value)
     152{
     153        size_t len = avp_value->os.len;
     154        if (len > 42)
     155                len = 42; /* avoid very long strings */
     156        fd_log_debug("%.*s", len, avp_value->os.data);
     157}
     158
     159
    146160
    147161
    … …  
    231245                                the content and format of the remaining octets.
    232246                        */
    233                         struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "Address"               , Address_interpret     , Address_encode        };
     247                        struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "Address"               , Address_interpret     , Address_encode,       Address_dump    };
    234248                        CHECK_dict_new( DICT_TYPE, &data , NULL, NULL);
    235249                }
    … …  
    250264                                This procedure MUST be supported by all DIAMETER nodes.
    251265                        */
    252                         struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "Time"                  , NULL                  , NULL                  };
     266                        struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "Time"                  , NULL                  , NULL          , NULL          };
    253267                        CHECK_dict_new( DICT_TYPE, &data , NULL, NULL);
    254268                }
    … …  
    288302                                octets, not characters.
    289303                        */
    290                         struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "UTF8String"            , NULL                  , NULL                  };
     304                        struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "UTF8String"            , NULL                  , NULL  , UTF8String_dump       };
    291305                        CHECK_dict_new( DICT_TYPE, &data , NULL, NULL);
    292306                }
    … …  
    317331                                Domain Name (IDNs).
    318332                        */
    319                         struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "DiameterIdentity"      , NULL                  , NULL                  };
     333                        struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "DiameterIdentity"      , NULL                  , NULL          , UTF8String_dump       };
    320334                        CHECK_dict_new( DICT_TYPE, &data , NULL, NULL);
    321335                }
    … …  
    372386                                aaa://host.example.com:1813;transport=udp;protocol=radius
    373387                        */
    374                         struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "DiameterURI"           , NULL                  , NULL                  };
     388                        struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "DiameterURI"           , NULL                  , NULL          , UTF8String_dump       };
    375389                        CHECK_dict_new( DICT_TYPE, &data , NULL, NULL);
    376390                }
    … …  
    434448                                infrastructure.
    435449                        */
    436                         struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "IPFilterRule"          , NULL                  , NULL                  };
     450                        struct dict_type_data data = { AVP_TYPE_OCTETSTRING,    "IPFilterRule"          , NULL                  , NULL          , UTF8String_dump       };
    437451                        CHECK_dict_new( DICT_TYPE, &data , NULL, NULL);
    438452                }
    … …  
    604618                        */
    605619                        struct dict_object      *       type;
    606                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Disconnect-Cause)"  , NULL, NULL};
     620                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Disconnect-Cause)"  , NULL, NULL, NULL };
    607621                        struct dict_enumval_data        t_0 = { "REBOOTING",                    { .i32 = 0 }};
    608622                        struct dict_enumval_data        t_1 = { "BUSY",                         { .i32 = 1 }};
    … …  
    909923                       
    910924                        struct dict_object      *       type;
    911                         struct dict_type_data           tdata = { AVP_TYPE_UNSIGNED32,  "Enumerated*(Inband-Security-Id)"       , NULL, NULL};
     925                        struct dict_type_data           tdata = { AVP_TYPE_UNSIGNED32,  "Enumerated*(Inband-Security-Id)"       , NULL, NULL, NULL };
    912926                        struct dict_enumval_data        t_0 = { "NO_INBAND_SECURITY",           { .u32 = ACV_ISI_NO_INBAND_SECURITY }};
    913927                        struct dict_enumval_data        t_1 = { "TLS",                  { .u32 = ACV_ISI_TLS }};
    … …  
    11031117                        */
    11041118                        struct dict_object      *       type;
    1105                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Redirect-Host-Usage)"       , NULL, NULL};
     1119                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Redirect-Host-Usage)"       , NULL, NULL, NULL };
    11061120                        struct dict_enumval_data        t_0 = { "DONT_CACHE",                   { .i32 = 0 }};
    11071121                        struct dict_enumval_data        t_1 = { "ALL_SESSION",                  { .i32 = 1 }};
    … …  
    11971211                         */
    11981212                        struct dict_object *    type;
    1199                         struct dict_type_data   tdata = { AVP_TYPE_UNSIGNED32,  "Enumerated*(Result-Code)"      , NULL, NULL};
     1213                        struct dict_type_data   tdata = { AVP_TYPE_UNSIGNED32,  "Enumerated*(Result-Code)"      , NULL, NULL, NULL };
    12001214                        struct dict_avp_data    data = {
    12011215                                        268,                                    /* Code */
    … …  
    17961810                         */
    17971811                        struct dict_object *    type;
    1798                         struct dict_type_data   tdata = { AVP_TYPE_UNSIGNED32,  "Enumerated*(Experimental-Result-Code)" , NULL, NULL};
     1812                        struct dict_type_data   tdata = { AVP_TYPE_UNSIGNED32,  "Enumerated*(Experimental-Result-Code)" , NULL, NULL, NULL };
    17991813                        struct dict_avp_data    data = {
    18001814                                        298,                                    /* Code */
    … …  
    18431857                        */
    18441858                        struct dict_object      *       type;
    1845                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Auth-Request-Type)" , NULL, NULL};
     1859                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Auth-Request-Type)" , NULL, NULL, NULL };
    18461860                        struct dict_enumval_data        t_1 = { "AUTHENTICATE_ONLY",            { .i32 = 1 }};
    18471861                        struct dict_enumval_data        t_2 = { "AUTHORIZE_ONLY",               { .i32 = 2 }};
    … …  
    19851999                        */
    19862000                        struct dict_object      *       type;
    1987                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Auth-Session-State)"        , NULL, NULL};
     2001                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Auth-Session-State)"        , NULL, NULL, NULL };
    19882002                        struct dict_enumval_data        t_0 = { "STATE_MAINTAINED",             { .i32 = 0 }};
    19892003                        struct dict_enumval_data        t_1 = { "NO_STATE_MAINTAINED",          { .i32 = 1 }};
    … …  
    20282042                        */
    20292043                        struct dict_object      *       type;
    2030                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Re-Auth-Request-Type)"      , NULL, NULL};
     2044                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Re-Auth-Request-Type)"      , NULL, NULL, NULL };
    20312045                        struct dict_enumval_data        t_0 = { "AUTHORIZE_ONLY",               { .i32 = 0 }};
    20322046                        struct dict_enumval_data        t_1 = { "AUTHORIZE_AUTHENTICATE",       { .i32 = 1 }};
    … …  
    21552169                        */
    21562170                        struct dict_object      *       type;
    2157                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Termination-Cause)" , NULL, NULL};
     2171                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Termination-Cause)" , NULL, NULL, NULL };
    21582172                        struct dict_enumval_data        t_1 = { "DIAMETER_LOGOUT",                      { .i32 = 1 }};
    21592173                        struct dict_enumval_data        t_2 = { "DIAMETER_SERVICE_NOT_PROVIDED",        { .i32 = 2 }};
    … …  
    22672281                       
    22682282                        struct dict_object      *       type;
    2269                         struct dict_type_data           tdata = { AVP_TYPE_UNSIGNED32,  "Enumerated*(Session-Binding)"  , NULL, NULL};
     2283                        struct dict_type_data           tdata = { AVP_TYPE_UNSIGNED32,  "Enumerated*(Session-Binding)"  , NULL, NULL, NULL };
    22702284                        struct dict_enumval_data        t_1 = { "RE_AUTH",              { .u32 = 1 }};
    22712285                        struct dict_enumval_data        t_2 = { "STR",                  { .u32 = 2 }};
    … …  
    23292343                        */
    23302344                        struct dict_object      *       type;
    2331                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Session-Server-Failover)"   , NULL, NULL};
     2345                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Session-Server-Failover)"   , NULL, NULL, NULL };
    23322346                        struct dict_enumval_data        t_0 = { "REFUSE_SERVICE",               { .i32 = 0 }};
    23332347                        struct dict_enumval_data        t_1 = { "TRY_AGAIN",                    { .i32 = 1 }};
    … …  
    24612475                        */
    24622476                        struct dict_object      *       type;
    2463                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Accounting-Record-Type)"    , NULL, NULL};
     2477                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Accounting-Record-Type)"    , NULL, NULL, NULL };
    24642478                        struct dict_enumval_data        t_1 = { "EVENT_RECORD",                 { .i32 = 1 }};
    24652479                        struct dict_enumval_data        t_2 = { "START_RECORD",                 { .i32 = 2 }};
    … …  
    26552669                        */
    26562670                        struct dict_object      *       type;
    2657                         struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Accounting-Realtime-Required)"      , NULL, NULL};
     2671                        struct dict_type_data           tdata = { AVP_TYPE_INTEGER32,   "Enumerated(Accounting-Realtime-Required)"      , NULL, NULL, NULL };
    26582672                        struct dict_enumval_data        t_1 = { "DELIVER_AND_GRANT",            { .i32 = 1 }};
    26592673                        struct dict_enumval_data        t_2 = { "GRANT_AND_STORE",              { .i32 = 2 }};

  • freeDiameter/sctps.c

    r155 r156  
    9191                        case FDEVP_CNX_MSG_RECV:
    9292                                /* Demux this message in the appropriate fifo, another thread will pull, gnutls process, and send in target queue */
    93                                 CHECK_FCT_DO(fd_event_send(conn->cc_sctps_data.array[strid].raw_recv, event, bufsz, buf), goto error );
     93                                if (strid < conn->cc_sctp_para.pairs) {
     94                                        CHECK_FCT_DO(fd_event_send(conn->cc_sctps_data.array[strid].raw_recv, event, bufsz, buf), goto error );
     95                                } else {
     96                                        TRACE_DEBUG(INFO, "Received packet (%d bytes) on out-of-range stream #%s from %s, discarded.", bufsz, strid, conn->cc_remid);
     97                                        free(buf);
     98                                }
    9499                                break;
    95100                               
    … …  
    113118                CHECK_FCT_DO( fd_event_send( Target_Queue(conn), FDEVP_CNX_ERROR, 0, NULL), /* continue or destroy everything? */);
    114119        }
     120       
     121        /* Since the demux thread terminates, we must trig an error for all decipher threads. We do this by destroying all demuxed FIFO queues */
     122        for (strid = 0; strid < conn->cc_sctp_para.pairs; strid++) {
     123                fd_event_destroy( &conn->cc_sctps_data.array[strid].raw_recv, free );
     124        }
     125       
    115126        goto out;
    116127}
    … …  
    583594}
    584595
    585 static void * bye_th(void * arg)
    586 {
    587         struct sctps_ctx * ctx = (struct sctps_ctx *) arg;
    588         TRACE_ENTRY("%p", arg);
    589        
    590         /* Set the thread name */
    591         {
    592                 char buf[48];
    593                 snprintf(buf, sizeof(buf), "gnutls_bye (%hu@%d)", ctx->strid, ctx->parent->cc_socket);
    594                 fd_log_threadname ( buf );
    595         }
    596        
    597         CHECK_GNUTLS_DO( gnutls_bye(ctx->session, GNUTLS_SHUT_WR), /* Continue */ );
    598                        
    599         /* Finish */
    600         return NULL;
    601 }
    602 
    603 /* Initiate a "bye" on all stream pairs in paralel */
     596/* Initiate a "bye" on all stream pairs */
    604597void fd_sctps_bye(struct cnxctx * conn)
    605598{
    … …  
    608601        CHECK_PARAMS_DO( conn && conn->cc_sctps_data.array, return );
    609602       
    610         /* End all TLS sessions, in parallel */
     603        /* End all TLS sessions, in series (not as efficient as paralel, but simpler) */
    611604        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
    612                 CHECK_POSIX_DO( pthread_create( &conn->cc_sctps_data.array[i].thr, NULL, bye_th, &conn->cc_sctps_data.array[i] ), break );
    613         }
    614         for (--i; i > 0; --i) {
    615                 CHECK_POSIX_DO( pthread_join( conn->cc_sctps_data.array[i].thr, NULL ), continue );
     605                CHECK_GNUTLS_DO( gnutls_bye(conn->cc_sctps_data.array[i].session, GNUTLS_SHUT_WR), /* Continue */ );
    616606        }
    617607}
    … …  
    677667        /* Free remaining data in the array */
    678668        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
    679                 fd_event_destroy( &conn->cc_sctps_data.array[i].raw_recv, free );
     669                if (conn->cc_sctps_data.array[i].raw_recv)
     670                        fd_event_destroy( &conn->cc_sctps_data.array[i].raw_recv, free );
    680671                free(conn->cc_sctps_data.array[i].partial.buf);
    681672                if (i > 0)

  • include/freeDiameter/libfreeDiameter.h

    r137 r156  
    666666void fd_dict_dump(struct dictionary * dict);
    667667
    668 
    669668/*
    670669 ***************************************************************************
    … …  
    895894        dict_avpdata_interpret   type_interpret;/* cb to convert the AVP value in more comprehensive format (or NULL) */
    896895        dict_avpdata_encode      type_encode;   /* cb to convert formatted data into an AVP value (or NULL) */
     896        void                    (*type_dump)(union avp_value * val);    /* cb called by fd_msg_dump_one for this type of data (if != NULL) */
    897897};
    898898

  • libfreeDiameter/dictionary.c

    r111 r156  
    12841284}
    12851285
     1286/**************************** Dump AVP values ********************************/
     1287
     1288/* Default dump functions */
     1289static void dump_val_os(union avp_value * value)
     1290{
     1291        int i;
     1292        for (i = 0; i < value->os.len; i++) {
     1293                if (i == 16) { /* Dump only up to 16 bytes of the buffer */
     1294                        fd_log_debug("(trunc, len=%zd)", value->os.len);
     1295                        break;
     1296                }
     1297                fd_log_debug("%02.2X ", value->os.data[i]);
     1298        }
     1299}
     1300
     1301static void dump_val_i32(union avp_value * value)
     1302{
     1303        fd_log_debug("%i", value->i32);
     1304}
     1305
     1306static void dump_val_i64(union avp_value * value)
     1307{
     1308        fd_log_debug("%lli (0x%llx)", value->i64, value->i64);
     1309}
     1310
     1311static void dump_val_u32(union avp_value * value)
     1312{
     1313        fd_log_debug("%u", value->u32);
     1314}
     1315
     1316static void dump_val_u64(union avp_value * value)
     1317{
     1318        fd_log_debug("%llu", value->u64);
     1319}
     1320
     1321static void dump_val_f32(union avp_value * value)
     1322{
     1323        fd_log_debug("%f", value->f32);
     1324}
     1325
     1326static void dump_val_f64(union avp_value * value)
     1327{
     1328        fd_log_debug("%g", value->f64);
     1329}
     1330
     1331/* Get the dump function for basic dict_avp_basetype */
     1332static void (*get_default_dump_val_cb(enum dict_avp_basetype datatype))(union avp_value *)
     1333{
     1334        switch (datatype) {
     1335                case AVP_TYPE_OCTETSTRING:
     1336                        return &dump_val_os;
     1337               
     1338                case AVP_TYPE_INTEGER32:
     1339                        return &dump_val_i32;
     1340
     1341                case AVP_TYPE_INTEGER64:
     1342                        return &dump_val_i64;
     1343
     1344                case AVP_TYPE_UNSIGNED32:
     1345                        return &dump_val_u32;
     1346
     1347                case AVP_TYPE_UNSIGNED64:
     1348                        return &dump_val_u64;
     1349
     1350                case AVP_TYPE_FLOAT32:
     1351                        return &dump_val_f32;
     1352
     1353                case AVP_TYPE_FLOAT64:
     1354                        return &dump_val_f64;
     1355               
     1356                case AVP_TYPE_GROUPED:
     1357                        TRACE_DEBUG(FULL, "error: grouped AVP with a value!");
     1358        }
     1359        return NULL;
     1360}
     1361
     1362/* indent inside an object (duplicate from messages.c) */
     1363#define INOBJHDR        "%*s   "
     1364#define INOBJHDRVAL     indent<0 ? 1 : indent, indent<0 ? "-" : "|"
     1365
     1366/* Formater for the AVP value dump line */
     1367static void dump_avp_val(union avp_value *avp_value, void (*dump_val_cb)(union avp_value *avp_value), enum dict_avp_basetype datatype, char * type_name, char * const_name, int indent)
     1368{
     1369        /* Header for all AVP values dumps: */
     1370        fd_log_debug(INOBJHDR "value ", INOBJHDRVAL);
     1371       
     1372        /* If the type is provided, write it */
     1373        if (type_name)
     1374                fd_log_debug("t: '%s' ", type_name);
     1375       
     1376        /* Always give the base datatype anyway */
     1377        fd_log_debug("(%s) ", type_base_name[datatype]);
     1378       
     1379        /* Now, the value */
     1380        fd_log_debug("v: ");
     1381        if (const_name)
     1382                fd_log_debug("'%s' (", const_name);
     1383        (*dump_val_cb)(avp_value);
     1384        if (const_name)
     1385                fd_log_debug(")");
     1386       
     1387        /* Done! */
     1388        fd_log_debug("\n");
     1389}
     1390
     1391/* Dump the value of an AVP of known type */
     1392void fd_dict_dump_avp_value(union avp_value *avp_value, struct dict_object * model, int indent)
     1393{
     1394        void (*dump_val_cb)(union avp_value *avp_value);
     1395        struct dict_object * type = NULL;
     1396        char * type_name = NULL;
     1397        char * const_name = NULL;
     1398       
     1399        /* Check the parameters are correct */
     1400        CHECK_PARAMS_DO( avp_value && verify_object(model) && (model->type == DICT_AVP), return );
     1401       
     1402        /* Default: display the value with the formatter for the AVP datatype */
     1403        CHECK_PARAMS_DO( dump_val_cb = get_default_dump_val_cb(model->data.avp.avp_basetype), return );
     1404       
     1405        /* Get the type definition of this AVP */
     1406        type = model->parent;
     1407        if (type) {
     1408                struct dict_enumval_request  request;
     1409                struct dict_object * enumval = NULL;
     1410               
     1411                type_name = type->data.type.type_name;
     1412               
     1413                /* overwrite the dump function ? */
     1414                if (type->data.type.type_dump)
     1415                        dump_val_cb = type->data.type.type_dump;
     1416               
     1417                /* Now check if the AVP value matches a constant */
     1418                memset(&request, 0, sizeof(request));
     1419                request.type_obj = type;
     1420                memcpy(&request.search.enum_value, avp_value, sizeof(union avp_value));
     1421                /* bypass checks */
     1422                if ((search_enumval( type->dico, ENUMVAL_BY_STRUCT, &request, &enumval ) == 0) && (enumval)) {
     1423                        /* We found a cosntant, get its name */
     1424                        const_name = enumval->data.enumval.enum_name;
     1425                }
     1426        }
     1427       
     1428        /* And finally, dump the value */
     1429        dump_avp_val(avp_value, dump_val_cb, model->data.avp.avp_basetype, type_name, const_name, indent);
     1430}
     1431
    12861432/*******************************************************************************************************/
    12871433/*******************************************************************************************************/

  • libfreeDiameter/fifo.c

    r139 r156  
    159159        q->eyec = 0xdead;
    160160       
     161        /* Have all waiting threads return an error */
    161162        while (q->thrs) {
    162163                CHECK_POSIX(  pthread_mutex_unlock( &q->mtx ));

  • libfreeDiameter/libfD.h

    r85 r156  
    5252/* Dispatch / messages / dictionary API */
    5353int fd_dict_disp_cb(enum dict_object_type type, struct dict_object *obj, struct fd_list ** cb_list);
     54void fd_dict_dump_avp_value(union avp_value *avp_value, struct dict_object * model, int indent);
    5455int fd_disp_call_cb_int( struct fd_list * cb_list, struct msg ** msg, struct avp *avp, struct session *sess, enum disp_action *action,
    5556                        struct dict_object * obj_app, struct dict_object * obj_cmd, struct dict_object * obj_avp, struct dict_object * obj_enu);

  • libfreeDiameter/messages.c

    r132 r156  
    691691}
    692692
    693 #define DUMP_VALUE(_format, _parms...)   fd_log_debug(INOBJHDR "value : t:'%s' v:'" _format "'\n", INOBJHDRVAL, typename, ## _parms);
    694 /* Dump an AVP value that is not a constant */
    695 static void dump_basic_type(union avp_value * value, enum dict_avp_basetype type, const char * typename, int indent)
    696 {
    697         switch (type) {
    698                 case AVP_TYPE_GROUPED:
    699                         DUMP_VALUE("%s", "error: grouped AVP with a value!");
    700                         break;
    701                        
    702                 case AVP_TYPE_OCTETSTRING:
    703                         {
    704                                 /* Dump only up to 16 bytes of the buffer */
    705                                 unsigned char buf[8];
    706                                 memset(buf, 0, sizeof(buf));
    707                                 memcpy(buf, value->os.data, value->os.len < sizeof(buf) ? value->os.len : sizeof(buf) );
    708                                 DUMP_VALUE("l:%d, v:%02.2X %02.2X %02.2X %02.2X  %02.2X %02.2X %02.2X %02.2X  ... ('%.*s')",
    709                                                 value->os.len,
    710                                                 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
    711                                                 value->os.len, value->os.data
    712                                                 );
    713                         }
    714                         break;
    715                
    716                 case AVP_TYPE_INTEGER32:
    717                         DUMP_VALUE("%i",value->i32);
    718                         break;
    719 
    720                 case AVP_TYPE_INTEGER64:
    721                         DUMP_VALUE("%lli (0x%llx)",value->i64,value->i64);
    722                         break;
    723 
    724                 case AVP_TYPE_UNSIGNED32:
    725                         DUMP_VALUE("%u",value->u32);
    726                         break;
    727 
    728                 case AVP_TYPE_UNSIGNED64:
    729                         DUMP_VALUE("%llu",value->u64);
    730                         break;
    731 
    732                 case AVP_TYPE_FLOAT32:
    733                         DUMP_VALUE("%f",value->f32);
    734                         break;
    735 
    736                 case AVP_TYPE_FLOAT64:
    737                         DUMP_VALUE("%g",value->f64);
    738                         break;
    739                
    740                 default:
    741                         DUMP_VALUE("%s %d", "error: invalid type :", type);
    742         }
    743 }
    744 
    745 /* Dump an AVP value that is a constant */
    746 #define DUMP_CONST(_format, _parms...)   fd_log_debug(INOBJHDR "value : t:'%s' v:'%s' ( " _format " )\n", INOBJHDRVAL, typename, value->enum_name, ## _parms);
    747 static void dump_constant_type(struct dict_enumval_data * value, enum dict_avp_basetype type, char * typename, int indent)
    748 {
    749         switch (type) {
    750                 case AVP_TYPE_GROUPED:
    751                         DUMP_CONST("%s", "error: grouped AVP with a constant value!");
    752                         break;
    753                 case AVP_TYPE_OCTETSTRING:
    754                         DUMP_CONST("%s", "value skipped");
    755                         break;
    756                
    757                 case AVP_TYPE_INTEGER32:
    758                         DUMP_CONST("%i",value->enum_value.i32);
    759                         break;
    760 
    761                 case AVP_TYPE_INTEGER64:
    762                         DUMP_CONST("%li",value->enum_value.i64);
    763                         break;
    764 
    765                 case AVP_TYPE_UNSIGNED32:
    766                         DUMP_CONST("%u",value->enum_value.u32);
    767                         break;
    768 
    769                 case AVP_TYPE_UNSIGNED64:
    770                         DUMP_CONST("%lu",value->enum_value.u64);
    771                         break;
    772 
    773                 case AVP_TYPE_FLOAT32:
    774                         DUMP_CONST("%f",value->enum_value.f32);
    775                         break;
    776 
    777                 case AVP_TYPE_FLOAT64:
    778                         DUMP_CONST("%g",value->enum_value.f64);
    779                         break;
    780                
    781                 default:
    782                         DUMP_CONST("%s %d", "error: invalid type :", type);
    783         }
    784 }
    785 
    786693/* Dump an avp object */
    787694static void obj_dump_avp ( struct avp * avp, int indent )
    … …  
    834741                        fd_log_debug(INOBJHDR "(data set but no model: ERROR)\n", INOBJHDRVAL);
    835742                } else {
    836                         /* Try and find a constant name for this value */
    837                         struct dictionary * dict = NULL;
    838                         struct dict_object * avp_type = NULL;
    839                         struct dict_object * avp_constant = NULL;
    840                         struct dict_type_data type_data;
    841                         struct dict_enumval_request  request;
    842                         ret = fd_dict_getdict(avp->avp_model, & dict);
    843                         if (ret != 0) {
    844                                 dump_basic_type(avp->avp_public.avp_value, type, type_base_name[type], indent);
    845                                 goto end;
    846                         }
    847                         ret = fd_dict_search(dict, DICT_TYPE, TYPE_OF_AVP, avp->avp_model, &avp_type, ENOENT);
    848                         if (ret != 0) {
    849                                 dump_basic_type(avp->avp_public.avp_value, type, type_base_name[type], indent);
    850                                 goto end;
    851                         }
    852                         ret = fd_dict_getval(avp_type, &type_data);
    853                         if (ret != 0) {
    854                                 dump_basic_type(avp->avp_public.avp_value, type, "(error getting type data)", indent);
    855                                 goto end;
    856                         }
    857                         if (type_data.type_base != type) {
    858                                 dump_basic_type(avp->avp_public.avp_value, type, "(mismatching type information!)", indent);
    859                                 goto end;
    860                         }
    861                         /* Create a query for a constant */
    862                         memset(&request, 0, sizeof(request));
    863                         request.type_obj = avp_type;
    864                         memcpy(&request.search.enum_value, avp->avp_public.avp_value, sizeof(union avp_value));
    865                         ret = fd_dict_search(dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &avp_constant, ENOENT);
    866                         if (ret != 0)  {
    867                                 dump_basic_type(avp->avp_public.avp_value, type, type_data.type_name, indent);
    868                                 goto end;
    869                         }
    870                         /* get the constant's information; we re-use request.search field */
    871                         ret = fd_dict_getval(avp_constant, &request.search);
    872                         if (ret != 0) {
    873                                 dump_basic_type(avp->avp_public.avp_value, type, "(error getting constant data)", indent);
    874                                 goto end;
    875                         }
    876                         dump_constant_type(&request.search, type, type_data.type_name, indent);
     743                        fd_dict_dump_avp_value(avp->avp_public.avp_value, avp->avp_model, indent);
    877744                }
    878745        }
Note: See TracChangeset for help on using the changeset viewer.