Navigation

Changeset 1093:44f3e48dfe27 in freeDiameter


Ignore:
Timestamp:
May 6, 2013, 5:33:22 PM (11 years ago)
Author:
Sebastien Decugis <sdecugis@freediameter.net>
Branch:
default
Phase:
public
Message:

Align the behavior of all fd_*dump functions wrt final \n

Files:
15 edited

Legend:

Unmodified
Added
Removed

  • include/freeDiameter/libfdproto.h

    r1088 r1093  
    222222
    223223
    224 /* Helper functions for the *dump functions that add into a buffer */
    225 char * fd_dump_extend(char ** buf, size_t *len, size_t *offset, const char * format, ... ) _ATTRIBUTE_PRINTFLIKE_(4,5);
    226 char * fd_dump_extend_hexdump(char ** buf, size_t *len, size_t *offset, uint8_t *data, size_t datalen, size_t trunc, size_t wrap );
    227 
    228 /* All dump functions follow the same prototype:
    229  * PARAMETERS:
    230  *   buf   : *buf can be NULL on entry, it will be malloc'd. Otherwise it can be realloc'd if needed.
     224/* All dump functions follow this same prototype:
     225 * PARAMETERS:
     226 *   buf   : *buf can be NULL on entry, it will be malloc'd. Otherwise it is realloc'd if needed.
    231227 *   len   : the current size of the buffer (in/out)
    232228 *   offset: (optional) if provided, starts writing dump at offset in the buffer, and updated upon exit. if NULL, starts at offset O.
    … …  
    234230 * RETURN VALUE:
    235231 *   *buf upon success, NULL upon failure.
    236  * After the buffer has been used, it should be freed.
     232 *
     233 * REMARKS:
     234 *  - After the buffer has been used, it should be freed.
     235 *  - Depending on the function, the created string may be multi-line. However, it should never be terminated with a '\n'.
    237236 */
    238237#define DECLARE_FD_DUMP_PROTOTYPE( function_name, args... )     \
    239238        char * function_name(char ** buf, size_t *len, size_t *offset, ##args)
    240239       
     240
     241/* Helper functions for the *dump functions that add into a buffer */
     242DECLARE_FD_DUMP_PROTOTYPE( fd_dump_extend, const char * format, ... ) _ATTRIBUTE_PRINTFLIKE_(4,5);
     243DECLARE_FD_DUMP_PROTOTYPE( fd_dump_extend_hexdump, uint8_t *data, size_t datalen, size_t trunc, size_t wrap );
     244
     245
     246/* Some helpers macro for writing such *_dump routine */
    241247#define FD_DUMP_STD_PARAMS  buf, len, offset
     248#define FD_DUMP_HANDLE_OFFSET()  size_t o = 0; if (!offset) offset = &o
     249#define FD_DUMP_HANDLE_TRAIL()  while ((*buf) && (*offset > 0) && ((*buf)[*offset - 1] == '\n')) { *offset -= 1; (*buf)[*offset] = '\0'; }
     250
    242251
    243252
    … …  
    10161025        VENDOR_BY_ID = 10,      /* "what" points to a vendor_id_t */
    10171026        VENDOR_BY_NAME,         /* "what" points to a char * */
    1018         VENDOR_OF_APPLICATION   /* "what" points to a struct dict_object containing an application (see below) */
     1027        VENDOR_OF_APPLICATION,  /* "what" points to a struct dict_object containing an application (see below) */
     1028        VENDOR_OF_AVP,          /* "what" points to a struct dict_object containing an avp (see below) */
    10191029};
    10201030
    … …  
    14051415
    14061416/* For dumping flags and values */
    1407 #define DUMP_AVPFL_str  "%c%c"
    1408 #define DUMP_AVPFL_val(_val) (_val & AVP_FLAG_VENDOR)?'V':'-' , (_val & AVP_FLAG_MANDATORY)?'M':'-'
     1417#define DUMP_AVPFL_str  "%c%c%s%s%s%s%s%s"
     1418#define DUMP_AVPFL_val(_val) (_val & AVP_FLAG_VENDOR)?'V':'-' , (_val & AVP_FLAG_MANDATORY)?'M':'-',    \
     1419                                (_val & AVP_FLAG_RESERVED3)?"3":"", (_val & AVP_FLAG_RESERVED4)?"4":"", \
     1420                                (_val & AVP_FLAG_RESERVED5)?"5":"", (_val & AVP_FLAG_RESERVED6)?"6":"", (_val & AVP_FLAG_RESERVED7)?"7":"", (_val & AVP_FLAG_RESERVED8)?"8":""
    14091421
    14101422/* Type to hold data associated to an avp */
    … …  
    15551567
    15561568/* For dumping flags and values */
    1557 #define DUMP_CMDFL_str  "%c%c%c%c"
    1558 #define DUMP_CMDFL_val(_val) (_val & CMD_FLAG_REQUEST)?'R':'-' , (_val & CMD_FLAG_PROXIABLE)?'P':'-' , (_val & CMD_FLAG_ERROR)?'E':'-' , (_val & CMD_FLAG_RETRANSMIT)?'T':'-'
     1569#define DUMP_CMDFL_str  "%c%c%c%c%s%s%s%s"
     1570#define DUMP_CMDFL_val(_val) (_val & CMD_FLAG_REQUEST)?'R':'-' , (_val & CMD_FLAG_PROXIABLE)?'P':'-' , (_val & CMD_FLAG_ERROR)?'E':'-' , (_val & CMD_FLAG_RETRANSMIT)?'T':'-', \
     1571                                (_val & CMD_FLAG_RESERVED5)?"5":"", (_val & CMD_FLAG_RESERVED6)?"6":"", (_val & CMD_FLAG_RESERVED7)?"7":"", (_val & CMD_FLAG_RESERVED8)?"8":""
    15591572
    15601573/* Type to hold data associated to a command */

  • libfdcore/config.c

    r1085 r1093  
    8383DECLARE_FD_DUMP_PROTOTYPE(fd_conf_dump)
    8484{
    85         size_t o=0;
    86         if (!offset)
    87                 offset = &o;
     85        FD_DUMP_HANDLE_OFFSET();
    8886       
    8987        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{freeDiameter configuration}(@%p): \n", fd_g_config), return NULL);       

  • libfdcore/endpoints.c

    r1085 r1093  
    287287DECLARE_FD_DUMP_PROTOTYPE(fd_ep_dump_one, struct fd_endpoint * ep )
    288288{
    289         size_t o = 0;
    290         if (!offset)
    291                 offset=&o;
     289        FD_DUMP_HANDLE_OFFSET();
    292290       
    293291        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{ep}(@%p): ", ep), return NULL);
    294292       
    295293        if (!ep) {
    296                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL\n"), return NULL);
     294                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL"), return NULL);
    297295                return *buf;
    298296        }
    … …  
    311309{
    312310        struct fd_list * li;
    313         size_t o = 0;
    314         if (!offset)
    315                 offset=&o;
    316        
    317         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*s{eps}(@%p):\n", indent, "", eps), return NULL);
     311       
     312        FD_DUMP_HANDLE_OFFSET();
     313       
     314        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*s{eps}(@%p):", indent, "", eps), return NULL);
    318315        if (eps) {
    319316                for (li = eps->next; li != eps; li = li->next) {
    320317                        struct fd_endpoint * ep = (struct fd_endpoint *)li;
    321                         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*s", indent+1, ""), return NULL);
     318                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n%*s", indent+1, ""), return NULL);
    322319                        CHECK_MALLOC_DO( fd_ep_dump_one( FD_DUMP_STD_PARAMS, ep ), return NULL);
    323                         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
    324                 }
    325         }
    326 }
    327        
     320                }
     321        }
     322}
     323       

  • libfdcore/events.c

    r1085 r1093  
    165165{
    166166        struct fd_list * li;
    167         size_t o=0;
    168         if (!offset)
    169                 offset=&o;
     167        FD_DUMP_HANDLE_OFFSET();
    170168       
    171169        CHECK_POSIX_DO( pthread_rwlock_rdlock(&trig_rwl),  );
    … …  
    173171        for (li = trig_list.next; li != &trig_list; li = li->next) {
    174172                struct trig_item *t = li->o;
    175                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{trigger sig:%d}'%s'->%p ", t->trig_value, t->trig_module, t->cb), break);
     173                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{signal:%d}'%s'->%p ", t->trig_value, t->trig_module, t->cb), break);
    176174        }
    177175       

  • libfdcore/extensions.c

    r1085 r1093  
    8888        {
    8989                struct fd_ext_info * ext = (struct fd_ext_info *)li;
    90                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{extension}(@%p): '%s'[%s], %sloaded\n", ext, ext->filename, ext->conffile?:"no conf", ext->handler ? "" : "not "), return NULL);
     90                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{extension}(@%p): '%s'[%s], %sloaded%s", ext, ext->filename, ext->conffile?:"no conf", ext->handler ? "" : "not ", (li->next == &ext_list) ? "":"\n"), return NULL);
    9191        }
    9292        return *buf;

  • libfdcore/peers.c

    r1085 r1093  
    412412DECLARE_FD_DUMP_PROTOTYPE(fd_peer_dump, struct peer_hdr * p, int details)
    413413{
    414         size_t o=0;
    415         if (!offset)
    416                 offset = &o;
     414        FD_DUMP_HANDLE_OFFSET();
    417415       
    418416        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{peer}(@%p): ", p), return NULL);
    … …  
    454452{
    455453        struct fd_list * li;
    456         size_t o=0;
    457         if (!offset)
    458                 offset = &o;
     454        FD_DUMP_HANDLE_OFFSET();
    459455       
    460456        CHECK_FCT_DO( pthread_rwlock_rdlock(&fd_g_peers_rw), /* continue */ );
    … …  
    462458        for (li = fd_g_peers.next; li != &fd_g_peers; li = li->next) {
    463459                CHECK_MALLOC_DO( fd_peer_dump(FD_DUMP_STD_PARAMS, (struct peer_hdr *)li->o, details), break);
    464                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), break);
     460                if (li->next != &fd_g_peers) {
     461                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), break);
     462                }
    465463        }
    466464       

  • libfdcore/server.c

    r1085 r1093  
    9797{
    9898        struct fd_list * li, *cli;
    99         size_t o=0;
    100         if (!offset)
    101                 offset = &o;
     99       
     100        FD_DUMP_HANDLE_OFFSET();
    102101       
    103102        for (li = FD_SERVERS.next; li != &FD_SERVERS; li = li->next) {
    … …  
    105104                enum s_state st = get_status(s);
    106105               
    107                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{server}(@%p)'%s': %s, %s, %s\n", s, fd_cnx_getid(s->conn),
     106                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{server}(@%p)'%s': %s, %s, %s", s, fd_cnx_getid(s->conn),
    108107                                IPPROTO_NAME( s->proto ),
    109108                                s->secur ? "Secur" : "NotSecur",
    … …  
    117116                        struct client * c = (struct client *)cli;
    118117                        char bufts[128];
    119                         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  {client}(@%p)'%s': to:%s\n", c, fd_cnx_getid(c->conn), fd_log_time(&c->ts, bufts, sizeof(bufts))), break);
     118                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n  {client}(@%p)'%s': to:%s", c, fd_cnx_getid(c->conn), fd_log_time(&c->ts, bufts, sizeof(bufts))), break);
    120119                }
    121120                CHECK_POSIX_DO( pthread_mutex_unlock(&s->clients_mtx), );
     121               
     122                if (li->next != &FD_SERVERS) {
     123                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
     124                }
    122125        }
    123126       

  • libfdproto/dictionary.c

    r1085 r1093  
    719719}
    720720
     721/* For searchs of type "xxx_OF_xxx": if the search object is sentinel list for the "what" object */
     722#define SEARCH_sentinel( type_of_what, what_list_nr, sentinel_list_nr ) {                       \
     723        struct dict_object *__what = (struct dict_object *) what;                               \
     724        CHECK_PARAMS_DO( verify_object(__what) &&                                               \
     725                (__what->type == (type_of_what)),                                               \
     726                   {  ret = EINVAL; goto end;  }  );                                            \
     727        ret = 0;                                                                                \
     728        if (result) {                                                                           \
     729                /* this is similar to the "container_of" */                                     \
     730                *result = (struct dict_object *)((char *)(__what->list[what_list_nr].head) -    \
     731                                (size_t)&(((struct dict_object *)0)->list[sentinel_list_nr]));  \
     732        }                                                                                       \
     733}
     734
     735
    721736static int search_vendor ( struct dictionary * dict, int criteria, const void * what, struct dict_object **result )
    722737{
    … …  
    740755                        /* "what" should be an application object */
    741756                        SEARCH_childs_parent( DICT_APPLICATION, &dict->dict_vendors );
     757                        break;
     758               
     759                case VENDOR_OF_AVP:
     760                        /* "what" should be an avp object */
     761                        SEARCH_sentinel( DICT_AVP, 0, 1 );
    742762                        break;
    743763               
    … …  
    12481268        struct fd_list * li = sentinel;
    12491269        /* We don't lock here, the caller must have taken the dictionary lock for reading already */
    1250         while (li->next != sentinel)
    1251         {
    1252                 li = li->next;
    1253                 CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, _O(li->o), parents, depth, indent ), return NULL);
     1270        if (FD_IS_LIST_EMPTY(sentinel)) {
     1271                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n%*s{empty list}", indent, ""), return NULL);
     1272        } else {
     1273                while (li->next != sentinel)
     1274                {
     1275                        li = li->next;
     1276                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
     1277                        CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, _O(li->o), parents, depth, indent ), return NULL);
     1278                }
    12541279        }
    12551280}
    … …  
    12601285       
    12611286        if (!verify_object(obj)) {
    1262                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL\n"), return NULL);
     1287                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL"), return NULL);
    12631288                return *buf;
    12641289        }
    … …  
    12741299        }
    12751300       
    1276         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
    1277        
    12781301        if (parents) {
    1279                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*sparent:", indent + 1, ""), return NULL);
     1302                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n%*sparent:", indent + 1, ""), return NULL);
    12801303                CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, obj->parent, parents-1, 0, 0 ), return NULL);
    12811304        }
    … …  
    12851308                for (i=0; i<NB_LISTS_PER_OBJ; i++) {
    12861309                        if ((obj->list[i].o == NULL) && (obj->list[i].next != &obj->list[i])) {
    1287                                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*slist[%d]:\n", indent + 1, "", i), return NULL);
    12881310                                CHECK_MALLOC_DO( dump_list(FD_DUMP_STD_PARAMS, &obj->list[i], 0, depth - 1, indent + 2), return NULL);
     1311                                break; /* we get duplicate information sorted by another criteria otherwise, which is not very useful */
    12891312                        }
    12901313                }
    … …  
    12961319DECLARE_FD_DUMP_PROTOTYPE(fd_dict_dump_object, struct dict_object * obj)
    12971320{
    1298         size_t o = 0;
    1299 
    1300         if (!offset)
    1301                 offset = &o;
     1321        FD_DUMP_HANDLE_OFFSET();
    13021322       
    13031323        CHECK_MALLOC_DO( dump_object(FD_DUMP_STD_PARAMS, obj, 1, 2, 0), return NULL);
    … …  
    13101330        int i;
    13111331        struct fd_list * li;
    1312         size_t o = 0;
    1313 
    1314         if (!offset)
    1315                 offset = &o;
     1332       
     1333        FD_DUMP_HANDLE_OFFSET();
    13161334               
    13171335        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{dictionary}(@%p): ", dict), return NULL);
    13181336       
    13191337        if ((dict == NULL) || (dict->dict_eyec != DICT_EYECATCHER)) {
    1320                 return fd_dump_extend(FD_DUMP_STD_PARAMS, "INVALID/NULL\n");
     1338                return fd_dump_extend(FD_DUMP_STD_PARAMS, "INVALID/NULL");
    13211339        }
    13221340       
    13231341        CHECK_POSIX_DO(  pthread_rwlock_rdlock( &dict->dict_lock ), /* ignore */  );
    13241342       
    1325         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict:%p > vendors, AVPs and related rules}\n", dict), goto error);
     1343        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict(%p) : VENDORS / AVP / RULES}\n", dict), goto error);
    13261344        CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, &dict->dict_vendors, 0, 3, 3 ), goto error);
    1327         for (li = dict->dict_vendors.list[0].next; li != &dict->dict_vendors.list[0]; li = li->next)
     1345        for (li = dict->dict_vendors.list[0].next; li != &dict->dict_vendors.list[0]; li = li->next) {
     1346                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
    13281347                CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, li->o, 0, 3, 3 ), goto error);
    1329        
    1330         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " {dict:%p > applications}\n", dict), goto error);
     1348        }
     1349       
     1350        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict(%p) : APPLICATIONS}\n", dict), goto error);
    13311351        CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, &dict->dict_applications, 0, 1, 3 ), goto error);
    1332         for (li = dict->dict_applications.list[0].next; li != &dict->dict_applications.list[0]; li = li->next)
     1352        for (li = dict->dict_applications.list[0].next; li != &dict->dict_applications.list[0]; li = li->next) {
     1353                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
    13331354                CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, li->o, 0, 1, 3 ), goto error);
    1334        
    1335         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " {dict:%p > types}\n", dict), goto error);
     1355        }
     1356       
     1357        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict(%p) : TYPES / ENUMVAL}", dict), goto error);
    13361358        CHECK_MALLOC_DO( dump_list(FD_DUMP_STD_PARAMS, &dict->dict_types, 0, 2, 3 ), goto error);
    13371359       
    1338         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " {dict:%p > commands}\n", dict), goto error);
     1360        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict(%p) : COMMANDS / RULES}", dict), goto error);
    13391361        CHECK_MALLOC_DO( dump_list(FD_DUMP_STD_PARAMS, &dict->dict_cmd_code, 0, 0, 3 ), goto error);
    13401362       
    1341         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " {dict:%p > statistics}\n", dict), goto error);
     1363        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict(%p) : statistics}", dict), goto error);
    13421364        for (i=1; i<=DICT_TYPE_MAX; i++)
    1343                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "   %5d: %s\n",  dict->dict_count[i], dict_obj_info[i].name), goto error);
     1365                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n   %5d: %s",  dict->dict_count[i], dict_obj_info[i].name), goto error);
    13441366       
    13451367        CHECK_POSIX_DO(  pthread_rwlock_unlock( &dict->dict_lock ), /* ignore */  );
    … …  
    14851507        char * type_name = NULL;
    14861508        char * const_name = NULL;
    1487         size_t o = 0;
    1488        
    1489         if (!offset)
    1490                 offset = &o;
     1509       
     1510        FD_DUMP_HANDLE_OFFSET();
    14911511       
    14921512        /* Check the parameters are correct */

  • libfdproto/dictionary_functions.c

    r1085 r1093  
    162162        } s;
    163163        uint16_t fam;
    164         size_t o = 0;
    165        
    166         if (!offset)
    167                 offset = &o;
     164       
     165        FD_DUMP_HANDLE_OFFSET();
    168166       
    169167        memset(&s, 0, sizeof(s));
    … …  
    213211DECLARE_FD_DUMP_PROTOTYPE(fd_dictfct_UTF8String_dump, union avp_value * avp_value)
    214212{
    215         size_t o = 0, l;
    216         if (!offset)
    217                 offset = &o;
     213        size_t l;
     214        FD_DUMP_HANDLE_OFFSET();
    218215       
    219216        l = avp_value->os.len;
    … …  
    305302DECLARE_FD_DUMP_PROTOTYPE(fd_dictfct_Time_dump, union avp_value * avp_value)
    306303{
    307         size_t o = 0;
    308304        time_t val;
    309305        struct tm conv;
    310306               
    311         if (!offset)
    312                 offset = &o;
     307        FD_DUMP_HANDLE_OFFSET();
    313308       
    314309        if (avp_value->os.len != 4) {

  • libfdproto/fifo.c

    r1085 r1093  
    121121DECLARE_FD_DUMP_PROTOTYPE(fd_fifo_dump, char * name, struct fifo * queue, fd_fifo_dump_item_cb dump_item)
    122122{
    123         size_t o = 0;
    124         if (!offset)
    125                 offset = &o;
     123        FD_DUMP_HANDLE_OFFSET();
    126124       
    127125        if (name) {
    … …  
    132130       
    133131        if (!CHECK_FIFO( queue )) {
    134                 return fd_dump_extend(FD_DUMP_STD_PARAMS, "INVALID/NULL\n");
     132                return fd_dump_extend(FD_DUMP_STD_PARAMS, "INVALID/NULL");
    135133        }
    136134       
    137135        CHECK_POSIX_DO(  pthread_mutex_lock( &queue->mtx ), /* continue */  );
    138         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "items:%d,%d,%d threads:%d,%d stats:%lld/%ld.%06ld,%ld.%06ld,%ld.%06ld thresholds:%d,%d,%d,%p,%p,%p\n",
     136        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "items:%d,%d,%d threads:%d,%d stats:%lld/%ld.%06ld,%ld.%06ld,%ld.%06ld thresholds:%d,%d,%d,%p,%p,%p",
    139137                                                queue->count, queue->highest_ever, queue->max,
    140138                                                queue->thrs, queue->thrs_push,
    … …  
    148146                for (li = queue->list.next; li != &queue->list; li = li->next) {
    149147                        struct fifo_item * fi = (struct fifo_item *)li;
    150                         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " [#%i](@%p)@%ld.%06ld: ",
     148                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n [#%i](@%p)@%ld.%06ld: ",
    151149                                                i++, fi->item.o, (long)fi->posted_on.tv_sec,(long)(fi->posted_on.tv_nsec/1000)),
    152150                                         goto error);
    … …  
    155153        }
    156154        CHECK_POSIX_DO(  pthread_mutex_unlock( &queue->mtx ), /* continue */  );
     155       
    157156        return *buf;
    158157error:

  • libfdproto/messages.c

    r1092 r1093  
    721721/* Debug functions: dumping */
    722722
     723/* messages and AVP formatters */
     724typedef DECLARE_FD_DUMP_PROTOTYPE( (*msg_dump_formatter_msg), struct msg * msg );
     725typedef DECLARE_FD_DUMP_PROTOTYPE( (*msg_dump_formatter_avp), struct avp * avp, int level );
     726
     727/* Core function to process the dumping */
     728static DECLARE_FD_DUMP_PROTOTYPE( msg_dump_process, msg_dump_formatter_msg msg_format, msg_dump_formatter_avp avp_format, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
     729{
     730        FD_DUMP_HANDLE_OFFSET();
     731               
     732        if (force_parsing) {
     733                (void) fd_msg_parse_dict(obj, dict, NULL);
     734        }
     735       
     736        switch (_C(obj)->type) {
     737                case MSG_AVP:
     738                        CHECK_MALLOC_DO( (*avp_format)(FD_DUMP_STD_PARAMS, (struct avp *)obj, 0), return NULL);
     739                        break;
     740
     741                case MSG_MSG:
     742                        CHECK_MALLOC_DO( (*msg_format)(FD_DUMP_STD_PARAMS, (struct msg *)obj), return NULL);
     743                        break;
     744
     745                default:
     746                        ASSERT(0);
     747        }
     748               
     749        if (recurse) {
     750                struct avp * avp = NULL;
     751                CHECK_FCT_DO(  fd_msg_browse ( obj, MSG_BRW_FIRST_CHILD, &avp, NULL ), avp = NULL );
     752                while (avp) {
     753                        CHECK_MALLOC_DO( (*avp_format)(FD_DUMP_STD_PARAMS, avp, 1), return NULL);
     754                        CHECK_FCT_DO(  fd_msg_browse ( avp, MSG_BRW_NEXT, &avp, NULL ), avp = NULL  );
     755                };
     756        }
     757       
     758        /* we remove the final \n if any */
     759        FD_DUMP_HANDLE_TRAIL();
     760       
     761        return *buf;
     762}
     763
     764/*
     765 * Tree View message dump
     766 */
     767
     768static DECLARE_FD_DUMP_PROTOTYPE( msg_format_treeview, struct msg * msg )
     769{
     770        if (!CHECK_MSG(msg)) {
     771                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{message}(@%p): INVALID\n", msg), return NULL);
     772                return *buf;
     773        }
     774       
     775        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{message}(@%p): ", msg), return NULL);
     776        if (!msg->msg_model) {
     777                if (msg->msg_model_not_found.mnf_code) {
     778                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(not found in dictionary)\n"), return NULL);
     779                } else {
     780                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(not searched in dictionary)\n"), return NULL);
     781                }
     782        } else {
     783                enum dict_object_type dicttype;
     784                struct dict_cmd_data  dictdata;
     785                if (fd_dict_gettype(msg->msg_model, &dicttype) || (dicttype != DICT_COMMAND)) {
     786                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(invalid model information)\n"), return NULL);
     787                } else if (fd_dict_getval(msg->msg_model, &dictdata)) {
     788                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(error getting model information)\n"), return NULL);
     789                } else {
     790                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "'%s'\n", dictdata.cmd_name), return NULL);
     791                }
     792        }
     793               
     794        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  Version: 0x%02hhX\n", msg->msg_public.msg_version), return NULL);
     795        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  Length: %d\n", msg->msg_public.msg_length), return NULL);
     796        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  Flags: 0x%02hhX (" DUMP_CMDFL_str ")\n", msg->msg_public.msg_flags, DUMP_CMDFL_val(msg->msg_public.msg_flags)), return NULL);
     797        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  Command Code: %u\n", msg->msg_public.msg_code), return NULL);
     798        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  ApplicationId: %d\n", msg->msg_public.msg_appl), return NULL);
     799        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  Hop-by-Hop Identifier: 0x%8X\n", msg->msg_public.msg_hbhid), return NULL);
     800        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  End-to-End Identifier: 0x%8X\n", msg->msg_public.msg_eteid), return NULL);
     801        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "   {debug data}: src:%s(%zd) rwb:%p rt:%d cb:%p,%p(%p) qry:%p asso:%d sess:%p\n", msg->msg_src_id?:"(nil)", msg->msg_src_id_len, msg->msg_rawbuffer, msg->msg_routable, msg->msg_cb.anscb, msg->msg_cb.expirecb, msg->msg_cb.data, msg->msg_query, msg->msg_associated, msg->msg_sess), return NULL);
     802       
     803        return *buf;
     804}
     805
     806static DECLARE_FD_DUMP_PROTOTYPE( avp_format_treeview, struct avp * avp, int level )
     807{
     808        char * name;
     809        struct dict_avp_data  dictdata;
     810        struct dict_avp_data *dictinfo = NULL;
     811        struct dict_vendor_data  vendordata;
     812        struct dict_vendor_data *vendorinfo = NULL;
     813        if (!CHECK_AVP(avp)) {
     814                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{avp}(@%p): INVALID\n", avp), return NULL);
     815                return *buf;
     816        }
     817       
     818        if (!level) {
     819                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{avp}(@%p): ", avp), return NULL);
     820        } else {
     821                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*sAVP: ", level * 3, ""), return NULL);
     822        }
     823       
     824        if (!avp->avp_model) {
     825                if (avp->avp_model_not_found.mnf_code) {
     826                        name = "(not found in dictionary)";
     827                } else {
     828                        name = "(not searched in dictionary)";
     829                }
     830        } else {
     831                enum dict_object_type dicttype;
     832                if (fd_dict_gettype(avp->avp_model, &dicttype) || (dicttype != DICT_AVP)) {
     833                        name = "(invalid model information)";
     834                } else if (fd_dict_getval(avp->avp_model, &dictdata)) {
     835                        name = "(error getting model information)";
     836                } else {
     837                        name = dictdata.avp_name;
     838                        dictinfo = &dictdata;
     839                        if (avp->avp_public.avp_flags & AVP_FLAG_VENDOR) {
     840                                struct dictionary * dict;
     841                                struct dict_object * vendor;
     842                                if ((!fd_dict_getdict(avp->avp_model, &dict))
     843                                && (!fd_dict_search(dict, DICT_VENDOR, VENDOR_OF_AVP, avp->avp_model, &vendor, ENOENT))
     844                                && (!fd_dict_getval(vendor, &vendordata))) {
     845                                        vendorinfo = &vendordata;
     846                                }
     847                        }
     848                }
     849        }
     850       
     851        if (dictinfo) {
     852                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "'%s'(%u)", name, avp->avp_public.avp_code), return NULL);
     853        } else {
     854                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%u%s", avp->avp_public.avp_code, name), return NULL);
     855        }
     856       
     857        if (avp->avp_public.avp_flags & AVP_FLAG_VENDOR) {
     858                if (vendorinfo) {
     859                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " vend='%s'(%u)", vendorinfo->vendor_name, avp->avp_public.avp_vendor), return NULL);
     860                } else {
     861                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " vend=%u", avp->avp_public.avp_vendor), return NULL);
     862                }
     863        }
     864
     865        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " l=%d f=" DUMP_AVPFL_str " val=", avp->avp_public.avp_len, DUMP_AVPFL_val(avp->avp_public.avp_flags)), return NULL);
     866       
     867        if (dictinfo && (dictinfo->avp_basetype == AVP_TYPE_GROUPED)) {
     868                struct avp * inavp = NULL;
     869                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(grouped)\n"), return NULL);
     870                CHECK_FCT_DO(  fd_msg_browse ( avp, MSG_BRW_FIRST_CHILD, &inavp, NULL ), inavp = NULL );
     871                while (inavp) {
     872                        CHECK_MALLOC_DO( avp_format_treeview(FD_DUMP_STD_PARAMS, inavp, level + 1), return NULL);
     873                        CHECK_FCT_DO(  fd_msg_browse ( inavp, MSG_BRW_NEXT, &inavp, NULL ), inavp = NULL  );
     874                };
     875        } else {
     876                if (avp->avp_public.avp_value) {
     877                        CHECK_MALLOC_DO( fd_dict_dump_avp_value(FD_DUMP_STD_PARAMS, avp->avp_public.avp_value, avp->avp_model, 0, 0), return NULL);
     878                } else if (avp->avp_rawdata) {
     879                        CHECK_MALLOC_DO( fd_dump_extend_hexdump(FD_DUMP_STD_PARAMS, avp->avp_rawdata, avp->avp_rawlen, 0, 0), return NULL);
     880                } else {
     881                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(not set)"), return NULL);
     882                }
     883                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
     884        }
     885
     886        return *buf;
     887}
     888
     889/* multi-line human-readable dump similar to wireshark output */
     890DECLARE_FD_DUMP_PROTOTYPE( fd_msg_dump_treeview, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
     891{
     892        return msg_dump_process(FD_DUMP_STD_PARAMS, msg_format_treeview, avp_format_treeview, obj, dict, force_parsing, recurse);
     893}
     894
     895
    723896#warning "todo"
    724 DECLARE_FD_DUMP_PROTOTYPE( fd_msg_dump_summary, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
    725 {
    726         return NULL;
    727 }
    728897/* one-line dump with all the contents of the message */
    729898DECLARE_FD_DUMP_PROTOTYPE( fd_msg_dump_full, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
    … …  
    731900        return NULL;
    732901}
    733 /* multi-line human-readable dump similar to wireshark output */
    734 DECLARE_FD_DUMP_PROTOTYPE( fd_msg_dump_treeview, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
     902
     903/* This one only prints a short display, does not go into the complete tree */
     904DECLARE_FD_DUMP_PROTOTYPE( fd_msg_dump_summary, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
    735905{
    736906        return NULL;

  • libfdproto/sessions.c

    r1088 r1093  
    877877DECLARE_FD_DUMP_PROTOTYPE(fd_sess_dump, struct session * session, int with_states)
    878878{
    879         size_t o = 0;
    880         if (!offset)
    881                 offset = &o;
     879        FD_DUMP_HANDLE_OFFSET();
    882880       
    883881        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{session}(@%p): ", session), return NULL);
    884882       
    885883        if (!VALIDATE_SI(session)) {
    886                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL\n"), return NULL);
     884                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL"), return NULL);
    887885        } else {
    888886                char timebuf[30];
    … …  
    890888
    891889                strftime(timebuf, sizeof(timebuf), "%D,%T", localtime_r( &session->timeout.tv_sec , &tm ));
    892                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "'%s'(%zd) h:%x m:%d d:%d to:%s.%06ld\n",
     890                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "'%s'(%zd) h:%x m:%d d:%d to:%s.%06ld",
    893891                                                        session->sid, session->sidlen, session->hash, session->msg_cnt, session->is_destroyed,
    894892                                                        timebuf, session->timeout.tv_nsec/1000),
    … …  
    902900                        for (li = session->states.next; li != &session->states; li = li->next) {
    903901                                struct state * st = (struct state *)(li->o);
    904                                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "  {state i:%d}(@%p): \n", st->hdl->id, st), return NULL);
     902                                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n  {state i:%d}(@%p): ", st->hdl->id, st), return NULL);
    905903                                if (st->hdl->state_dump) {
    906904                                        CHECK_MALLOC_DO( (*st->hdl->state_dump)( FD_DUMP_STD_PARAMS, st->state),
    907                                                         fd_dump_extend( FD_DUMP_STD_PARAMS, "[dumper error]\n"));
     905                                                        fd_dump_extend( FD_DUMP_STD_PARAMS, "[dumper error]"));
    908906                                } else {
    909                                         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "<%p>\n", st->state), return NULL);
     907                                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "<%p>", st->state), return NULL);
    910908                                }
    911909                        }
    … …  
    915913                }
    916914        }
     915       
    917916        return *buf;
    918917}
    … …  
    920919DECLARE_FD_DUMP_PROTOTYPE(fd_sess_dump_hdl, struct session_handler * handler)
    921920{
    922         size_t o = 0;
    923         if (!offset)
    924                 offset = &o;
     921        FD_DUMP_HANDLE_OFFSET();
    925922       
    926923        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{sesshdl}(@%p): ", handler), return NULL);
    927924       
    928925        if (!VALIDATE_SH(handler)) {
    929                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL\n"), return NULL);
     926                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL"), return NULL);
    930927        } else {
    931                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "i:%d cl:%p d:%p o:%p\n", handler->id, handler->cleanup, handler->state_dump, handler->opaque), return NULL);
     928                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "i:%d cl:%p d:%p o:%p", handler->id, handler->cleanup, handler->state_dump, handler->opaque), return NULL);
    932929        }
    933930        return *buf;

  • libfdproto/utils.c

    r1085 r1093  
    3939{
    4040        char addrbuf[INET6_ADDRSTRLEN];
    41         size_t o = 0;
    42         if (!offset)
    43                 offset = &o;
     41        FD_DUMP_HANDLE_OFFSET();
    4442       
    4543        if (sa) {
    … …  
    6159        char addrbuf[INET6_ADDRSTRLEN];
    6260        char servbuf[32];
    63         size_t o = 0;
    64         if (!offset)
    65                 offset = &o;
     61        FD_DUMP_HANDLE_OFFSET();
    6662       
    6763        if (sa) {

  • tests/testdict.c

    r1088 r1093  
    204204        }
    205205       
     206        LOG_D( "Dictionary at the end of %s: %s", __FILE__, fd_dict_dump(FD_DUMP_TEST_PARAMS, fd_g_config->cnf_dict) ?: "error");
     207       
    206208        /* That's all for the tests yet */
    207209        PASSTEST();

  • tests/testmesg_stress.c

    r1090 r1093  
    374374                CHECK( 0, fd_msg_bufferize( msg, &buf, NULL ) );
    375375               
     376                LOG_D( "Test message: %s", fd_msg_dump_treeview(FD_DUMP_TEST_PARAMS, msg, NULL, 0, 1));
     377               
    376378                /* Now free the message, we keep only the buffer. */
    377379                CHECK( 0, fd_msg_free( msg ) );
    … …  
    390392                struct timespec start, end;
    391393               
    392                 unsigned char * buf_cpy = NULL;
    393394                struct msg * msg;
    394395               
    395                 #define CPYBUF() {                      \
    396                         buf_cpy = malloc(344);          \
    397                         CHECK( buf_cpy ? 1 : 0, 1);     \
    398                         memcpy(buf_cpy, buf, 344);      \
    399                 }
    400396               
    401397                /* Create the copies of the message buffer */
    … …  
    404400               
    405401                for (i=0; i < test_parameter; i++) {
    406                         CPYBUF();
    407                         stress_array[i].b = buf_cpy;
    408                 }
     402                        stress_array[i].b = malloc(344);
     403                        if (!stress_array[i].b)
     404                                break;
     405                        memcpy(stress_array[i].b, buf, 344);
     406                }
     407                CHECK( test_parameter, i ); /* if false, a malloc failed */
    409408               
    410409        /* fd_msg_parse_buffer */
    … …  
    414413                /* Test the msg_parse_buffer function */
    415414                for (i=0; i < test_parameter; i++) {
    416                         CHECK( 0, fd_msg_parse_buffer( &stress_array[i].b, 344, &stress_array[i].m) );
    417                 }
     415                        if (0 != fd_msg_parse_buffer( &stress_array[i].b, 344, &stress_array[i].m) )
     416                                break;
     417                }
     418                CHECK( test_parameter, i ); /* if false, a call failed */
    418419               
    419420                CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
    … …  
    426427                /* Test the fd_msg_parse_dict function */
    427428                for (i=0; i < test_parameter; i++) {
    428                         CHECK( 0, fd_msg_parse_dict( stress_array[i].m, fd_g_config->cnf_dict, NULL ) );
    429                 }
     429                        if (0 != fd_msg_parse_dict( stress_array[i].m, fd_g_config->cnf_dict, NULL ) )
     430                                break;
     431                }
     432                CHECK( test_parameter, i ); /* if false, a call failed */
    430433               
    431434                CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
    … …  
    439442                /* Test the fd_msg_parse_rules function */
    440443                for (i=0; i < test_parameter; i++) {
    441                         CHECK( 0, fd_msg_parse_rules( stress_array[i].m, fd_g_config->cnf_dict, NULL ) );
    442                 }
     444                        if (0 != fd_msg_parse_rules( stress_array[i].m, fd_g_config->cnf_dict, NULL ) )
     445                                break;
     446                }
     447                CHECK( test_parameter, i ); /* if false, a call failed */
    443448               
    444449                CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
    … …  
    452457                /* Test the fd_msg_new_answer_from_req function */
    453458                for (i=0; i < test_parameter; i++) {
    454                         CHECK( 0, fd_msg_new_answer_from_req( fd_g_config->cnf_dict, &stress_array[i].m, 0 ) );
    455                 }
     459                        if (0 != fd_msg_new_answer_from_req( fd_g_config->cnf_dict, &stress_array[i].m, 0 ) )
     460                                break;
     461                }
     462                CHECK( test_parameter, i ); /* if false, a call failed */
    456463               
    457464                CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
    … …  
    461468                for (i=0; i < test_parameter; i++) {
    462469                        struct msg * ans = stress_array[i].m;
    463                         CHECK( 0, fd_msg_answ_getq( ans, &stress_array[i].m ) );
    464                         CHECK( 0, fd_msg_answ_detach( ans ) );
     470                        if (0 != fd_msg_answ_getq( ans, &stress_array[i].m ) )
     471                                break;
     472                        if (0 != fd_msg_answ_detach( ans ) )
     473                                break;
    465474                        fd_msg_free( ans );
    466475                }
     476                CHECK( test_parameter, i ); /* if false, a call failed */
    467477               
    468478               
    … …  
    473483                /* Test the fd_msg_new_answer_from_req function */
    474484                for (i=0; i < test_parameter; i++) {
    475                         CHECK( 0, fd_msg_new_answer_from_req( fd_g_config->cnf_dict, &stress_array[i].m, MSGFL_ANSW_ERROR ) );
    476                 }
     485                        if ( 0 != fd_msg_new_answer_from_req( fd_g_config->cnf_dict, &stress_array[i].m, MSGFL_ANSW_ERROR ) )
     486                                break;
     487                }
     488                CHECK( test_parameter, i ); /* if false, a call failed */
    477489               
    478490                CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
    … …  
    482494                for (i=0; i < test_parameter; i++) {
    483495                        struct msg * ans = stress_array[i].m;
    484                         CHECK( 0, fd_msg_answ_getq( ans, &stress_array[i].m ) );
    485                         CHECK( 0, fd_msg_answ_detach( ans ) );
     496                        if (0 != fd_msg_answ_getq( ans, &stress_array[i].m ) )
     497                                break;
     498                        if (0 != fd_msg_answ_detach( ans ) )
     499                                break;
    486500                        fd_msg_free( ans );
    487501                }
    … …  
    496510                for (i=0; i < test_parameter; i++) {
    497511                        size_t len = 0;
    498                         CHECK( 0, fd_msg_bufferize( stress_array[i].m, &stress_array[i].b, &len ) );
    499                 }
     512                        if (0 != fd_msg_bufferize( stress_array[i].m, &stress_array[i].b, &len ) )
     513                                break;
     514                }
     515                CHECK( test_parameter, i ); /* if false, a call failed */
    500516               
    501517                CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
Note: See TracChangeset for help on using the changeset viewer.