Navigation

Changeset 1085:7d7266115a34 in freeDiameter for libfdproto


Ignore:
Timestamp:
May 3, 2013, 8:20:56 PM (11 years ago)
Author:
Sebastien Decugis <sdecugis@freediameter.net>
Branch:
default
Phase:
public
Message:

Cleaning of the traces in progress

Location:
libfdproto
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • libfdproto/dictionary.c

    r1052 r1085  
    148148
    149149/* Forward declarations of dump functions */
    150 static void dump_vendor_data      ( void * data );
    151 static void dump_application_data ( void * data );
    152 static void dump_type_data        ( void * data );
     150static DECLARE_FD_DUMP_PROTOTYPE(dump_vendor_data, void * data );
     151static DECLARE_FD_DUMP_PROTOTYPE(dump_application_data, void * data );
     152static DECLARE_FD_DUMP_PROTOTYPE(dump_type_data, void * data );
    153153  /* the dump function for enum has a different prototype since it need the datatype */
    154 static void dump_avp_data         ( void * data );
    155 static void dump_command_data     ( void * data );
    156 static void dump_rule_data        ( void * data );
     154static DECLARE_FD_DUMP_PROTOTYPE(dump_avp_data, void * data );
     155static DECLARE_FD_DUMP_PROTOTYPE(dump_command_data, void * data );
     156static DECLARE_FD_DUMP_PROTOTYPE(dump_rule_data, void * data );
    157157
    158158/* Forward declarations of search functions */
    … …  
    173173        enum dict_object_type   parenttype;     /* The type of the parent, when relevant */
    174174        int                     eyecatcher;     /* A kind of signature for this object */
    175         void                  (*dump_data)(void * data );       /* The function to dump the data section */
     175        DECLARE_FD_DUMP_PROTOTYPE( (*dump_data), void * data ); /* The function to dump the data section */
    176176        int                   (*search_fct)(struct dictionary * dict, int criteria, const void * what, struct dict_object **result );;  /* The function to search an object of this type */
    177177        int                     haslist[NB_LISTS_PER_OBJ];      /* Tell if this list is used */
    … …  
    11501150/*******************************************************************************************************/
    11511151/* The following functions are used to debug the module, and allow to print out the content of the dictionary */
    1152 static void dump_vendor_data ( void * data )
     1152static DECLARE_FD_DUMP_PROTOTYPE(dump_vendor_data, void * data )
    11531153{
    11541154        struct dict_vendor_data * vendor = (struct dict_vendor_data *)data;
    11551155       
    1156         fd_log_debug("data: %-6u \"%s\"", vendor->vendor_id, vendor->vendor_name);
    1157 }
    1158 static void dump_application_data ( void * data )
     1156        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: %-6u \"%s\"", vendor->vendor_id, vendor->vendor_name);
     1157}
     1158static DECLARE_FD_DUMP_PROTOTYPE(dump_application_data, void * data )
    11591159{
    11601160        struct dict_application_data * appli = (struct dict_application_data *) data;
    1161         fd_log_debug("data: %-6u \"%s\"", appli->application_id, appli->application_name);
    1162 }
    1163 static void dump_type_data ( void * data )
     1161        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: %-6u \"%s\"", appli->application_id, appli->application_name);
     1162}
     1163static DECLARE_FD_DUMP_PROTOTYPE(dump_type_data, void * data )
    11641164{
    11651165        struct dict_type_data * type = ( struct dict_type_data * ) data;
    11661166       
    1167         fd_log_debug("data: %-12s \"%s\"",
     1167        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: %-12s \"%s\"",
    11681168                        type_base_name[type->type_base],
    11691169                        type->type_name);
    11701170}
    1171 static void dump_enumval_data ( struct dict_enumval_data * enumval, enum dict_avp_basetype type )
     1171static DECLARE_FD_DUMP_PROTOTYPE(dump_enumval_data, struct dict_enumval_data * enumval, enum dict_avp_basetype type )
    11721172{
    11731173        const int LEN_MAX = 20;
    1174         fd_log_debug("data: (%-12s) \"%s\" -> ", type_base_name[type], enumval->enum_name);
     1174        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "data: (%-12s) \"%s\" -> ", type_base_name[type], enumval->enum_name), return NULL);
    11751175        switch (type) {
    11761176                case AVP_TYPE_OCTETSTRING:
    … …  
    11801180                                        n = enumval->enum_value.os.len;
    11811181                                for (i=0; i < n; i++)
    1182                                         fd_log_debug("0x%2hhX/'%c' ", enumval->enum_value.os.data[i], ASCII(enumval->enum_value.os.data[i]));
     1182                                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "0x%2hhX/'%c' ", enumval->enum_value.os.data[i], ASCII(enumval->enum_value.os.data[i])), return NULL);
    11831183                                if (n == LEN_MAX)
    1184                                         fd_log_debug("...");
     1184                                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "..."), return NULL);
    11851185                        }
    11861186                        break;
    11871187               
    11881188                case AVP_TYPE_INTEGER32:
    1189                         fd_log_debug("%i", enumval->enum_value.i32);
     1189                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%i", enumval->enum_value.i32), return NULL);
    11901190                        break;
    11911191
    11921192                case AVP_TYPE_INTEGER64:
    1193                         fd_log_debug("%"PRId64, enumval->enum_value.i64);
     1193                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%"PRId64, enumval->enum_value.i64), return NULL);
    11941194                        break;
    11951195
    11961196                case AVP_TYPE_UNSIGNED32:
    1197                         fd_log_debug("%u", enumval->enum_value.u32);
     1197                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%u", enumval->enum_value.u32), return NULL);
    11981198                        break;
    11991199
    12001200                case AVP_TYPE_UNSIGNED64:
    1201                         fd_log_debug("%"PRIu64, enumval->enum_value.u64);
     1201                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%"PRIu64, enumval->enum_value.u64), return NULL);
    12021202                        break;
    12031203
    12041204                case AVP_TYPE_FLOAT32:
    1205                         fd_log_debug("%f", enumval->enum_value.f32);
     1205                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%f", enumval->enum_value.f32), return NULL);
    12061206                        break;
    12071207
    12081208                case AVP_TYPE_FLOAT64:
    1209                         fd_log_debug("%g", enumval->enum_value.f64);
     1209                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%g", enumval->enum_value.f64), return NULL);
    12101210                        break;
    12111211               
    12121212                default:
    1213                         fd_log_debug("??? (ERROR unknown type %d)", type);
    1214         }
    1215 }
    1216 static void dump_avp_data ( void * data )
     1213                        CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "??? (ERROR unknown type %d)", type), return NULL);
     1214        }
     1215        return *buf;
     1216}
     1217static DECLARE_FD_DUMP_PROTOTYPE(dump_avp_data, void * data )
    12171218{
    12181219        struct dict_avp_data * avp = (struct dict_avp_data * ) data;
    1219         fd_log_debug("data: v/m:" DUMP_AVPFL_str "/" DUMP_AVPFL_str ", %12s, %-6u \"%s\"",
     1220        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: v/m:" DUMP_AVPFL_str "/" DUMP_AVPFL_str ", %12s, %-6u \"%s\"",
    12201221                        DUMP_AVPFL_val(avp->avp_flag_val),
    12211222                        DUMP_AVPFL_val(avp->avp_flag_mask),
    … …  
    12241225                        avp->avp_name );
    12251226}
    1226 static void dump_command_data ( void * data )
     1227static DECLARE_FD_DUMP_PROTOTYPE(dump_command_data, void * data )
    12271228{
    12281229        struct dict_cmd_data * cmd = (struct dict_cmd_data *) data;
    1229         fd_log_debug("data: v/m:" DUMP_CMDFL_str "/" DUMP_CMDFL_str ", %-6u \"%s\"",
     1230        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: v/m:" DUMP_CMDFL_str "/" DUMP_CMDFL_str ", %-6u \"%s\"",
    12301231                        DUMP_CMDFL_val(cmd->cmd_flag_val), DUMP_CMDFL_val(cmd->cmd_flag_mask), cmd->cmd_code, cmd->cmd_name);
    12311232}
    1232 static void dump_rule_data ( void * data )
     1233static DECLARE_FD_DUMP_PROTOTYPE(dump_rule_data, void * data )
    12331234{
    12341235        struct dict_rule_data * rule = (struct dict_rule_data * )data;
    1235         fd_log_debug("data: pos:%d ord:%d m/M:%2d/%2d avp:\"%s\"",
     1236        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: pos:%d ord:%d m/M:%2d/%2d avp:\"%s\"",
    12361237                        rule->rule_position,
    12371238                        rule->rule_order,
    … …  
    12411242}
    12421243
    1243 static void dump_object ( struct dict_object * obj, int parents, int depth, int indent );
    1244 
    1245 static void dump_list ( struct fd_list * sentinel, int parents, int depth, int indent )
     1244static DECLARE_FD_DUMP_PROTOTYPE(dump_object, struct dict_object * obj, int parents, int depth, int indent );
     1245
     1246static DECLARE_FD_DUMP_PROTOTYPE(dump_list, struct fd_list * sentinel, int parents, int depth, int indent )
    12461247{
    12471248        struct fd_list * li = sentinel;
    … …  
    12501251        {
    12511252                li = li->next;
    1252                 dump_object( _O(li->o), parents, depth, indent );
    1253         }
    1254 }
    1255 
    1256 static void dump_object ( struct dict_object * obj, int parents, int depth, int indent )
    1257 {
    1258         if (obj == NULL)
    1259                 return;
    1260        
    1261         if (parents)
    1262                 dump_object (obj->parent, parents-1, 0, indent + 1 );
    1263        
    1264         fd_log_debug("%*s@%p: %s%s (p:%-9p) ",
    1265                         indent,
    1266                         "",
    1267                         obj,
    1268                         verify_object(obj) ? "" : "INVALID ",
    1269                         _OBINFO(obj).name,
    1270                         obj->parent);
    1271        
    1272         if (obj->type == DICT_ENUMVAL)
    1273                 dump_enumval_data ( &obj->data.enumval, obj->parent->data.type.type_base );
    1274         else
    1275                 _OBINFO(obj).dump_data(&obj->data);
     1253                CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, _O(li->o), parents, depth, indent ), return NULL);
     1254        }
     1255}
     1256
     1257static DECLARE_FD_DUMP_PROTOTYPE(dump_object, struct dict_object * obj, int parents, int depth, int indent )
     1258{
     1259        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*s{dictobj}(@%p): ", indent, "", obj), return NULL);
     1260       
     1261        if (!verify_object(obj)) {
     1262                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL\n"), return NULL);
     1263                return *buf;
     1264        }
     1265       
     1266        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%s p:%p ",
     1267                                                                _OBINFO(obj).name,
     1268                                                                obj->parent), return NULL);
     1269       
     1270        if (obj->type == DICT_ENUMVAL) {
     1271                CHECK_MALLOC_DO( dump_enumval_data ( FD_DUMP_STD_PARAMS, &obj->data.enumval, obj->parent->data.type.type_base ), return NULL);
     1272        } else {
     1273                CHECK_MALLOC_DO( _OBINFO(obj).dump_data(FD_DUMP_STD_PARAMS, &obj->data), return NULL);
     1274        }
     1275       
     1276        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n"), return NULL);
     1277       
     1278        if (parents) {
     1279                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*sparent:", indent + 1, ""), return NULL);
     1280                CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, obj->parent, parents-1, 0, 0 ), return NULL);
     1281        }
    12761282       
    12771283        if (depth) {
    … …  
    12791285                for (i=0; i<NB_LISTS_PER_OBJ; i++) {
    12801286                        if ((obj->list[i].o == NULL) && (obj->list[i].next != &obj->list[i])) {
    1281                                 fd_log_debug("%*s>%p: list[%d]:", indent, "", obj, i);
    1282                                 dump_list(&obj->list[i], parents, depth - 1, indent + 2);
     1287                                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*slist[%d]:\n", indent + 1, "", i), return NULL);
     1288                                CHECK_MALLOC_DO( dump_list(FD_DUMP_STD_PARAMS, &obj->list[i], 0, depth - 1, indent + 2), return NULL);
    12831289                        }
    12841290                }
    12851291        }
    1286 }
    1287 
    1288 void fd_dict_dump_object(struct dict_object * obj)
    1289 {
    1290         fd_log_debug("Dictionary object %p dump:", obj);
    1291         dump_object( obj, 1, 2, 2 );
    1292 }
    1293 
    1294 void fd_dict_dump(struct dictionary * dict)
     1292       
     1293        return *buf;
     1294}
     1295
     1296DECLARE_FD_DUMP_PROTOTYPE(fd_dict_dump_object, struct dict_object * obj)
     1297{
     1298        size_t o = 0;
     1299
     1300        if (!offset)
     1301                offset = &o;
     1302       
     1303        CHECK_MALLOC_DO( dump_object(FD_DUMP_STD_PARAMS, obj, 1, 2, 0), return NULL);
     1304       
     1305        return *buf;
     1306}
     1307
     1308DECLARE_FD_DUMP_PROTOTYPE(fd_dict_dump, struct dictionary * dict)
    12951309{
    12961310        int i;
    12971311        struct fd_list * li;
    1298        
    1299         CHECK_PARAMS_DO(dict && (dict->dict_eyec == DICT_EYECATCHER), return);
     1312        size_t o = 0;
     1313
     1314        if (!offset)
     1315                offset = &o;
     1316               
     1317        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{dictionary}(@%p): ", dict), return NULL);
     1318       
     1319        if ((dict == NULL) || (dict->dict_eyec != DICT_EYECATCHER)) {
     1320                return fd_dump_extend(FD_DUMP_STD_PARAMS, "INVALID/NULL\n");
     1321        }
    13001322       
    13011323        CHECK_POSIX_DO(  pthread_rwlock_rdlock( &dict->dict_lock ), /* ignore */  );
    13021324       
    1303         fd_log_debug("######################################################");
    1304         fd_log_debug("###### Dumping vendors, AVPs and related rules #######");
    1305        
    1306         dump_object( &dict->dict_vendors, 0, 3, 0 );
     1325        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict:%p > vendors, AVPs and related rules}\n", dict), goto error);
     1326        CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, &dict->dict_vendors, 0, 3, 3 ), goto error);
    13071327        for (li = dict->dict_vendors.list[0].next; li != &dict->dict_vendors.list[0]; li = li->next)
    1308                 dump_object( li->o, 0, 3, 0 );
    1309        
    1310         fd_log_debug("######          Dumping applications           #######");
    1311 
    1312         dump_object( &dict->dict_applications, 0, 1, 0 );
     1328                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);
     1331        CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, &dict->dict_applications, 0, 1, 3 ), goto error);
    13131332        for (li = dict->dict_applications.list[0].next; li != &dict->dict_applications.list[0]; li = li->next)
    1314                 dump_object( li->o, 0, 1, 0 );
    1315        
    1316         fd_log_debug("######             Dumping types               #######");
    1317 
    1318         dump_list( &dict->dict_types, 0, 2, 0 );
    1319        
    1320         fd_log_debug("######      Dumping commands per name          #######");
    1321 
    1322         dump_list( &dict->dict_cmd_name, 0, 2, 0 );
    1323        
    1324         fd_log_debug("######   Dumping commands per code and flags   #######");
    1325 
    1326         dump_list( &dict->dict_cmd_code, 0, 0, 0 );
    1327        
    1328         fd_log_debug("######             Statistics                  #######");
    1329 
     1333                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);
     1336        CHECK_MALLOC_DO( dump_list(FD_DUMP_STD_PARAMS, &dict->dict_types, 0, 2, 3 ), goto error);
     1337       
     1338        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " {dict:%p > commands}\n", dict), goto error);
     1339        CHECK_MALLOC_DO( dump_list(FD_DUMP_STD_PARAMS, &dict->dict_cmd_code, 0, 0, 3 ), goto error);
     1340       
     1341        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " {dict:%p > statistics}\n", dict), goto error);
    13301342        for (i=1; i<=DICT_TYPE_MAX; i++)
    1331                 fd_log_debug(" %5d objects of type %s", dict->dict_count[i], dict_obj_info[i].name);
    1332        
    1333         fd_log_debug("######################################################");
    1334        
     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);
     1344       
     1345        CHECK_POSIX_DO(  pthread_rwlock_unlock( &dict->dict_lock ), /* ignore */  );
     1346        return *buf;
     1347error: 
    13351348        /* Free the rwlock */
    13361349        CHECK_POSIX_DO(  pthread_rwlock_unlock( &dict->dict_lock ), /* ignore */  );
     1350        return NULL;
    13371351}
    13381352
    … …  
    13401354
    13411355/* Default dump functions */
    1342 static int dump_val_os(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
     1356static DECLARE_FD_DUMP_PROTOTYPE(dump_val_os, union avp_value * value)
    13431357{
    13441358        int i;
    1345         CHECK_FCT( dump_add_str(outstr, offset, outlen, "<") );
     1359       
     1360        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "<"), return NULL);
    13461361        for (i = 0; i < value->os.len; i++) {
    13471362                if (i == 1024) { /* Dump only up to 1024 bytes of the buffer */
    1348                         CHECK_FCT( dump_add_str(outstr, offset, outlen, "[...] (len=%zd)", value->os.len) );
     1363                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "[...] (len=%zd)", value->os.len), return NULL);
    13491364                        break;
    13501365                }
    1351                 CHECK_FCT( dump_add_str(outstr, offset, outlen, "%s%02.2X", (i==0 ? "" : " "), value->os.data[i]) );
    1352         }
    1353         CHECK_FCT( dump_add_str(outstr, offset, outlen, ">") );
    1354         return 0;
    1355 }
    1356 
    1357 static int dump_val_i32(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
    1358 {
    1359         CHECK_FCT( dump_add_str(outstr, offset, outlen, "%i (0x%x)", value->i32, value->i32) );
    1360         return 0;
    1361 }
    1362 
    1363 static int dump_val_i64(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
    1364 {
    1365         CHECK_FCT( dump_add_str(outstr, offset, outlen, "%lli (0x%llx)", value->i64, value->i64) );
    1366         return 0;
    1367 }
    1368 
    1369 static int dump_val_u32(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
    1370 {
    1371         CHECK_FCT( dump_add_str(outstr, offset, outlen, "%u (0x%x)", value->u32, value->u32) );
    1372         return 0;
    1373 }
    1374 
    1375 static int dump_val_u64(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
    1376 {
    1377         CHECK_FCT( dump_add_str(outstr, offset, outlen, "%llu (0x%llx)", value->u64, value->u64) );
    1378         return 0;
    1379 }
    1380 
    1381 static int dump_val_f32(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
    1382 {
    1383         CHECK_FCT( dump_add_str(outstr, offset, outlen, "%f", value->f32) );
    1384         return 0;
    1385 }
    1386 
    1387 static int dump_val_f64(union avp_value * value, char **outstr, size_t *offset, size_t *outlen)
    1388 {
    1389         CHECK_FCT( dump_add_str(outstr, offset, outlen, "%g", value->f64) );
    1390         return 0;
     1366                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%s%02hhX", (i==0 ? "" : " "), value->os.data[i]), return NULL);
     1367        }
     1368        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, ">"), return NULL);
     1369        return *buf;
     1370}
     1371
     1372static DECLARE_FD_DUMP_PROTOTYPE(dump_val_i32, union avp_value * value)
     1373{
     1374        return fd_dump_extend( FD_DUMP_STD_PARAMS, "%i (0x%x)", value->i32, value->i32);
     1375}
     1376
     1377static DECLARE_FD_DUMP_PROTOTYPE(dump_val_i64, union avp_value * value)
     1378{
     1379        return fd_dump_extend( FD_DUMP_STD_PARAMS, "%" PRId64 " (0x%" PRIx64 ")", value->i64, value->i64);
     1380}
     1381
     1382static DECLARE_FD_DUMP_PROTOTYPE(dump_val_u32, union avp_value * value)
     1383{
     1384        return fd_dump_extend( FD_DUMP_STD_PARAMS, "%u (0x%x)", value->u32, value->u32);
     1385}
     1386
     1387static DECLARE_FD_DUMP_PROTOTYPE(dump_val_u64, union avp_value * value)
     1388{
     1389        return fd_dump_extend( FD_DUMP_STD_PARAMS, "%" PRIu64 " (0x%" PRIx64 ")", value->u64, value->u64);
     1390}
     1391
     1392static DECLARE_FD_DUMP_PROTOTYPE(dump_val_f32, union avp_value * value)
     1393{
     1394        return fd_dump_extend( FD_DUMP_STD_PARAMS, "%f", value->f32);
     1395}
     1396
     1397static DECLARE_FD_DUMP_PROTOTYPE(dump_val_f64, union avp_value * value)
     1398{
     1399        return fd_dump_extend( FD_DUMP_STD_PARAMS, "%g", value->f64);
    13911400}
    13921401
    13931402/* Get the dump function for basic dict_avp_basetype */
    1394 static int (*get_default_dump_val_cb(enum dict_avp_basetype datatype))(union avp_value *, char **, size_t *, size_t *)
     1403static DECLARE_FD_DUMP_PROTOTYPE((*get_default_dump_val_cb(enum dict_avp_basetype datatype)), union avp_value *)
    13951404{
    13961405        switch (datatype) {
    … …  
    14261435#define INOBJHDRVAL     indent<0 ? 1 : indent, indent<0 ? "-" : "|"
    14271436
     1437typedef DECLARE_FD_DUMP_PROTOTYPE((*dump_val_cb_t), union avp_value *);
     1438
    14281439/* Formatter for the AVP value dump line */
    1429 static int dump_avp_val(union avp_value *avp_value,
    1430                         int (*def_dump_val_cb)(union avp_value *, char **, size_t *, size_t *),
    1431                         char * (*dump_val_cb)(union avp_value *),
     1440static DECLARE_FD_DUMP_PROTOTYPE(dump_avp_val, union avp_value *avp_value,
     1441                        dump_val_cb_t def_dump_val_cb,
     1442                        dump_val_cb_t dump_val_cb,
    14321443                        enum dict_avp_basetype datatype,
    14331444                        char * type_name,
    14341445                        char * const_name,
    14351446                        int indent,
    1436                         char **outstr,
    1437                         size_t *offset,
    1438                         size_t *outlen,
    14391447                        int header)
    14401448{
    14411449        if (header) {
    14421450                /* Header for all AVP values dumps: */
    1443                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "value ", INOBJHDRVAL) );
     1451                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, INOBJHDR "value ", INOBJHDRVAL), return NULL);
    14441452       
    14451453                /* If the type is provided, write it */
    14461454                if (type_name) {
    1447                         CHECK_FCT( dump_add_str(outstr, offset, outlen, "t: '%s' ", type_name) );
     1455                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "t: '%s' ", type_name), return NULL);
    14481456                }
    14491457       
    14501458                /* Always give the base datatype anyway */
    1451                 CHECK_FCT( dump_add_str(outstr, offset, outlen, "(%s) ", type_base_name[datatype]) );
     1459                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(%s) ", type_base_name[datatype]), return NULL);
    14521460
    14531461                /* Now, the value */
    1454                 CHECK_FCT( dump_add_str(outstr, offset, outlen, "v: ") );
     1462                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "v: "), return NULL);
    14551463        }
    14561464        if (const_name) {
    1457                 CHECK_FCT( dump_add_str(outstr, offset, outlen, "'%s' (", const_name) );
     1465                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "'%s' (", const_name), return NULL);
    14581466        }
    14591467        if (dump_val_cb) {
    1460                 char * str;
    1461                 CHECK_MALLOC_DO( str = (*dump_val_cb)(avp_value), dump_add_str(outstr, offset, outlen, "(dump failed)") );
    1462                 CHECK_FCT( dump_add_str(outstr, offset, outlen, "%s", str) );
    1463                 free(str);
     1468                CHECK_MALLOC_DO( (*dump_val_cb)( FD_DUMP_STD_PARAMS, avp_value), fd_dump_extend( FD_DUMP_STD_PARAMS, "(dump failed)"));
    14641469        } else {
    1465                 CHECK_FCT( (*def_dump_val_cb)(avp_value, outstr, offset, outlen) );
     1470                CHECK_MALLOC_DO( (*def_dump_val_cb)( FD_DUMP_STD_PARAMS, avp_value), return NULL);
    14661471        }
    14671472        if (const_name) {
    1468                 CHECK_FCT( dump_add_str(outstr, offset, outlen, ")") );
     1473                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, ")"), return NULL);
    14691474        }
    14701475       
    14711476        /* Done! */
    1472         return 0;
     1477        return *buf;
    14731478}
    14741479
    14751480/* Dump the value of an AVP of known type into the returned str */
    1476 int fd_dict_dump_avp_value(union avp_value *avp_value, struct dict_object * model, int indent, char **outstr, size_t *offset, size_t *outlen, int header)
    1477 {
    1478         char * (*dump_val_cb)(union avp_value *avp_value) = NULL;
     1481DECLARE_FD_DUMP_PROTOTYPE(fd_dict_dump_avp_value, union avp_value *avp_value, struct dict_object * model, int indent, int header)
     1482{
     1483        DECLARE_FD_DUMP_PROTOTYPE((*dump_val_cb), union avp_value *avp_value) = NULL;
    14791484        struct dict_object * type = NULL;
    14801485        char * type_name = NULL;
    14811486        char * const_name = NULL;
     1487        size_t o = 0;
     1488       
     1489        if (!offset)
     1490                offset = &o;
    14821491       
    14831492        /* Check the parameters are correct */
    1484         CHECK_PARAMS( avp_value && verify_object(model) && (model->type == DICT_AVP) );
     1493        CHECK_PARAMS_DO( avp_value && verify_object(model) && (model->type == DICT_AVP), return NULL );
    14851494       
    14861495        /* Get the type definition of this AVP */
    … …  
    15021511                /* bypass checks */
    15031512                if ((search_enumval( type->dico, ENUMVAL_BY_STRUCT, &request, &enumval ) == 0) && (enumval)) {
    1504                         /* We found a cosntant, get its name */
     1513                        /* We found a constant, get its name */
    15051514                        const_name = enumval->data.enumval.enum_name;
    15061515                }
    … …  
    15081517       
    15091518        /* And finally, dump the value */
    1510         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, header) );
    1511         return 0;
     1519        CHECK_MALLOC_DO( dump_avp_val(FD_DUMP_STD_PARAMS, 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, header), return NULL );
     1520        return *buf;
    15121521}
    15131522
    … …  
    15741583        switch (dict_obj_info[type].parent) {
    15751584                case 0: /* parent is forbidden */
    1576                         CHECK_PARAMS( parent == NULL );
     1585                        CHECK_PARAMS_DO( parent == NULL, goto error_param );
    15771586               
    15781587                case 1: /* parent is optional */
    … …  
    15811590               
    15821591                case 2: /* parent is mandatory */
    1583                         CHECK_PARAMS(  verify_object(parent)  );
     1592                        CHECK_PARAMS_DO(  verify_object(parent), goto error_param  );
    15841593                       
    15851594                        if (type == DICT_RULE ) { /* Special case : grouped AVP or Command parents are allowed */
    1586                                 CHECK_PARAMS( (parent->type == DICT_COMMAND )
    1587                                                 || ( (parent->type == DICT_AVP) && (parent->data.avp.avp_basetype == AVP_TYPE_GROUPED ) ) );
     1595                                CHECK_PARAMS_DO( (parent->type == DICT_COMMAND )
     1596                                                || ( (parent->type == DICT_AVP) && (parent->data.avp.avp_basetype == AVP_TYPE_GROUPED ) ), goto error_param );
    15881597                        } else {
    1589                                 CHECK_PARAMS( parent->type == dict_obj_info[type].parenttype );
     1598                                CHECK_PARAMS_DO( parent->type == dict_obj_info[type].parenttype, goto error_param );
    15901599                        }
    15911600        }
    … …  
    15941603        if (type == DICT_AVP) {
    15951604                CHECK_FCT_DO(  fd_dict_search( dict, DICT_VENDOR, VENDOR_BY_ID, &(((struct dict_avp_data *)data)->avp_vendor), (void*)&vendor, ENOENT ),
    1596                         { TRACE_DEBUG(INFO, "Unable to find vendor '%d' referenced in the AVP data", ((struct dict_avp_data *)data)->avp_vendor); return EINVAL; }  );
     1605                        { TRACE_DEBUG(INFO, "Unable to find vendor '%d' referenced in the AVP data", ((struct dict_avp_data *)data)->avp_vendor); goto error_param; }  );
    15971606               
    15981607                /* Also check if a parent is provided, that the type are the same */
    15991608                if (parent) {
    1600                         CHECK_PARAMS(  parent->data.type.type_base == ((struct dict_avp_data *)data)->avp_basetype  );
     1609                        CHECK_PARAMS_DO(  parent->data.type.type_base == ((struct dict_avp_data *)data)->avp_basetype, goto error_param  );
    16011610                }
    16021611        }
    … …  
    16041613        /* For RULE object, we must also check that the "avp" referenced exists */
    16051614        if (type == DICT_RULE) {
    1606                 CHECK_PARAMS(  verify_object(((struct dict_rule_data *)data)->rule_avp)  );
    1607                 CHECK_PARAMS(  ((struct dict_rule_data *)data)->rule_avp->type == DICT_AVP  );
     1615                CHECK_PARAMS_DO(  verify_object(((struct dict_rule_data *)data)->rule_avp), goto error_param  );
     1616                CHECK_PARAMS_DO(  ((struct dict_rule_data *)data)->rule_avp->type == DICT_AVP, goto error_param  );
    16081617        }
    16091618       
    16101619        /* For COMMAND object, check that the 'R' flag is fixed */
    16111620        if (type == DICT_COMMAND) {
    1612                 CHECK_PARAMS( ((struct dict_cmd_data *)data)->cmd_flag_mask & CMD_FLAG_REQUEST   );
     1621                CHECK_PARAMS_DO( ((struct dict_cmd_data *)data)->cmd_flag_mask & CMD_FLAG_REQUEST, goto error_param   );
    16131622        }
    16141623       
    16151624        /* We have to check that the new values are not equal to the sentinels */
    16161625        if (type == DICT_VENDOR) {
    1617                 CHECK_PARAMS( ((struct dict_vendor_data *)data)->vendor_id != 0   );
     1626                CHECK_PARAMS_DO( ((struct dict_vendor_data *)data)->vendor_id != 0, goto error_param   );
    16181627        }
    16191628        if (type == DICT_APPLICATION) {
    1620                 CHECK_PARAMS( ((struct dict_application_data *)data)->application_id != 0   );
     1629                CHECK_PARAMS_DO( ((struct dict_application_data *)data)->application_id != 0, goto error_param   );
    16211630        }
    16221631       
    … …  
    17181727        return 0;
    17191728       
     1729error_param:
     1730        ret = EINVAL;
     1731        goto all_errors;
     1732
    17201733error_unlock:
    17211734        CHECK_POSIX_DO(  pthread_rwlock_unlock(&dict->dict_lock),  /* continue */  );
    … …  
    17281741                                if (fd_os_cmp(locref->data.vendor.vendor_name, locref->datastr_len,
    17291742                                                new->data.vendor.vendor_name, new->datastr_len)) {
    1730                                         TRACE_DEBUG(FULL, "Conflicting vendor name");
     1743                                        TRACE_DEBUG(INFO, "Conflicting vendor name: %s", new->data.vendor.vendor_name);
    17311744                                        break;
    17321745                                }
    … …  
    18661879                                break;
    18671880                }
    1868                 if (ret) {
    1869                         TRACE_DEBUG(INFO, "An existing object with different non-key data was found: EEXIST");
    1870                         if (TRACE_BOOL(INFO)) {
    1871                                 fd_log_debug("New object to insert:");
    1872                                 dump_object(new, 0, 0, 3);
    1873                                 fd_log_debug("Object already in dictionary:");                 
    1874                                 dump_object(locref, 0, 0 , 3);
    1875                         }
    1876                 } else {
     1881                if (!ret) {
    18771882                        TRACE_DEBUG(FULL, "An existing object with the same data was found, ignoring the error...");
    18781883                }
    18791884                if (ref)
    18801885                        *ref = locref;
    1881         } else {
    1882                 CHECK_FCT_DO( ret, ); /* log the error */
    1883         }
    1884 
     1886        }
     1887all_errors:
     1888        if (ret != 0) {
     1889                char * buf = NULL;
     1890                size_t len = 0;
     1891               
     1892                CHECK_MALLOC( dict_obj_info[CHECK_TYPE(type) ? type : 0].dump_data(&buf, &len, NULL, data) );
     1893                TRACE_DEBUG(INFO, "An error occurred while adding the following data in the dictionary: %s", buf);
     1894               
     1895                if (ret == EEXIST) {
     1896                        CHECK_MALLOC( dump_object(&buf, &len, NULL, locref, 0, 0, 0) );
     1897                        TRACE_DEBUG(INFO, "Conflicting entry in the dictionary: %s", buf);
     1898                }
     1899                free(buf);
     1900        }
    18851901error_free:
    18861902        free(new);

  • libfdproto/dictionary_functions.c

    r1052 r1085  
    153153
    154154/* Dump the content of an Address AVP */
    155 char * fd_dictfct_Address_dump(union avp_value * avp_value)
    156 {
    157         char * ret;
    158         #define STR_LEN 1024
     155DECLARE_FD_DUMP_PROTOTYPE(fd_dictfct_Address_dump, union avp_value * avp_value)
     156{
    159157        union {
    160158                sSA     sa;
    … …  
    164162        } s;
    165163        uint16_t fam;
     164        size_t o = 0;
     165       
     166        if (!offset)
     167                offset = &o;
    166168       
    167169        memset(&s, 0, sizeof(s));
    168        
    169         CHECK_MALLOC_DO( ret = malloc(STR_LEN), return NULL );
    170170       
    171171        /* The first two octets represent the address family, http://www.iana.org/assignments/address-family-numbers/ */
    172172        if (avp_value->os.len < 2) {
    173                 snprintf(ret, STR_LEN, "[invalid length: %zd]", avp_value->os.len);
    174                 return ret;
     173                CHECK_MALLOC_DO( fd_dump_extend(FD_DUMP_STD_PARAMS, "[invalid length: %zd]", avp_value->os.len), return NULL);
     174                return *buf;
    175175        }
    176176       
    … …  
    182182                        s.sa.sa_family = AF_INET;
    183183                        if (avp_value->os.len != 6) {
    184                                 snprintf(ret, STR_LEN, "[invalid IP length: %zd]", avp_value->os.len);
    185                                 return ret;
     184                                CHECK_MALLOC_DO( fd_dump_extend(FD_DUMP_STD_PARAMS, "[invalid IP length: %zd]", avp_value->os.len), return NULL);
     185                                return *buf;
    186186                        }
    187187                        memcpy(&s.sin.sin_addr.s_addr, avp_value->os.data + 2, 4);
    … …  
    191191                        s.sa.sa_family = AF_INET6;
    192192                        if (avp_value->os.len != 18) {
    193                                 snprintf(ret, STR_LEN, "[invalid IP6 length: %zd]", avp_value->os.len);
    194                                 return ret;
     193                                CHECK_MALLOC_DO( fd_dump_extend(FD_DUMP_STD_PARAMS, "[invalid IP6 length: %zd]", avp_value->os.len), return NULL);
     194                                return *buf;
    195195                        }
    196196                        memcpy(&s.sin6.sin6_addr.s6_addr, avp_value->os.data + 2, 16);
    197197                        break;
    198198                default:
    199                         snprintf(ret, STR_LEN, "[unsupported family: 0x%hx]", fam);
    200                         return ret;
    201         }
    202        
    203         {
    204                 int rc = getnameinfo(&s.sa, sSAlen(&s.sa), ret, STR_LEN, NULL, 0, NI_NUMERICHOST);
    205                 if (rc)
    206                         snprintf(ret, STR_LEN, "%s", (char *)gai_strerror(rc));
    207         }
    208        
    209         return ret;
     199                        CHECK_MALLOC_DO( fd_dump_extend(FD_DUMP_STD_PARAMS, "[unsupported family: 0x%hx]", fam), return NULL);
     200                        return *buf;
     201        }
     202       
     203        return fd_sa_dump_node(FD_DUMP_STD_PARAMS, &s.sa, NI_NUMERICHOST);
    210204}
    211205
    … …  
    216210/*******************************/
    217211
    218 /* Dump the AVP in a natural human-readable format */
    219 char * fd_dictfct_UTF8String_dump(union avp_value * avp_value)
    220 {
    221 #define TRUNC_LEN       1024 /* avoid very long strings */
    222         char * ret;
    223         CHECK_MALLOC_DO( ret = malloc(TRUNC_LEN+2+3+1), return NULL );
    224         *ret = '"';
    225         strncpy(ret+1, (char *)avp_value->os.data, TRUNC_LEN);
    226         /* be sure to have a nul-terminated string */
    227         ret[TRUNC_LEN+1] = '\0';
    228         if (ret[1] != '\0') {
    229                 /* We sanitize the returned string to avoid UTF8 boundary problem.
    230                 We do this whether the string is trucated at TRUNC_LEN or not, to avoid potential problem
    231                 with malformed AVP */
    232 
    233                 char * end = strchr(ret, '\0');
    234                 while (end > ret) {
    235                         end--;
    236                         char b = *end;
    237                         /* after the position pointed by end, we have only \0s */
    238                         if ((b & 0x80) == 0) {
    239                                 break; /* this is a single byte char, no problem */
    240                         } else {
    241                                 /* this byte is start or cont. of multibyte sequence, as we do not know the next byte we need to delete it. */
    242                                 *end = '\0';
    243                                 if (b & 0x40)
    244                                         break; /* This was a start byte, we can stop the loop */
    245                         }
    246                 }
    247                 if (strlen((char *)avp_value->os.data) > strlen(ret+1))
    248                         strcat(end, "...");
    249                 strcat(end, "\"");
    250         } else {
    251                 *ret = '\0';
    252         }
    253         return ret;
     212/* Dump the AVP in a natural human-readable format. This dumps the complete length of the AVP, it is up to the caller to truncate if needed */
     213DECLARE_FD_DUMP_PROTOTYPE(fd_dictfct_UTF8String_dump, union avp_value * avp_value)
     214{
     215        size_t o = 0, l;
     216        if (!offset)
     217                offset = &o;
     218       
     219        l = avp_value->os.len;
     220        /* Just in case the string ends in invalid UTF-8 chars, we shorten it */
     221        while ((l > 0) && (avp_value->os.data[l - 1] & 0x80)) {
     222                /* this byte is start or cont. of multibyte sequence, as we do not know the next byte we need to delete it. */
     223                l--;
     224                if (avp_value->os.data[l] & 0x40)
     225                        break; /* This was a start byte, we can stop the loop */
     226        }
     227       
     228        CHECK_MALLOC_DO( fd_dump_extend(FD_DUMP_STD_PARAMS, "\"%.*s\"", (int)l, (char *)avp_value->os.data), return NULL);
     229       
     230        return *buf;
    254231}
    255232
    … …  
    326303}
    327304
    328 char * fd_dictfct_Time_dump(union avp_value * avp_value)
    329 {
    330         char * ret;
     305DECLARE_FD_DUMP_PROTOTYPE(fd_dictfct_Time_dump, union avp_value * avp_value)
     306{
     307        size_t o = 0;
    331308        time_t val;
    332309        struct tm conv;
    333         CHECK_MALLOC_DO( ret = malloc(STR_LEN), return NULL );
     310               
     311        if (!offset)
     312                offset = &o;
     313       
    334314        if (avp_value->os.len != 4) {
    335                 snprintf(ret, STR_LEN, "[invalid length: %zd]", avp_value->os.len);
    336                 return ret;
    337         }
     315                CHECK_MALLOC_DO( fd_dump_extend(FD_DUMP_STD_PARAMS, "[invalid length: %zd]", avp_value->os.len), return NULL);
     316                return *buf;
     317        }
     318
    338319        if (diameter_string_to_time_t((char *)avp_value->os.data, avp_value->os.len, &val) != 0) {
    339                 snprintf(ret, STR_LEN, "[time conversion error]");
    340                 return ret;
    341         }
    342         gmtime_r(&val, &conv);
    343         snprintf(ret, STR_LEN, "%d%02d%02dT%02d%02d%02d+00", conv.tm_year+1900, conv.tm_mon+1, conv.tm_mday, conv.tm_hour, conv.tm_min, conv.tm_sec);
    344         return ret;
    345 }
    346 
     320                CHECK_MALLOC_DO( fd_dump_extend(FD_DUMP_STD_PARAMS, "[time conversion error]"), return NULL);
     321                return *buf;
     322        }
     323       
     324        CHECK_MALLOC_DO( fd_dump_extend(FD_DUMP_STD_PARAMS, "%d%02d%02dT%02d%02d%02d+00", conv.tm_year+1900, conv.tm_mon+1, conv.tm_mday, conv.tm_hour, conv.tm_min, conv.tm_sec), return NULL);
     325        return *buf;
     326}
     327

  • libfdproto/fdproto-internal.h

    r1052 r1085  
    5151extern FILE * fd_g_debug_fstr;
    5252
    53 /* Special message dump function */
    54 void fd_msg_dump_fstr_one ( struct msg * msg, FILE * fstr );
    55 void fd_msg_dump_fstr ( struct msg * msg, FILE * fstr );
    56 
    5753/* Iterator on the rules of a parent object */
    5854int fd_dict_iterate_rules ( struct dict_object *parent, void * data, int (*cb)(void *, struct dict_rule_data *) );
    … …  
    6056/* Dispatch / messages / dictionary API */
    6157int fd_dict_disp_cb(enum dict_object_type type, struct dict_object *obj, struct fd_list ** cb_list);
    62 int fd_dict_dump_avp_value(union avp_value *avp_value, struct dict_object * model, int indent, char **outstr, size_t *offset, size_t *outlen, int header);
     58DECLARE_FD_DUMP_PROTOTYPE(fd_dict_dump_avp_value, union avp_value *avp_value, struct dict_object * model, int indent, int header);
    6359int fd_disp_call_cb_int( struct fd_list * cb_list, struct msg ** msg, struct avp *avp, struct session *sess, enum disp_action *action,
    6460                        struct dict_object * obj_app, struct dict_object * obj_cmd, struct dict_object * obj_avp, struct dict_object * obj_enu);
    … …  
    6965
    7066
    71 /* For dump routines into string buffers */
    72 #include <stdarg.h>
    73 static __inline__ int dump_init_str(char **outstr, size_t *offset, size_t *outlen)
    74 {
    75         *outlen = 1<<12;
    76         CHECK_MALLOC( *outstr = malloc(*outlen) );
    77         *offset = 0;
    78         (*outstr)[0] = 0;
    79         return 0;
    80 }
    81 static __inline__ int dump_add_str(char **outstr, size_t *offset, size_t *outlen, char * fmt, ...)
    82 {
    83         va_list argp;
    84         int len;
    85         va_start(argp, fmt);
    86         len = vsnprintf(*outstr + *offset, *outlen - *offset, fmt, argp);
    87         va_end(argp);
    88         if ((len + *offset) >= *outlen) {
    89                 char * newstr;
    90                 /* buffer was too short, extend */
    91                 size_t newsize = ((len + *offset) + (1<<12)) & ~((1<<12) - 1); /* next multiple of 4k */
    92                 CHECK_MALLOC( newstr = realloc(*outstr, newsize) );
    93                
    94                 /* redo */
    95                 *outstr = newstr;
    96                 *outlen = newsize;
    97                 va_start(argp, fmt);
    98                 len = vsnprintf(*outstr + *offset, *outlen - *offset, fmt, argp);
    99                 va_end(argp);
    100         }
    101         *offset += len;
    102         return 0;
    103 }
    104 
    105 
    106 
    10767#endif /* _LIBFDPROTO_INTERNAL_H */

  • libfdproto/fifo.c

    r1073 r1085  
    119119
    120120/* Dump the content of a queue */
    121 void fd_fifo_dump(int level, char * name, struct fifo * queue, void (*dump_item)(int level, void * item))
    122 {
    123         TRACE_ENTRY("%i %p %p %p", level, name, queue, dump_item);
    124        
    125         if (!TRACE_BOOL(level))
    126                 return;
    127        
    128         fd_log_debug("Dumping queue '%s' (%p):", name ?: "?", queue);
     121DECLARE_FD_DUMP_PROTOTYPE(fd_fifo_dump, char * name, struct fifo * queue, fd_fifo_dump_item_cb dump_item)
     122{
     123        size_t o = 0;
     124        if (!offset)
     125                offset = &o;
     126       
     127        if (name) {
     128                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "'%s'(@%p): ", name, queue), return NULL);
     129        } else {
     130                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{fifo}(@%p): ", queue), return NULL);
     131        }
     132       
    129133        if (!CHECK_FIFO( queue )) {
    130                 fd_log_debug("  Queue invalid!");
    131                 if (queue)
    132                         fd_log_debug("  (%x != %x)", queue->eyec, FIFO_EYEC);
    133                 return;
     134                return fd_dump_extend(FD_DUMP_STD_PARAMS, "INVALID/NULL\n");
    134135        }
    135136       
    136137        CHECK_POSIX_DO(  pthread_mutex_lock( &queue->mtx ), /* continue */  );
    137         fd_log_debug("   %d elements in queue / %d threads waiting", queue->count, queue->thrs);
    138         fd_log_debug("   %d elements max / %d threads waiting to push", queue->max, queue->thrs_push);
    139         fd_log_debug("   thresholds: %d / %d (h:%d), cb: %p,%p (%p), highest: %d",
    140                         queue->high, queue->low, queue->highest,
    141                         queue->h_cb, queue->l_cb, queue->data,
    142                         queue->highest_ever);
    143         fd_log_debug("   stats: total:%lld in %ld.%06ld, blocking:%ld.%06ld, last:%ld.%06ld",
    144                         queue->total_items,
    145                         (long)queue->total_time.tv_sec,(long)(queue->total_time.tv_nsec/1000),
    146                         (long)queue->blocking_time.tv_sec,(long)(queue->blocking_time.tv_nsec/1000),
    147                         (long)queue->last_time.tv_sec,(long)(queue->last_time.tv_nsec/1000) );
     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",
     139                                                queue->count, queue->highest_ever, queue->max,
     140                                                queue->thrs, queue->thrs_push,
     141                                                queue->total_items,(long)queue->total_time.tv_sec,(long)(queue->total_time.tv_nsec/1000),(long)queue->blocking_time.tv_sec,(long)(queue->blocking_time.tv_nsec/1000),(long)queue->last_time.tv_sec,(long)(queue->last_time.tv_nsec/1000),
     142                                                queue->high, queue->low, queue->highest, queue->h_cb, queue->l_cb, queue->data),
     143                         goto error);
    148144       
    149145        if (dump_item) {
    … …  
    152148                for (li = queue->list.next; li != &queue->list; li = li->next) {
    153149                        struct fifo_item * fi = (struct fifo_item *)li;
    154                         fd_log_debug("  [%i] item %p in fifo %p, posted:%ld.%06ld",
    155                                 i++, fi->item.o, queue, (long)fi->posted_on.tv_sec,(long)(fi->posted_on.tv_nsec/1000));
    156                         (*dump_item)(level, fi->item.o);
     150                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, " [#%i](@%p)@%ld.%06ld: ",
     151                                                i++, fi->item.o, (long)fi->posted_on.tv_sec,(long)(fi->posted_on.tv_nsec/1000)),
     152                                         goto error);
     153                        CHECK_MALLOC_DO( (*dump_item)(FD_DUMP_STD_PARAMS, fi->item.o), goto error);
    157154                }
    158155        }
    159156        CHECK_POSIX_DO(  pthread_mutex_unlock( &queue->mtx ), /* continue */  );
    160        
     157        return *buf;
     158error:
     159        CHECK_POSIX_DO(  pthread_mutex_unlock( &queue->mtx ), /* continue */  );
     160        return NULL;
    161161}
    162162

  • libfdproto/log.c

    r1027 r1085  
    143143}
    144144
    145 /* Log debug message to file. */
    146 void fd_log_debug_fstr( FILE * fstr, const char * format, ... )
    147 {
    148         va_list ap;
    149        
    150         va_start(ap, format);
    151         vfprintf(fstr, format, ap);
    152         va_end(ap);
     145/* Log a debug message */
     146void fd_log_va ( int loglevel, const char * format, va_list args )
     147{
     148        (void)pthread_mutex_lock(&fd_log_lock);
     149       
     150        pthread_cleanup_push(fd_cleanup_mutex_silent, &fd_log_lock);
     151        fd_logger(loglevel, format, args);
     152        pthread_cleanup_pop(0);
     153       
     154        (void)pthread_mutex_unlock(&fd_log_lock);
    153155}
    154156
    … …  
    208210        return buf;
    209211}
     212
     213
     214/* Helper function for fd_*_dump. Prints the format string from 'offset' into '*buf', extends if needed. The location of buf can be updated by this function. */
     215char * fd_dump_extend(char ** buf, size_t *len, size_t *offset, const char * format, ... )
     216{
     217        va_list ap;
     218        int to_write;
     219        size_t o = 0;
     220        static size_t mempagesz = 0;
     221       
     222        if (!mempagesz) {
     223                mempagesz = sysconf(_SC_PAGESIZE); /* We alloc buffer by memory pages for efficiency */
     224                if (mempagesz <= 0)
     225                        mempagesz = 1024; /* default size if above call failed */
     226        }
     227       
     228        /* we do not TRACE_ENTRY this one on purpose */
     229       
     230        CHECK_PARAMS_DO(buf && len, return NULL);
     231       
     232        if (*buf == NULL) {
     233                CHECK_MALLOC_DO(*buf = malloc(mempagesz), return NULL);
     234                *len = mempagesz;
     235        }
     236       
     237        if (offset)
     238                o = *offset;
     239       
     240        va_start(ap, format);
     241        to_write = vsnprintf(*buf + o, *len - o, format, ap);
     242        va_end(ap);
     243       
     244        if (to_write + o >= *len) {
     245                /* There was no room in the buffer, we extend and redo */
     246                size_t new_len = (((to_write + o) / mempagesz) + 1) * mempagesz;
     247                CHECK_MALLOC_DO(*buf = realloc(*buf, new_len), return NULL);
     248                *len = new_len;
     249               
     250                va_start(ap, format);
     251                to_write = vsnprintf(*buf + o, *len - o, format, ap);
     252                va_end(ap);
     253        }
     254       
     255        if (offset)
     256                *offset += to_write;
     257       
     258        return *buf;
     259}

  • libfdproto/messages.c

    r1084 r1085  
    711711/* Debug functions: dumping */
    712712
     713#warning "todo"
     714DECLARE_FD_DUMP_PROTOTYPE( fd_msg_dump_summary, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
     715{
     716        return NULL;
     717}
     718/* one-line dump with all the contents of the message */
     719DECLARE_FD_DUMP_PROTOTYPE( fd_msg_dump_full, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
     720{
     721        return NULL;
     722}
     723/* multi-line human-readable dump similar to wireshark output */
     724DECLARE_FD_DUMP_PROTOTYPE( fd_msg_dump_treeview, msg_or_avp *obj, struct dictionary *dict, int force_parsing, int recurse )
     725{
     726        return NULL;
     727}
     728
     729#ifndef OLD_CODE_TO_BE_REPLACED
     730void fd_msg_dump_walk ( int level, msg_or_avp *obj )
     731{
     732        LOG_D("fd_msg_dump_walk %d, %p is deprecated", level, obj);
     733}
     734void fd_msg_dump_one ( int level, msg_or_avp * obj )
     735{
     736        LOG_D("fd_msg_dump_one %d, %p is deprecated", level, obj);
     737}
     738#else  /* OLD_CODE_TO_BE_REPLACED */
     739
     740
    713741/* indent inside an object */
    714742#define INOBJHDR        "%*s   "
    … …  
    10761104}
    10771105
    1078 
     1106#endif /*  OLD_CODE_TO_BE_REPLACED */
    10791107/***************************************************************************************************************/
    10801108/* Simple meta-data management */

  • libfdproto/sessions.c

    r1027 r1085  
    7070        int               id;   /* A unique integer to identify this handler */
    7171        void            (*cleanup)(session_state *, os0_t, void *); /* The cleanup function to be called for cleaning a state */
     72        session_state_dump *state_dump; /* dumper function */
    7273        void             *opaque; /* a value that is passed as is to the cleanup callback */
    7374};
    … …  
    273274
    274275/* Create a new handler */
    275 int fd_sess_handler_create_internal ( struct session_handler ** handler, void (*cleanup)(session_state *, os0_t, void *), void * opaque )
     276int fd_sess_handler_create_internal ( struct session_handler ** handler, void (*cleanup)(session_state *, os0_t, void *), session_state_dump dumper, void * opaque )
    276277{
    277278        struct session_handler *new;
    … …  
    290291        new->eyec = SH_EYEC;
    291292        new->cleanup = cleanup;
     293        new->state_dump = dumper;
    292294        new->opaque = opaque;
    293295       
    … …  
    873875
    874876/* Dump functions */
    875 void fd_sess_dump(int level, struct session * session)
    876 {
    877         struct fd_list * li;
    878         char buf[30];
    879         struct tm tm;
    880        
    881         if (!TRACE_BOOL(level))
    882                 return;
    883        
    884         fd_log_debug("\t  %*s -- Session @%p --", level, "", session);
     877DECLARE_FD_DUMP_PROTOTYPE(fd_sess_dump, struct session * session, int with_states)
     878{
     879        size_t o = 0;
     880        if (!offset)
     881                offset = &o;
     882       
     883        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{session}(@%p): ", session), return NULL);
     884       
    885885        if (!VALIDATE_SI(session)) {
    886                 fd_log_debug("\t  %*s  Invalid session object", level, "");
     886                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL\n"), return NULL);
    887887        } else {
    888                
    889                 fd_log_debug("\t  %*s  sid '%s'(%zd), hash %x, msg %d, destroyed %d", level, "", session->sid, session->sidlen, session->hash, session->msg_cnt, session->is_destroyed);
    890 
    891                 strftime(buf, sizeof(buf), "%D,%T", localtime_r( &session->timeout.tv_sec , &tm ));
    892                 fd_log_debug("\t  %*s  timeout %s.%09ld", level, "", buf, session->timeout.tv_nsec);
    893 
    894                 CHECK_POSIX_DO( pthread_mutex_lock(&session->stlock), /* ignore */ );
    895                 pthread_cleanup_push( fd_cleanup_mutex, &session->stlock );
    896                 for (li = session->states.next; li != &session->states; li = li->next) {
    897                         struct state * st = (struct state *)(li->o);
    898                         fd_log_debug("\t  %*s    handler %d registered data %p", level, "", st->hdl->id, st->state);
     888                char timebuf[30];
     889                struct tm tm;
     890
     891                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",
     893                                                        session->sid, session->sidlen, session->hash, session->msg_cnt, session->is_destroyed,
     894                                                        timebuf, session->timeout.tv_nsec/1000),
     895                                 return NULL);
     896               
     897                if (with_states) {
     898                        struct fd_list * li;
     899                        CHECK_POSIX_DO( pthread_mutex_lock(&session->stlock), /* ignore */ );
     900                        pthread_cleanup_push( fd_cleanup_mutex, &session->stlock );
     901                       
     902                        for (li = session->states.next; li != &session->states; li = li->next) {
     903                                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);
     905                                if (st->hdl->state_dump) {
     906                                        CHECK_MALLOC_DO( (*st->hdl->state_dump)( FD_DUMP_STD_PARAMS, st->state),
     907                                                        fd_dump_extend( FD_DUMP_STD_PARAMS, "[dumper error]\n"));
     908                                } else {
     909                                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "<%p>\n", st->state), return NULL);
     910                                }
     911                        }
     912                       
     913                        pthread_cleanup_pop(0);
     914                        CHECK_POSIX_DO( pthread_mutex_unlock(&session->stlock), /* ignore */ );
    899915                }
    900                 pthread_cleanup_pop(0);
    901                 CHECK_POSIX_DO( pthread_mutex_unlock(&session->stlock), /* ignore */ );
    902         }
    903         fd_log_debug("\t  %*s -- end of session @%p --", level, "", session);
    904 }
    905 
    906 void fd_sess_dump_hdl(int level, struct session_handler * handler)
    907 {
    908         if (!TRACE_BOOL(level))
    909                 return;
    910        
    911         fd_log_debug("\t  %*s -- Handler @%p --", level, "", handler);
     916        }
     917        return *buf;
     918}
     919
     920DECLARE_FD_DUMP_PROTOTYPE(fd_sess_dump_hdl, struct session_handler * handler)
     921{
     922        size_t o = 0;
     923        if (!offset)
     924                offset = &o;
     925       
     926        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{sesshdl}(@%p): ", handler), return NULL);
     927       
    912928        if (!VALIDATE_SH(handler)) {
    913                 fd_log_debug("\t  %*s  Invalid session handler object", level, "");
     929                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL\n"), return NULL);
    914930        } else {
    915                 fd_log_debug("\t  %*s  id %d, cleanup %p, opaque %p", level, "", handler->id, handler->cleanup, handler->opaque);
    916         }
    917         fd_log_debug("\t  %*s -- end of handler @%p --", level, "", handler);
     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);
     932        }
     933        return *buf;
    918934}       
    919935

  • libfdproto/utils.c

    r1084 r1085  
    3636#include "fdproto-internal.h"
    3737
    38 char * fd_sa_dump_node(char * buf, size_t bufsize, sSA * sa, int flags)
     38DECLARE_FD_DUMP_PROTOTYPE(fd_sa_dump_node, sSA * sa, int flags)
    3939{
    4040        char addrbuf[INET6_ADDRSTRLEN];
     41        size_t o = 0;
     42        if (!offset)
     43                offset = &o;
     44       
    4145        if (sa) {
    4246                int rc = getnameinfo(sa, sSAlen( sa ), addrbuf, sizeof(addrbuf), NULL, 0, flags);
    43                 if (rc)
    44                         snprintf(buf, bufsize, "%s", gai_strerror(rc));
    45                 else
    46                         snprintf(buf, bufsize, "%s", &addrbuf[0]);
     47                if (rc) {
     48                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%s", gai_strerror(rc)), return NULL);
     49                } else {
     50                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%s", &addrbuf[0]), return NULL);
     51                }
    4752        } else {
    48                 snprintf(buf, bufsize, "(NULL / ANY)");
     53                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(NULL / ANY)"), return NULL);
    4954        }
    50         return buf;
     55       
     56        return *buf;
    5157}
    5258
    53 char * fd_sa_dump_node_serv(char * buf, size_t bufsize, sSA * sa, int flags)
     59DECLARE_FD_DUMP_PROTOTYPE(fd_sa_dump_node_serv, sSA * sa, int flags)
    5460{
    5561        char addrbuf[INET6_ADDRSTRLEN];
    5662        char servbuf[32];
     63        size_t o = 0;
     64        if (!offset)
     65                offset = &o;
     66       
    5767        if (sa) {
    5868                int rc = getnameinfo(sa, sSAlen( sa ), addrbuf, sizeof(addrbuf), servbuf, sizeof(servbuf), flags);
    59                 if (rc)
    60                         snprintf(buf, bufsize, "%s", gai_strerror(rc));
    61                 else
    62                         snprintf(buf, bufsize, "%s", &addrbuf[0]);
     69                if (rc) {
     70                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%s", gai_strerror(rc)), return NULL);
     71                } else {
     72                        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%s", &addrbuf[0]), return NULL);
     73                }
    6374        } else {
    64                 snprintf(buf, bufsize, "(NULL / ANY)");
     75                CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(NULL / ANY)"), return NULL);
    6576        }
    66         return buf;
     77        return *buf;
    6778}
Note: See TracChangeset for help on using the changeset viewer.