Navigation

Changeset 804:c5b7d4a2cc77 in freeDiameter


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

Files:
5 edited

Legend:

Unmodified
Added
Removed

  • include/freeDiameter/libfdproto.h

    r788 r804  
    11151115        dict_avpdata_interpret   type_interpret;/* cb to convert the AVP value in more comprehensive format (or NULL) */
    11161116        dict_avpdata_encode      type_encode;   /* cb to convert formatted data into an AVP value (or NULL) */
    1117         void                    (*type_dump)(union avp_value * val, FILE * fstr);       /* cb called by fd_msg_dump_one for this type of data (if != NULL), to dump the AVP value in fstr */
     1117        char *                  (*type_dump)(union avp_value * val);    /* cb called by fd_msg_dump_one for this type of data (if != NULL). Returned string must be freed. */
    11181118};
    11191119

  • libfdcore/dict_base_proto.c

    r740 r804  
    145145
    146146/* Dump the content of an Address AVP */
    147 static void Address_dump(union avp_value * avp_value, FILE * fstr)
     147static char * Address_dump(union avp_value * avp_value)
    148148{
     149        char * ret;
     150        #define STR_LEN 1024
    149151        union {
    150152                sSA     sa;
    … …  
    157159        memset(&s, 0, sizeof(s));
    158160       
     161        CHECK_MALLOC_DO( ret = malloc(STR_LEN), return NULL );
     162       
    159163        /* The first two octets represent the address family, http://www.iana.org/assignments/address-family-numbers/ */
    160164        if (avp_value->os.len < 2) {
    161                 fd_log_debug_fstr(fstr, "[invalid length: %d]", avp_value->os.len);
    162                 return;
     165                snprintf(ret, STR_LEN, "[invalid length: %d]", avp_value->os.len);
     166                return ret;
    163167        }
    164168       
    … …  
    170174                        s.sa.sa_family = AF_INET;
    171175                        if (avp_value->os.len != 6) {
    172                                 fd_log_debug_fstr(fstr, "[invalid IP length: %d]", avp_value->os.len);
    173                                 return;
     176                                snprintf(ret, STR_LEN, "[invalid IP length: %d]", avp_value->os.len);
     177                                return ret;
    174178                        }
    175179                        memcpy(&s.sin.sin_addr.s_addr, avp_value->os.data + 2, 4);
    … …  
    179183                        s.sa.sa_family = AF_INET6;
    180184                        if (avp_value->os.len != 18) {
    181                                 fd_log_debug_fstr(fstr, "[invalid IP6 length: %d]", avp_value->os.len);
    182                                 return;
     185                                snprintf(ret, STR_LEN, "[invalid IP6 length: %d]", avp_value->os.len);
     186                                return ret;
    183187                        }
    184188                        memcpy(&s.sin6.sin6_addr.s6_addr, avp_value->os.data + 2, 16);
    185189                        break;
    186190                default:
    187                         fd_log_debug_fstr(fstr, "[unsupported family: 0x%hx]", fam);
    188                         return;
     191                        snprintf(ret, STR_LEN, "[unsupported family: 0x%hx]", fam);
     192                        return ret;
    189193        }
    190194       
    191195        {
    192                 char addrbuf[INET6_ADDRSTRLEN];
    193                 int rc = getnameinfo(&s.sa, sSAlen(&s.sa), addrbuf, INET6_ADDRSTRLEN, NULL, 0, NI_NUMERICHOST);
     196                int rc = getnameinfo(&s.sa, sSAlen(&s.sa), ret, STR_LEN, NULL, 0, NI_NUMERICHOST);
    194197                if (rc)
    195                         fd_log_debug_fstr(fstr, "%s", (char *)gai_strerror(rc));
    196                 else
    197                         fd_log_debug_fstr(fstr, "%s", addrbuf);
    198                
     198                        snprintf(ret, STR_LEN, "%s", (char *)gai_strerror(rc));
    199199        }
     200       
     201        return ret;
    200202}
    201203
    202 static void UTF8String_dump(union avp_value * avp_value, FILE * fstr)
     204static char * UTF8String_dump(union avp_value * avp_value)
    203205{
    204         size_t len = avp_value->os.len;
    205         if (len > 42)
    206                 len = 42; /* avoid very long strings */
    207         fd_log_debug_fstr(fstr, "%.*s", len, avp_value->os.data);
     206        return strndup((char *)avp_value->os.data, 42); /* avoid very long strings */
    208207}
    209208

  • 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.