int get_imsi(struct msg * msg, struct avp ** avp)
{
struct avp * nextavp = NULL, * a = NULL;
struct avp_hdr * a_hdr = NULL;
struct dict_avp_data dictdata;
struct avp_hdr *avp_dst;
*avp = NULL;
CHECK_FCT( fd_dict_getval(dcca_dict.Subscription_Id, &dictdata) );
CHECK_FCT( fd_msg_browse(msg, MSG_BRW_FIRST_CHILD, (void *)&nextavp, NULL) );
while (nextavp) {
CHECK_FCT( fd_msg_avp_hdr( nextavp, &avp_dst ) );
if ( (avp_dst->avp_code == dictdata.avp_code) && (avp_dst->avp_vendor == dictdata.avp_vendor) ) {
CHECK_FCT( avp_search_child ( nextavp, dcca_dict.Subscription_Id_Type, &a) );
if(a) {
CHECK_FCT( fd_msg_avp_hdr( a, &a_hdr ) );
if(a_hdr->avp_value->i32 == 1) {
CHECK_FCT( avp_search_child ( nextavp, dcca_dict.Subscription_Id_Data, avp) );
break;
}
}
}
/* Otherwise move to next AVP in the message */
CHECK_FCT( fd_msg_browse(nextavp, MSG_BRW_NEXT, (void *)&nextavp, NULL) );
}
return 0;
}
/* Test for the dict_iterate_rules function */
int iter_test(void * data, struct dict_rule_data * rule)
{
struct dict_avp_data avpdata;
(*(int *)data)++;
CHECK( 0, fd_dict_getval ( rule->rule_avp, &avpdata ) );
TRACE_DEBUG(FULL, "rule #%d: avp '%s'", *(int *)data, avpdata.avp_name);
return 0;
}
int avp_search_child ( struct avp * msg, struct dict_object * what, struct avp ** avp )
{
struct avp * nextavp;
struct dict_avp_data dictdata;
struct avp_hdr *avp_dst;
TRACE_ENTRY("%p %p %p", msg, what, avp);
*avp = NULL;
CHECK_FCT( fd_dict_getval(what, &dictdata) );
/* Loop on all top AVPs */
CHECK_FCT( fd_msg_browse(msg, MSG_BRW_FIRST_CHILD, (void *)&nextavp, NULL) );
while (nextavp) {
CHECK_FCT( fd_msg_avp_hdr( nextavp, &avp_dst ) );
if ( (avp_dst->avp_code == dictdata.avp_code) && (avp_dst->avp_vendor == dictdata.avp_vendor) ) {
break;
}
/* Otherwise move to next AVP in the message */
CHECK_FCT( fd_msg_browse(nextavp, MSG_BRW_NEXT, (void *)&nextavp, NULL) );
}
if (avp)
*avp = nextavp;
if (avp && nextavp) {
struct dictionary * dict;
CHECK_FCT( fd_dict_getdict( what, &dict) );
CHECK_FCT_DO( fd_msg_parse_dict( nextavp, dict, NULL ), /* nothing */ );
}
if (avp || nextavp)
return 0;
else
return ENOENT;
}
/* Main test routine */
int main(int argc, char *argv[])
{
/* First, initialize the daemon modules */
INIT_FD();
/* Test creating and searching all types of objects */
{
struct dict_object * obj1 = NULL;
struct dict_object * obj2 = NULL;
struct dict_object * obj3 = NULL;
vendor_id_t vendor_id = 735671;
struct dict_vendor_data vendor1_data = { 735671, "Vendor test 1" };
struct dict_vendor_data vendor2_data = { 735672, "Vendor test 2" };
struct dict_application_data app1_data = { 735674, "Application test 1" };
/* Create two vendors */
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_VENDOR, &vendor1_data , NULL, &obj1 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_VENDOR, &vendor2_data , NULL, NULL ) );
/* Check we always retrieve the correct vendor object */
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, &obj2, ENOENT ) );
CHECK( obj1, obj2);
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 1", &obj2, ENOENT ) );
CHECK( obj1, obj2);
/* Check the error conditions */
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, NULL, ENOENT ) );
vendor_id = 735673; /* Not defined */
CHECK( ENOENT, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, NULL, ENOENT ) );
CHECK( ENOENT, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", NULL, ENOENT ) );
CHECK( ENOENT, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_ID, &vendor_id, &obj2, ENOENT ) );
CHECK( ENOENT, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", &obj2, ENOENT ) );
CHECK( ENOTSUP, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_NAME, "Vendor test 3", &obj2, ENOTSUP ) );
/* Check the get_* functions */
CHECK( 0, fd_dict_getval ( obj1, &vendor1_data ) );
CHECK( 735671, vendor1_data.vendor_id );
CHECK( 0, strcmp(vendor1_data.vendor_name, "Vendor test 1") );
/* error conditions */
CHECK( EINVAL, fd_dict_getval ( (struct dict_object *)"not an object", &vendor1_data ) );
/* Create the application with vendor1 as parent */
CHECK( EINVAL, fd_dict_new ( fd_g_config->cnf_dict, DICT_APPLICATION, &app1_data , (struct dict_object *)"bad object", &obj2 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_APPLICATION, &app1_data , obj1, &obj2 ) );
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_OF_APPLICATION, obj2, &obj3, ENOENT ) );
CHECK( obj1, obj3);
/* Creating and searching the other objects is already done in dictionary initialization */
}
/* Test creation of the "Example-AVP" grouped AVP from the RFC */
{
int nbr = 0;
struct dict_object * origin_host_avp = NULL;
struct dict_object * session_id_avp = NULL;
struct dict_object * example_avp_avp = NULL;
struct dict_rule_data rule_data = { NULL, RULE_REQUIRED, -1, -1 };
struct dict_avp_data example_avp_data = { 999999, 0, "Example-AVP", AVP_FLAG_VENDOR , 0, AVP_TYPE_GROUPED };
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Origin-Host", &origin_host_avp, ENOENT ) );
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Session-Id", &session_id_avp, ENOENT ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &example_avp_data , NULL, &example_avp_avp ) );
rule_data.rule_avp = origin_host_avp;
rule_data.rule_min = 1;
rule_data.rule_max = 1;
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_RULE, &rule_data, example_avp_avp, NULL ) );
rule_data.rule_avp = session_id_avp;
rule_data.rule_min = 1;
rule_data.rule_max = -1;
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_RULE, &rule_data, example_avp_avp, NULL ) );
CHECK( 0, fd_dict_iterate_rules ( example_avp_avp, &nbr, iter_test) );
CHECK( 2, nbr );
}
/* Test list function */
{
struct fd_list * li = NULL;
struct fd_list * sentinel = NULL;
enum dict_object_type type;
struct dict_object * defvnd=NULL;
vendor_id_t vid = 0;
int first = 1;
CHECK( 0, fd_dict_getlistof(VENDOR_BY_ID, fd_g_config->cnf_dict, &sentinel));
for (li = sentinel; (li != sentinel) || (first != 0); li = li->next) {
first = 0;
CHECK(0, fd_dict_gettype(li->o, &type));
CHECK(DICT_VENDOR, type);
#if 0
struct dict_vendor_data data;
CHECK( 0, fd_dict_getval(li->o, &data) );
printf("%d : %s\n", data.vendor_id, data.vendor_name);
#endif
}
CHECK( 0, fd_dict_search(fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_ID, &vid, &defvnd, ENOENT) );
CHECK( 0, fd_dict_getlistof(AVP_BY_NAME, defvnd, &sentinel));
for (li = sentinel->next; li != sentinel; li = li->next) {
CHECK(0, fd_dict_gettype(li->o, &type));
CHECK(DICT_AVP, type);
#if 0
struct dict_avp_data data;
CHECK( 0, fd_dict_getval(li->o, &data) );
printf("%d : %s\n", data.avp_code, data.avp_name);
#endif
}
}
/* Test delete function */
{
struct fd_list * li = NULL;
struct fd_list * sentinel = NULL;
struct dict_object * obj=NULL;
vendor_id_t vid = 0;
int count = 0, cntbkp;
CHECK( 0, fd_dict_search(fd_g_config->cnf_dict, DICT_VENDOR, VENDOR_BY_ID, &vid, &obj, ENOENT) );
CHECK( EINVAL, fd_dict_delete(obj) );
CHECK( 0, fd_dict_getlistof(AVP_BY_NAME, obj, &sentinel));
obj = NULL;
for (li = sentinel->next; li != sentinel; li = li->next) {
struct dict_avp_data data;
CHECK( 0, fd_dict_getval(li->o, &data) );
count++;
if (data.avp_basetype != AVP_TYPE_GROUPED)
obj = li->o;
}
CHECK(1, obj ? 1 : 0 );
#if 1
fd_log_debug("%s", fd_dict_dump_object(FD_DUMP_TEST_PARAMS, obj));
#endif
CHECK( 0, fd_dict_delete(obj) );
cntbkp = count;
count = 0;
for (li = sentinel->next; li != sentinel; li = li->next) {
count++;
}
CHECK( 1, cntbkp - count );
}
LOG_D( "Dictionary at the end of %s: %s", __FILE__, fd_dict_dump(FD_DUMP_TEST_PARAMS, fd_g_config->cnf_dict) ?: "error");
/* That's all for the tests yet */
PASSTEST();
}
