Navigation

Changeset 804:c5b7d4a2cc77 in freeDiameter for libfdproto


Ignore:
Timestamp:
Aug 22, 2012, 7:22:46 AM (12 years ago)
Author:
Sebastien Decugis <sdecugis@nict.go.jp>
Branch:
default
Phase:
public
Message:

Log message dumps in one call to the dump function to avoid fragmentation in the log files, as per Zack comment

Location:
libfdproto
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • libfdproto/dictionary.c

    r788 r804  
    13051305
    13061306/* Default dump functions */
    1307 static void dump_val_os(union avp_value * value, FILE * fstr)
     1307static int dump_val_os(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
    13081308{
    13091309        int i;
    13101310        for (i = 0; i < value->os.len; i++) {
    13111311                if (i == 24) { /* Dump only up to 24 bytes of the buffer */
    1312                         fd_log_debug_fstr(fstr, "[...] (len=%zd)", value->os.len);
     1312                        CHECK_FCT( dump_add_str(outstr, offset, outlen, "[...] (len=%zd)", value->os.len) );
    13131313                        break;
    13141314                }
    1315                 fd_log_debug_fstr(fstr, "%02.2X ", value->os.data[i]);
    1316         }
    1317 }
    1318 
    1319 static void dump_val_i32(union avp_value * value, FILE * fstr)
    1320 {
    1321         fd_log_debug_fstr(fstr, "%i (0x%x)", value->i32, value->i32);
    1322 }
    1323 
    1324 static void dump_val_i64(union avp_value * value, FILE * fstr)
    1325 {
    1326         fd_log_debug_fstr(fstr, "%lli (0x%llx)", value->i64, value->i64);
    1327 }
    1328 
    1329 static void dump_val_u32(union avp_value * value, FILE * fstr)
    1330 {
    1331         fd_log_debug_fstr(fstr, "%u (0x%x)", value->u32, value->u32);
    1332 }
    1333 
    1334 static void dump_val_u64(union avp_value * value, FILE * fstr)
    1335 {
    1336         fd_log_debug_fstr(fstr, "%llu (0x%llx)", value->u64, value->u64);
    1337 }
    1338 
    1339 static void dump_val_f32(union avp_value * value, FILE * fstr)
    1340 {
    1341         fd_log_debug_fstr(fstr, "%f", value->f32);
    1342 }
    1343 
    1344 static void dump_val_f64(union avp_value * value, FILE * fstr)
    1345 {
    1346         fd_log_debug_fstr(fstr, "%g", value->f64);
     1315                CHECK_FCT( dump_add_str(outstr, offset, outlen, "%02.2X ", value->os.data[i]) );
     1316        }
     1317        return 0;
     1318}
     1319
     1320static int dump_val_i32(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
     1321{
     1322        CHECK_FCT( dump_add_str(outstr, offset, outlen, "%i (0x%x)", value->i32, value->i32) );
     1323        return 0;
     1324}
     1325
     1326static int dump_val_i64(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
     1327{
     1328        CHECK_FCT( dump_add_str(outstr, offset, outlen, "%lli (0x%llx)", value->i64, value->i64) );
     1329        return 0;
     1330}
     1331
     1332static int dump_val_u32(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
     1333{
     1334        CHECK_FCT( dump_add_str(outstr, offset, outlen, "%u (0x%x)", value->u32, value->u32) );
     1335        return 0;
     1336}
     1337
     1338static int dump_val_u64(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
     1339{
     1340        CHECK_FCT( dump_add_str(outstr, offset, outlen, "%llu (0x%llx)", value->u64, value->u64) );
     1341        return 0;
     1342}
     1343
     1344static int dump_val_f32(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
     1345{
     1346        CHECK_FCT( dump_add_str(outstr, offset, outlen, "%f", value->f32) );
     1347        return 0;
     1348}
     1349
     1350static int dump_val_f64(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
     1351{
     1352        CHECK_FCT( dump_add_str(outstr, offset, outlen, "%g", value->f64) );
     1353        return 0;
    13471354}
    13481355
    13491356/* Get the dump function for basic dict_avp_basetype */
    1350 static void (*get_default_dump_val_cb(enum dict_avp_basetype datatype))(union avp_value *, FILE *)
     1357static int (*get_default_dump_val_cb(enum dict_avp_basetype datatype))(union avp_value *, char **, size_t *, size_t *)
    13511358{
    13521359        switch (datatype) {
    … …  
    13831390
    13841391/* Formater for the AVP value dump line */
    1385 static void dump_avp_val(union avp_value *avp_value, void (*dump_val_cb)(union avp_value *, FILE *), enum dict_avp_basetype datatype, char * type_name, char * const_name, int indent, FILE * fstr)
     1392static int dump_avp_val(union avp_value *avp_value,
     1393                        int (*def_dump_val_cb)(union avp_value *, char **, size_t *, size_t *),
     1394                        char * (*dump_val_cb)(union avp_value *),
     1395                        enum dict_avp_basetype datatype,
     1396                        char * type_name,
     1397                        char * const_name,
     1398                        int indent,
     1399                        char **outstr,
     1400                        size_t *offset,
     1401                        size_t *outlen)
    13861402{
    13871403        /* Header for all AVP values dumps: */
    1388         fd_log_debug_fstr(fstr, INOBJHDR "value ", INOBJHDRVAL);
     1404        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "value ", INOBJHDRVAL) );
    13891405       
    13901406        /* If the type is provided, write it */
    1391         if (type_name)
    1392                 fd_log_debug_fstr(fstr, "t: '%s' ", type_name);
     1407        if (type_name) {
     1408                CHECK_FCT( dump_add_str(outstr, offset, outlen, "t: '%s' ", type_name) );
     1409        }
    13931410       
    13941411        /* Always give the base datatype anyway */
    1395         fd_log_debug_fstr(fstr, "(%s) ", type_base_name[datatype]);
     1412        CHECK_FCT( dump_add_str(outstr, offset, outlen, "(%s) ", type_base_name[datatype]) );
    13961413       
    13971414        /* Now, the value */
    1398         fd_log_debug_fstr(fstr, "v: ");
    1399         if (const_name)
    1400                 fd_log_debug_fstr(fstr, "'%s' (", const_name);
    1401         (*dump_val_cb)(avp_value, fstr);
    1402         if (const_name)
    1403                 fd_log_debug_fstr(fstr, ")");
     1415        CHECK_FCT( dump_add_str(outstr, offset, outlen, "v: ") );
     1416        if (const_name) {
     1417                CHECK_FCT( dump_add_str(outstr, offset, outlen, "'%s' (", const_name) );
     1418        }
     1419        if (dump_val_cb) {
     1420                char * str;
     1421                CHECK_MALLOC_DO( str = (*dump_val_cb)(avp_value), dump_add_str(outstr, offset, outlen, "(dump failed)") );
     1422                CHECK_FCT( dump_add_str(outstr, offset, outlen, "%s", str) );
     1423                free(str);
     1424        } else {
     1425                CHECK_FCT( (*def_dump_val_cb)(avp_value, outstr, offset, outlen) );
     1426        }
     1427        if (const_name) {
     1428                CHECK_FCT( dump_add_str(outstr, offset, outlen, ")") );
     1429        }
    14041430       
    14051431        /* Done! */
    1406         fd_log_debug_fstr(fstr, "\n");
    1407 }
    1408 
    1409 /* Dump the value of an AVP of known type */
    1410 void fd_dict_dump_avp_value(union avp_value *avp_value, struct dict_object * model, int indent, FILE * fstr)
    1411 {
    1412         void (*dump_val_cb)(union avp_value *avp_value, FILE * fstr);
     1432        CHECK_FCT( dump_add_str(outstr, offset, outlen, "\n") );
     1433        return 0;
     1434}
     1435
     1436/* Dump the value of an AVP of known type into the returned str */
     1437int fd_dict_dump_avp_value(union avp_value *avp_value, struct dict_object * model, int indent, char **outstr, size_t *offset, size_t *outlen)
     1438{
     1439        char * (*dump_val_cb)(union avp_value *avp_value) = NULL;
    14131440        struct dict_object * type = NULL;
    14141441        char * type_name = NULL;
    … …  
    14161443       
    14171444        /* Check the parameters are correct */
    1418         CHECK_PARAMS_DO( avp_value && verify_object(model) && (model->type == DICT_AVP), return );
    1419        
    1420         /* Default: display the value with the formatter for the AVP datatype */
    1421         CHECK_PARAMS_DO( dump_val_cb = get_default_dump_val_cb(model->data.avp.avp_basetype), return );
     1445        CHECK_PARAMS( avp_value && verify_object(model) && (model->type == DICT_AVP) );
    14221446       
    14231447        /* Get the type definition of this AVP */
    … …  
    14451469       
    14461470        /* And finally, dump the value */
    1447         dump_avp_val(avp_value, dump_val_cb, model->data.avp.avp_basetype, type_name, const_name, indent, fstr);
     1471        CHECK_FCT( dump_avp_val(avp_value, get_default_dump_val_cb(model->data.avp.avp_basetype), dump_val_cb, model->data.avp.avp_basetype, type_name, const_name, indent, outstr, offset, outlen) );
     1472        return 0;
    14481473}
    14491474

  • libfdproto/fdproto-internal.h

    r740 r804  
    6060/* Dispatch / messages / dictionary API */
    6161int fd_dict_disp_cb(enum dict_object_type type, struct dict_object *obj, struct fd_list ** cb_list);
    62 void fd_dict_dump_avp_value(union avp_value *avp_value, struct dict_object * model, int indent, FILE * fstr);
     62int fd_dict_dump_avp_value(union avp_value *avp_value, struct dict_object * model, int indent, char **outstr, size_t *offset, size_t *outlen);
    6363int fd_disp_call_cb_int( struct fd_list * cb_list, struct msg ** msg, struct avp *avp, struct session *sess, enum disp_action *action,
    6464                        struct dict_object * obj_app, struct dict_object * obj_cmd, struct dict_object * obj_avp, struct dict_object * obj_enu);
    … …  
    7070int fd_sess_reclaim_msg ( struct session ** session );
    7171
     72/* For dump routines into string buffers */
     73#include <stdarg.h>
     74static __inline__ int dump_init_str(char **outstr, size_t *offset, size_t *outlen)
     75{
     76        *outlen = 1<<12;
     77        CHECK_MALLOC( *outstr = malloc(*outlen) );
     78        *offset = 0;
     79        (*outstr)[0] = 0;
     80        return 0;
     81}
     82static __inline__ int dump_add_str(char **outstr, size_t *offset, size_t *outlen, char * fmt, ...)
     83{
     84        va_list argp;
     85        int len;
     86        va_start(argp, fmt);
     87        len = vsnprintf(*outstr + *offset, *outlen - *offset, fmt, argp);
     88        va_end(argp);
     89        if ((len + *offset) >= *outlen) {
     90                char * newstr;
     91                /* buffer was too short, extend */
     92                size_t newsize = ((len + *offset) + (1<<12)) & ~((1<<12) - 1); /* next multiple of 4k */
     93                CHECK_MALLOC( newstr = realloc(*outstr, newsize) );
     94               
     95                /* redo */
     96                *outstr = newstr;
     97                *outlen = newsize;
     98                va_start(argp, fmt);
     99                len = vsnprintf(*outstr + *offset, *outlen - *offset, fmt, argp);
     100                va_end(argp);
     101        }
     102        *offset += len;
     103        return 0;
     104}
     105
     106
     107
    72108#endif /* _LIBFDPROTO_INTERNAL_H */

  • libfdproto/messages.c

    r792 r804  
    662662#define INOBJHDRVAL     indent<0 ? 1 : indent, indent<0 ? "-" : "|"
    663663
     664/* Write some debug data in a buffer */
     665
    664666/* Dump a msg_t object */
    665 static void obj_dump_msg (struct msg * msg, int indent, FILE * fstr )
     667static int obj_dump_msg (struct msg * msg, int indent, char **outstr, size_t *offset, size_t *outlen )
    666668{
    667669        int ret = 0;
    668670       
    669         fd_log_debug_fstr(fstr, "%*sMSG: %p\n", INOBJHDRVAL, msg);
     671        CHECK_FCT( dump_add_str(outstr, offset, outlen, "%*sMSG: %p\n", INOBJHDRVAL, msg) );
    670672       
    671673        if (!CHECK_MSG(msg)) {
    672                 fd_log_debug_fstr(fstr, INOBJHDR "INVALID!\n", INOBJHDRVAL);
    673                 return;
     674                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "INVALID!\n", INOBJHDRVAL) );
     675                return 0;
    674676        }
    675677       
    676678        if (!msg->msg_model) {
    677679               
    678                 fd_log_debug_fstr(fstr, INOBJHDR "(no model)\n", INOBJHDRVAL);
     680                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(no model)\n", INOBJHDRVAL) );
    679681               
    680682        } else {
    … …  
    684686                ret = fd_dict_gettype(msg->msg_model, &dicttype);
    685687                if (ret || (dicttype != DICT_COMMAND)) {
    686                         fd_log_debug_fstr(fstr, INOBJHDR "(invalid model: %d %d)\n", INOBJHDRVAL, ret, dicttype);
     688                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(invalid model: %d %d)\n", INOBJHDRVAL, ret, dicttype) );
    687689                        goto public;
    688690                }
    689691                ret = fd_dict_getval(msg->msg_model, &dictdata);
    690692                if (ret != 0) {
    691                         fd_log_debug_fstr(fstr, INOBJHDR "(error getting model data: %s)\n", INOBJHDRVAL, strerror(ret));
     693                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(error getting model data: %s)\n", INOBJHDRVAL, strerror(ret)) );
    692694                        goto public;
    693695                }
    694                 fd_log_debug_fstr(fstr, INOBJHDR "model : v/m:" DUMP_CMDFL_str "/" DUMP_CMDFL_str ", %u \"%s\"\n", INOBJHDRVAL,
    695                         DUMP_CMDFL_val(dictdata.cmd_flag_val), DUMP_CMDFL_val(dictdata.cmd_flag_mask), dictdata.cmd_code, dictdata.cmd_name);
     696                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "model : v/m:" DUMP_CMDFL_str "/" DUMP_CMDFL_str ", %u \"%s\"\n", INOBJHDRVAL,
     697                        DUMP_CMDFL_val(dictdata.cmd_flag_val), DUMP_CMDFL_val(dictdata.cmd_flag_mask), dictdata.cmd_code, dictdata.cmd_name) );
    696698        }
    697699public:
    698         fd_log_debug_fstr(fstr, INOBJHDR "public: V:%d L:%d fl:" DUMP_CMDFL_str " CC:%u A:%d hi:%x ei:%x\n", INOBJHDRVAL,
     700        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "public: V:%d L:%d fl:" DUMP_CMDFL_str " CC:%u A:%d hi:%x ei:%x\n", INOBJHDRVAL,
    699701                msg->msg_public.msg_version,
    700702                msg->msg_public.msg_length,
    … …  
    704706                msg->msg_public.msg_hbhid,
    705707                msg->msg_public.msg_eteid
    706                 );
    707         fd_log_debug_fstr(fstr, INOBJHDR "intern: rwb:%p rt:%d cb:%p(%p) qry:%p asso:%d sess:%p src:%s(%zd)\n",
    708                         INOBJHDRVAL, msg->msg_rawbuffer, msg->msg_routable, msg->msg_cb.fct, msg->msg_cb.data, msg->msg_query, msg->msg_associated, msg->msg_sess, msg->msg_src_id?:"(nil)", msg->msg_src_id_len);
     708                ) );
     709        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "intern: rwb:%p rt:%d cb:%p(%p) qry:%p asso:%d sess:%p src:%s(%zd)\n",
     710                        INOBJHDRVAL, msg->msg_rawbuffer, msg->msg_routable, msg->msg_cb.fct, msg->msg_cb.data, msg->msg_query, msg->msg_associated, msg->msg_sess, msg->msg_src_id?:"(nil)", msg->msg_src_id_len) );
     711        return 0;
    709712}
    710713
    711714/* Dump an avp object */
    712 static void obj_dump_avp ( struct avp * avp, int indent, FILE * fstr )
     715static int obj_dump_avp ( struct avp * avp, int indent, char **outstr, size_t *offset, size_t *outlen )
    713716{
    714717        int ret = 0;
    715718       
    716719        if (!CHECK_AVP(avp)) {
    717                 fd_log_debug_fstr(fstr, INOBJHDR "INVALID!\n", INOBJHDRVAL);
    718                 return;
     720                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "INVALID!\n", INOBJHDRVAL) );
     721                return 0;
    719722        }
    720723       
    721724        if (!avp->avp_model) {
    722725               
    723                 fd_log_debug_fstr(fstr, INOBJHDR "(no model)\n", INOBJHDRVAL);
     726                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(no model)\n", INOBJHDRVAL) );
    724727               
    725728        } else {
    … …  
    729732                ret = fd_dict_gettype(avp->avp_model, &dicttype);
    730733                if (ret || (dicttype != DICT_AVP)) {
    731                         fd_log_debug_fstr(fstr, INOBJHDR "(invalid model: %d %d)\n", INOBJHDRVAL, ret, dicttype);
     734                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(invalid model: %d %d)\n", INOBJHDRVAL, ret, dicttype) );
    732735                        goto public;
    733736                }
    734737                ret = fd_dict_getval(avp->avp_model, &dictdata);
    735738                if (ret != 0) {
    736                         fd_log_debug_fstr(fstr, INOBJHDR "(error getting model data: %s)\n", INOBJHDRVAL, strerror(ret));
     739                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(error getting model data: %s)\n", INOBJHDRVAL, strerror(ret)) );
    737740                        goto public;
    738741                }
    739                 fd_log_debug_fstr(fstr, INOBJHDR "model : v/m:" DUMP_AVPFL_str "/" DUMP_AVPFL_str ", %12s, %u \"%s\"\n", INOBJHDRVAL,
     742                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "model : v/m:" DUMP_AVPFL_str "/" DUMP_AVPFL_str ", %12s, %u \"%s\"\n", INOBJHDRVAL,
    740743                        DUMP_AVPFL_val(dictdata.avp_flag_val),
    741744                        DUMP_AVPFL_val(dictdata.avp_flag_mask),
    742745                        type_base_name[dictdata.avp_basetype],
    743746                        dictdata.avp_code,
    744                         dictdata.avp_name );
     747                        dictdata.avp_name ) );
    745748        }
    746749public:
    747         fd_log_debug_fstr(fstr, INOBJHDR "public: C:%u fl:" DUMP_AVPFL_str " L:%d V:%u  data:@%p\n", INOBJHDRVAL,
     750        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "public: C:%u fl:" DUMP_AVPFL_str " L:%d V:%u  data:@%p\n", INOBJHDRVAL,
    748751                avp->avp_public.avp_code,
    749752                DUMP_AVPFL_val(avp->avp_public.avp_flags),
    … …  
    751754                avp->avp_public.avp_vendor,
    752755                avp->avp_public.avp_value
    753                 );
     756                ) );
    754757        /* Dump the value if set */
    755758        if (avp->avp_public.avp_value) {
    756759                if (!avp->avp_model) {
    757                         fd_log_debug_fstr(fstr, INOBJHDR "(data set but no model: ERROR)\n", INOBJHDRVAL);
     760                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(data set but no model: ERROR)\n", INOBJHDRVAL) );
    758761                } else {
    759                         fd_dict_dump_avp_value(avp->avp_public.avp_value, avp->avp_model, indent, fstr);
    760                 }
    761         }
    762 
    763         fd_log_debug_fstr(fstr, INOBJHDR "intern: src:%p mf:%d raw:%p(%d)\n", INOBJHDRVAL, avp->avp_source, avp->avp_mustfreeos, avp->avp_rawdata, avp->avp_rawlen);
    764 }
    765 
    766 /* Dump a single object content */
    767 static void msg_dump_intern ( int level, msg_or_avp * obj, int indent, FILE * fstr )
     762                        CHECK_FCT( fd_dict_dump_avp_value(avp->avp_public.avp_value, avp->avp_model, indent, outstr, offset, outlen) );
     763                }
     764        }
     765
     766        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "intern: src:%p mf:%d raw:%p(%d)\n", INOBJHDRVAL, avp->avp_source, avp->avp_mustfreeos, avp->avp_rawdata, avp->avp_rawlen) );
     767        return 0;
     768}
     769
     770/* Dump a single object content into out string, realloc if needed */
     771static int msg_dump_intern ( int level, msg_or_avp * obj, int indent, char **outstr, size_t *offset, size_t *outlen )
    768772{
    769773        /* Log only if we are at least at level */
    770774        if ( ! TRACE_BOOL(level) )
    771                 return;
     775                return 0;
    772776       
    773777        /* Check the object */
    774778        if (!VALIDATE_OBJ(obj)) {
    775                 fd_log_debug_fstr(fstr, ">>> invalid object (%p)!.\n", obj);
    776                 return;
     779                CHECK_FCT( dump_add_str(outstr, offset, outlen, ">>> invalid object (%p)!.\n", obj) );
     780                return 0;
    777781        }
    778782       
    … …  
    780784        switch (_C(obj)->type) {
    781785                case MSG_AVP:
    782                         obj_dump_avp ( _A(obj), indent, fstr );
     786                        CHECK_FCT( obj_dump_avp ( _A(obj), indent, outstr, offset, outlen ));
    783787                        break;
    784788               
    785789                case MSG_MSG:
    786                         obj_dump_msg ( _M(obj), indent, fstr );
     790                        CHECK_FCT( obj_dump_msg ( _M(obj), indent, outstr, offset, outlen ) );
    787791                        break;
    788792               
    … …  
    790794                        ASSERT(0);
    791795        }
     796        return 0;
    792797}
    793798
    … …  
    797802        msg_or_avp * ref = msg;
    798803        int indent = 2;
     804        char *outstr;
     805        size_t offset, outlen;
     806        CHECK_FCT_DO( dump_init_str(&outstr, &offset, &outlen), { fd_log_debug_fstr(fstr, "Error initializing string for dumping %p\n", msg); return; } );
    799807        do {
    800                 msg_dump_intern ( NONE, ref, indent, fstr );
     808                CHECK_FCT_DO(  msg_dump_intern ( NONE, ref, indent, &outstr, &offset, &outlen ),
     809                                fd_log_debug_fstr(fstr, "Error while dumping %p\n", ref) );
    801810               
    802811                /* Now find the next object */
    … …  
    805814                /* dump next object */
    806815        } while (ref);
     816       
     817        /* now really output this in one shot, so it is not interrupted */
     818        fd_log_debug_fstr(fstr, "%s", outstr);
     819       
     820        free(outstr);
    807821}
    808822void fd_msg_dump_fstr_one ( struct msg * msg, FILE * fstr ) /* just the header */
    809823{
    810         msg_dump_intern ( NONE, msg, 2, fstr );
     824        char *outstr;
     825        size_t offset, outlen;
     826        CHECK_FCT_DO( dump_init_str(&outstr, &offset, &outlen), { fd_log_debug_fstr(fstr, "Error initializing string for dumping %p\n", msg); return; } );
     827        CHECK_FCT_DO(  msg_dump_intern ( NONE, msg, 2, &outstr, &offset, &outlen ),
     828                                fd_log_debug_fstr(fstr, "Error while dumping %p\n", msg) );
     829        /* now really output this in one shot, so it is not interrupted */
     830        fd_log_debug_fstr(fstr, "%s", outstr);
     831       
     832        free(outstr);
    811833}
    812834
    … …  
    816838        msg_or_avp * ref = obj;
    817839        int indent = 1;
    818        
    819         TRACE_DEBUG(level, "------ Dumping object %p (w)-------", obj);
     840        char *outstr;
     841        size_t offset, outlen;
     842        CHECK_FCT_DO( dump_init_str(&outstr, &offset, &outlen),
     843                        { fd_log_debug_fstr(fd_g_debug_fstr, "Error initializing string for dumping %p\n", obj); return; } );
     844
    820845        do {
    821                 msg_dump_intern ( level, ref, indent, fd_g_debug_fstr );
     846                CHECK_FCT_DO(  msg_dump_intern ( level, ref, indent, &outstr, &offset, &outlen ),
     847                                fd_log_debug_fstr(fd_g_debug_fstr, "Error while dumping %p\n", ref) );
    822848               
    823849                /* Now find the next object */
    … …  
    827853        } while (ref);
    828854       
     855        /* now really output this in one shot, so it is not interrupted */
     856        TRACE_DEBUG(level, "------ Dumping object %p (w)-------", obj);
     857        fd_log_debug_fstr(fd_g_debug_fstr, "%s", outstr);
    829858        TRACE_DEBUG(level, "------ /end of object %p -------", obj);
     859       
     860        free(outstr);
    830861}
    831862
    … …  
    833864void fd_msg_dump_one ( int level, msg_or_avp * obj )
    834865{
     866        char *outstr;
     867        size_t offset, outlen;
     868        CHECK_FCT_DO( dump_init_str(&outstr, &offset, &outlen),
     869                        { fd_log_debug_fstr(fd_g_debug_fstr, "Error initializing string for dumping %p\n", obj); return; } );
     870        CHECK_FCT_DO(  msg_dump_intern ( level, obj, 1, &outstr, &offset, &outlen ),
     871                        fd_log_debug_fstr(fd_g_debug_fstr, "Error while dumping %p\n", obj) );
    835872        TRACE_DEBUG(level, "------ Dumping object %p (s)-------", obj);
    836         msg_dump_intern ( level, obj, 1, fd_g_debug_fstr );
     873        fd_log_debug_fstr(fd_g_debug_fstr, "%s", outstr);
    837874        TRACE_DEBUG(level, "------ /end of object %p -------", obj);
     875        free(outstr);
    838876}
    839877
    … …  
    16881726                if (mandatory && (avp->avp_public.avp_flags & AVP_FLAG_MANDATORY)) {
    16891727                        TRACE_DEBUG(INFO, "Unsupported mandatory AVP found:");
    1690                         msg_dump_intern(INFO, avp, 2, fd_g_debug_fstr);
     1728                        fd_msg_dump_one(INFO, avp);
    16911729                        if (error_info) {
    16921730                                error_info->pei_errcode = "DIAMETER_AVP_UNSUPPORTED";
Note: See TracChangeset for help on using the changeset viewer.