690 lines
26 KiB
C
690 lines
26 KiB
C
/*********************************************************************************************************
|
|
* Software License Agreement (BSD License) *
|
|
* Author: Sebastien Decugis <sdecugis@freediameter.net> *
|
|
* *
|
|
* Copyright (c) 2013, WIDE Project and NICT *
|
|
* All rights reserved. *
|
|
* *
|
|
* Redistribution and use of this software in source and binary forms, with or without modification, are *
|
|
* permitted provided that the following conditions are met: *
|
|
* *
|
|
* * Redistributions of source code must retain the above *
|
|
* copyright notice, this list of conditions and the *
|
|
* following disclaimer. *
|
|
* *
|
|
* * Redistributions in binary form must reproduce the above *
|
|
* copyright notice, this list of conditions and the *
|
|
* following disclaimer in the documentation and/or other *
|
|
* materials provided with the distribution. *
|
|
* *
|
|
* * Neither the name of the WIDE Project or NICT nor the *
|
|
* names of its contributors may be used to endorse or *
|
|
* promote products derived from this software without *
|
|
* specific prior written permission of WIDE Project and *
|
|
* NICT. *
|
|
* *
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED *
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
|
|
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR *
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT *
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS *
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR *
|
|
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF *
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
|
|
*********************************************************************************************************/
|
|
|
|
#include "tests.h"
|
|
#include <dirent.h>
|
|
#include <libgen.h>
|
|
#include <dlfcn.h>
|
|
|
|
#ifndef BUILD_DIR
|
|
#error "Missing BUILD_DIR information"
|
|
#endif /* BUILD_DIR */
|
|
|
|
|
|
/* The number of times each operation is repeated to measure the average operation time */
|
|
#define DEFAULT_NUMBER_OF_SAMPLES 100000
|
|
|
|
static void display_result(int nr, struct timespec * start, struct timespec * end, char * fct, char * type, char *op)
|
|
{
|
|
long double dur = (long double)end->tv_sec + (long double)end->tv_nsec/1000000000;
|
|
dur -= (long double)start->tv_sec + (long double)start->tv_nsec/1000000000;
|
|
long double thrp = (long double)nr / dur;
|
|
printf("%-19s: %d %-8s %-7s in %.6LFs (%.1LFmsg/s)\n", fct, nr, type, op, dur, thrp);
|
|
}
|
|
|
|
struct ext_info {
|
|
struct fd_list chain; /* link in the list */
|
|
void *handler; /* object returned by dlopen() */
|
|
int (*init_cb)(int, int, char *);
|
|
char *ext_name; /* points to the extension name, either inside depends, or basename(filename) */
|
|
int free_ext_name; /* must be freed if it was malloc'd */
|
|
const char **depends; /* names of the other extensions this one depends on (if provided) */
|
|
};
|
|
|
|
static void load_all_extensions(char * prefix)
|
|
{
|
|
DIR *dir;
|
|
struct dirent *dp;
|
|
char fullname[512];
|
|
int pathlen;
|
|
struct fd_list all_extensions = FD_LIST_INITIALIZER(all_extensions);
|
|
struct fd_list ext_with_depends = FD_LIST_INITIALIZER(ext_with_depends);
|
|
|
|
/* Find all extensions which have been compiled along the test */
|
|
LOG_D("Loading %s*.fdx from: '%s'", BUILD_DIR "/extensions", prefix ?: "");
|
|
CHECK( 0, (dir = opendir (BUILD_DIR "/extensions")) == NULL ? 1 : 0 );
|
|
pathlen = snprintf(fullname, sizeof(fullname), BUILD_DIR "/extensions/");
|
|
|
|
while ((dp = readdir (dir)) != NULL) {
|
|
char * dot = strrchr(dp->d_name, '.');
|
|
if (dot && ((!prefix) || !(strncmp(dp->d_name, prefix, strlen(prefix)))) && (!(strcmp(dot, ".fdx")))) {
|
|
/* We found a file with name dict_*.fdx, attempt to load it */
|
|
struct ext_info * new = malloc(sizeof(struct ext_info));
|
|
CHECK( 1, new ? 1:0);
|
|
fd_list_init(&new->chain, new);
|
|
|
|
snprintf(fullname + pathlen, sizeof(fullname) - pathlen, "%s", dp->d_name);
|
|
|
|
LOG_D("Extension: '%s'", dp->d_name);
|
|
|
|
/* load */
|
|
new->handler = dlopen(fullname, RTLD_NOW | RTLD_GLOBAL);
|
|
if (!new->handler) {
|
|
TRACE_DEBUG(INFO, "Unable to load '%s': %s.", fullname, dlerror());
|
|
}
|
|
CHECK( 0, new->handler == NULL ? 1 : 0 );
|
|
|
|
/* resolve entry */
|
|
new->init_cb = dlsym( new->handler, "fd_ext_init" );
|
|
if (!new->init_cb) {
|
|
TRACE_DEBUG(INFO, "No 'fd_ext_init' entry point in '%s': %s.", fullname, dlerror());
|
|
}
|
|
CHECK( 0, new->init_cb == NULL ? 1 : 0 );
|
|
|
|
new->depends = dlsym( new->handler, "fd_ext_depends" );
|
|
if (new->depends) {
|
|
new->ext_name = (char *)new->depends[0];
|
|
new->free_ext_name = 0;
|
|
if ( new->depends[1] ) {
|
|
fd_list_insert_before(&ext_with_depends, &new->chain);
|
|
} else {
|
|
fd_list_insert_before(&all_extensions, &new->chain);
|
|
}
|
|
} else {
|
|
new->ext_name = strdup(basename(dp->d_name));
|
|
new->free_ext_name = 1;
|
|
fd_list_insert_before(&all_extensions, &new->chain);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/* Now, reorder the list by dependencies */
|
|
{
|
|
int count, prevcount = 0;
|
|
struct fd_list * li;
|
|
do {
|
|
count = 0;
|
|
for (li=ext_with_depends.next; li != &ext_with_depends; li=li->next) {
|
|
struct ext_info * e = li->o;
|
|
int d;
|
|
int satisfied=0;
|
|
|
|
/* Can we satisfy all dependencies? */
|
|
for (d=1; ;d++) {
|
|
struct fd_list * eli;
|
|
if (!e->depends[d]) {
|
|
satisfied = 1;
|
|
break;
|
|
}
|
|
|
|
/* can we find this dependency in the list? */
|
|
for (eli=all_extensions.next; eli != &all_extensions; eli = eli->next) {
|
|
struct ext_info * de = eli->o;
|
|
if (!strcasecmp(de->ext_name, e->depends[d]))
|
|
break; /* this dependency is satisfied */
|
|
}
|
|
|
|
if (eli == &all_extensions) {
|
|
satisfied = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (satisfied) {
|
|
/* OK, we have all our dependencies in the list */
|
|
li=li->prev;
|
|
fd_list_unlink(&e->chain);
|
|
fd_list_insert_before(&all_extensions, &e->chain);
|
|
} else {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (prevcount && (prevcount == count)) {
|
|
LOG_E("Some extensions cannot have their dependencies satisfied, e.g.: %s", ((struct ext_info *)ext_with_depends.next->o)->ext_name);
|
|
CHECK(0, 1);
|
|
}
|
|
prevcount = count;
|
|
|
|
if (FD_IS_LIST_EMPTY(&ext_with_depends))
|
|
break;
|
|
} while (1);
|
|
}
|
|
|
|
/* Now, load all the extensions */
|
|
{
|
|
struct fd_list * li;
|
|
for (li=all_extensions.next; li != &all_extensions; li=li->next) {
|
|
struct ext_info * e = li->o;
|
|
int ret = (*e->init_cb)( FD_PROJECT_VERSION_MAJOR, FD_PROJECT_VERSION_MINOR, NULL );
|
|
LOG_N("Initializing extension '%s': %s", e->ext_name, ret ? strerror(ret) : "Success");
|
|
}
|
|
}
|
|
|
|
/* We should probably clean the list here ? */
|
|
}
|
|
|
|
/* Main test routine */
|
|
int main(int argc, char *argv[])
|
|
{
|
|
struct msg * acr = NULL;
|
|
unsigned char * buf = NULL;
|
|
|
|
int dictionaries_loaded = 0;
|
|
|
|
test_parameter = DEFAULT_NUMBER_OF_SAMPLES;
|
|
|
|
/* First, initialize the daemon modules */
|
|
INIT_FD();
|
|
CHECK( 0, fd_queues_init() );
|
|
CHECK( 0, fd_msg_init() );
|
|
CHECK( 0, fd_rtdisp_init() );
|
|
|
|
|
|
{
|
|
struct dict_object * acr_model = NULL;
|
|
|
|
/* Now find the ACR dictionary object */
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Accounting-Request", &acr_model, ENOENT ) );
|
|
|
|
/* Create the instance, using the templates */
|
|
CHECK( 0, fd_msg_new ( acr_model, 0, &acr ) );
|
|
}
|
|
|
|
/* Now let's create some additional Dictionary objects for the test */
|
|
{
|
|
/* The constant values used here are totally arbitrary chosen */
|
|
struct dict_object * vendor;
|
|
{
|
|
struct dict_vendor_data vendor_data = { 73565, "Vendor test" };
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_VENDOR, &vendor_data , NULL, &vendor ) );
|
|
}
|
|
|
|
{
|
|
struct dict_application_data app_data = { 73566, "Application test" };
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_APPLICATION, &app_data , vendor, NULL ) );
|
|
}
|
|
|
|
{
|
|
struct dict_avp_data avp_data = { 73567, 0, "AVP Test - no vendor - f32", 0, 0, AVP_TYPE_FLOAT32 };
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp_data , NULL, NULL ) );
|
|
}
|
|
|
|
{
|
|
struct dict_avp_data avp_data = { 139103, 0, "AVP Test - no vendor - f64", 0, 0, AVP_TYPE_FLOAT64 };
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp_data , NULL, NULL ) );
|
|
}
|
|
|
|
{
|
|
struct dict_object * type = NULL;
|
|
struct dict_type_data type_data = { AVP_TYPE_INTEGER64, "Int64 test" };
|
|
struct dict_avp_data avp_data = { 73568, 73565, "AVP Test - i64", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_INTEGER64 };
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_TYPE, &type_data , NULL, &type ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp_data , type, NULL ) );
|
|
}
|
|
|
|
{
|
|
struct dict_object * type = NULL;
|
|
struct dict_type_data type_data = { AVP_TYPE_INTEGER32, "Enum32 test" };
|
|
struct dict_enumval_data val1 = { "i32 const test (val 1)", { .i32 = 1 } };
|
|
struct dict_enumval_data val2 = { "i32 const test (val 2)", { .i32 = 2 } };
|
|
struct dict_enumval_data val3 = { "i32 const test (val -5)",{ .i32 = -5 } };
|
|
struct dict_avp_data avp_data = { 73569, 73565, "AVP Test - enumi32", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_INTEGER32 };
|
|
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_TYPE, &type_data , NULL, &type ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp_data , type, NULL ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_ENUMVAL, &val1 , type, NULL ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_ENUMVAL, &val2 , type, NULL ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_ENUMVAL, &val3 , type, NULL ) );
|
|
}
|
|
|
|
{
|
|
struct dict_object * type = NULL;
|
|
struct dict_type_data type_data = { AVP_TYPE_OCTETSTRING, "OS test" };
|
|
struct dict_avp_data avp_data = { 73570, 73565, "AVP Test - os", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_OCTETSTRING };
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_TYPE, &type_data , NULL, &type ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp_data , type, NULL ) );
|
|
}
|
|
|
|
{
|
|
struct dict_object * type = NULL;
|
|
struct dict_type_data type_data = { AVP_TYPE_OCTETSTRING, "OS enum test" };
|
|
struct dict_enumval_data val1 = { "os const test (Test)", { .os = { (unsigned char *)"Test", 4 } } };
|
|
struct dict_enumval_data val2 = { "os const test (waaad)", { .os = { (unsigned char *)"waaad", 5 } } };
|
|
struct dict_enumval_data val3 = { "os const test (waa)", { .os = { (unsigned char *)"waaad", 3 } } };
|
|
struct dict_avp_data avp_data = { 73571, 73565, "AVP Test - enumos", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_OCTETSTRING };
|
|
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_TYPE, &type_data , NULL, &type ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp_data , type, NULL ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_ENUMVAL, &val1 , type, NULL ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_ENUMVAL, &val2 , type, NULL ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_ENUMVAL, &val3 , type, NULL ) );
|
|
}
|
|
|
|
{
|
|
struct dict_object * gavp = NULL;
|
|
struct dict_avp_data avp_data = { 73572, 73565, "AVP Test - grouped", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_GROUPED };
|
|
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp_data , NULL, &gavp ) );
|
|
|
|
/* Macro to search AVP and create a rule */
|
|
#define ADD_RULE( _parent, _vendor, _avpname, _pos, _min, _max, _ord ) { \
|
|
struct dict_object * _avp = NULL; \
|
|
struct dict_avp_request _req = { (_vendor), 0, (_avpname) }; \
|
|
struct dict_rule_data _data; \
|
|
CHECK( 0, fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &_req, &_avp, ENOENT));\
|
|
_data.rule_avp = _avp; \
|
|
_data.rule_position = (_pos); \
|
|
_data.rule_order = (_ord); \
|
|
_data.rule_min = (_min); \
|
|
_data.rule_max = (_max); \
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_RULE, &_data , (_parent), NULL ) ); \
|
|
}
|
|
|
|
ADD_RULE(gavp, 73565, "AVP Test - os", RULE_OPTIONAL, -1, -1, 0);
|
|
|
|
}
|
|
|
|
{
|
|
struct dict_object * application = NULL;
|
|
struct dict_object * command = NULL;
|
|
struct dict_cmd_data cmd_data = { 73573, "Test-Command-Request", CMD_FLAG_REQUEST, CMD_FLAG_REQUEST };
|
|
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_APPLICATION, APPLICATION_BY_NAME, "Application test", &application, ENOENT ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_COMMAND, &cmd_data , application, &command ) );
|
|
ADD_RULE(command, 0, "AVP Test - no vendor - f32", RULE_FIXED_HEAD, -1, 1, 1);
|
|
ADD_RULE(command, 73565, "AVP Test - i64", RULE_REQUIRED, -1, -1, 0);
|
|
ADD_RULE(command, 73565, "AVP Test - enumi32", RULE_OPTIONAL, -1, -1, 0);
|
|
ADD_RULE(command, 73565, "AVP Test - os", RULE_OPTIONAL, -1, -1, 0);
|
|
ADD_RULE(command, 73565, "AVP Test - enumos", RULE_OPTIONAL, -1, -1, 0);
|
|
ADD_RULE(command, 73565, "AVP Test - grouped", RULE_OPTIONAL, -1, -1, 0);
|
|
}
|
|
|
|
{
|
|
struct dict_object * application = NULL;
|
|
struct dict_object * command = NULL;
|
|
struct dict_cmd_data cmd_data = { 73573, "Test-Command-Answer", CMD_FLAG_REQUEST, 0 };
|
|
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_APPLICATION, APPLICATION_BY_NAME, "Application test", &application, ENOENT ) );
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_COMMAND, &cmd_data , application, &command ) );
|
|
}
|
|
|
|
{
|
|
struct dict_object * gavp = NULL;
|
|
struct dict_avp_data avp_data = { 73574, 73565, "AVP Test - rules", AVP_FLAG_VENDOR, AVP_FLAG_VENDOR, AVP_TYPE_GROUPED };
|
|
|
|
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp_data , NULL, &gavp ) );
|
|
|
|
ADD_RULE(gavp, 0, "AVP Test - no vendor - f32", RULE_FIXED_HEAD, 0, 1, 1);
|
|
ADD_RULE(gavp, 73565, "AVP Test - i64", RULE_FIXED_HEAD, -1, 1, 2);
|
|
ADD_RULE(gavp, 73565, "AVP Test - enumi32", RULE_FIXED_HEAD, -1, 1, 3);
|
|
ADD_RULE(gavp, 73565, "AVP Test - os", RULE_REQUIRED, 2, 3, 0);
|
|
ADD_RULE(gavp, 73565, "AVP Test - enumos", RULE_OPTIONAL, 0, 1, 0);
|
|
ADD_RULE(gavp, 73565, "AVP Test - grouped", RULE_FIXED_TAIL, -1, 1, 1);
|
|
/* ABNF :
|
|
< no vendor - f32 >
|
|
< i64 >
|
|
< enumi32 >
|
|
2*3 { os }
|
|
*1 [ enumos ]
|
|
< grouped >
|
|
*/
|
|
}
|
|
}
|
|
|
|
/* Now create some values and check the length is correctly handled */
|
|
{
|
|
struct dict_object * cmd_model = NULL;
|
|
struct msg * msg = NULL;
|
|
struct dict_object * avp_model = NULL;
|
|
union avp_value value;
|
|
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Test-Command-Request", &cmd_model, ENOENT ) );
|
|
|
|
/* Check the sizes are handled properly */
|
|
{
|
|
struct avp * avpi = NULL;
|
|
struct avp * avpch = NULL;
|
|
struct msg_hdr * msgdata = NULL;
|
|
#define ADD_AVP( _parent, _position, _avpi, _avpvendor, _avpname) { \
|
|
struct dict_object * _avp = NULL; \
|
|
struct dict_avp_request _req = { (_avpvendor), 0, (_avpname) }; \
|
|
CHECK( 0, fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &_req, &_avp, ENOENT));\
|
|
CHECK( 0, fd_msg_avp_new ( _avp, 0, &_avpi ) ); \
|
|
CHECK( 0, fd_msg_avp_add ( (_parent), (_position), _avpi ) ); \
|
|
}
|
|
/* Create a message with many AVP inside */
|
|
CHECK( 0, fd_msg_new ( cmd_model, 0, &msg ) );
|
|
CHECK( 0, fd_msg_hdr ( msg, &msgdata ) );
|
|
|
|
/* Avp no vendor, float32 => size = 12 */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 0, "AVP Test - no vendor - f32" );
|
|
value.f32 = 3.1415;
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpi, &value ) );
|
|
|
|
/* Add a vendor AVP, integer64 => size = 20 */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - i64" );
|
|
value.i64 = 0x123456789abcdeLL;
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpi, &value ) );
|
|
|
|
/* Add an AVP with an enum value */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - enumi32" );
|
|
{
|
|
struct dict_object * type_model = NULL;
|
|
struct dict_object * value_model = NULL;
|
|
struct dict_enumval_request request;
|
|
|
|
CHECK( 0, fd_msg_model ( avpi, &avp_model ) );
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
|
|
memset(&request, 0, sizeof(request));
|
|
request.type_obj = type_model;
|
|
request.search.enum_name = "i32 const test (val 2)";
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
|
|
CHECK( 0, fd_dict_getval ( value_model, &request.search ) );
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpi, &request.search.enum_value ) );
|
|
}
|
|
|
|
/* Add an AVP with an enum value, negative */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - enumi32" );
|
|
{
|
|
struct dict_object * type_model = NULL;
|
|
struct dict_object * value_model = NULL;
|
|
struct dict_enumval_request request;
|
|
|
|
CHECK( 0, fd_msg_model ( avpi, &avp_model ) );
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
|
|
memset(&request, 0, sizeof(request));
|
|
request.type_obj = type_model;
|
|
request.search.enum_name = "i32 const test (val -5)";
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
|
|
CHECK( 0, fd_dict_getval ( value_model, &request.search ) );
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpi, &request.search.enum_value ) );
|
|
}
|
|
|
|
/* Now add a value which is not a constant into an enumerated AVP */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - enumi32" );
|
|
value.i32 = -10;
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpi, &value ) );
|
|
|
|
/* Add an octetstring AVP */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - os" );
|
|
{
|
|
unsigned char buf[90];
|
|
memcpy(&buf, "This\0 is a buffer of dat\a. It is not a string so we can have any c\0ntr\0l character here...\0\0", 89);
|
|
value.os.data = buf;
|
|
value.os.len = 89;
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpi, &value ) );
|
|
memset(&buf, 0, sizeof(buf)); /* Test that the OS value is really copied */
|
|
}
|
|
|
|
/* Add an octetstring from an enumerated constant */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - enumos" );
|
|
{
|
|
struct dict_object * type_model = NULL;
|
|
struct dict_object * value_model = NULL;
|
|
struct dict_enumval_request request;
|
|
|
|
CHECK( 0, fd_msg_model ( avpi, &avp_model ) );
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
|
|
memset(&request, 0, sizeof(request));
|
|
request.type_obj = type_model;
|
|
request.search.enum_name = "os const test (waaad)";
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
|
|
CHECK( 0, fd_dict_getval ( value_model, &request.search ) );
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpi, &request.search.enum_value ) );
|
|
}
|
|
|
|
/* Add an octetstring from an enumerated constant */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - enumos" );
|
|
{
|
|
struct dict_object * type_model = NULL;
|
|
struct dict_object * value_model = NULL;
|
|
struct dict_enumval_request request;
|
|
|
|
CHECK( 0, fd_msg_model ( avpi, &avp_model ) );
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_TYPE, TYPE_OF_AVP, avp_model, &type_model, ENOENT ) );
|
|
memset(&request, 0, sizeof(request));
|
|
request.type_obj = type_model;
|
|
request.search.enum_name = "os const test (waa)";
|
|
CHECK( 0, fd_dict_search ( fd_g_config->cnf_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &request, &value_model, ENOENT ) );
|
|
CHECK( 0, fd_dict_getval ( value_model, &request.search ) );
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpi, &request.search.enum_value ) );
|
|
}
|
|
|
|
/* Now test the grouped AVPs */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - grouped" );
|
|
ADD_AVP( avpi, MSG_BRW_LAST_CHILD, avpch, 73565, "AVP Test - os" );
|
|
{
|
|
value.os.data = (unsigned char *)"12345678";
|
|
value.os.len = 8;
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpch, &value ) );
|
|
}
|
|
ADD_AVP( avpi, MSG_BRW_LAST_CHILD, avpch, 73565, "AVP Test - os" );
|
|
{
|
|
value.os.data = (unsigned char *)"123456789";
|
|
value.os.len = 9;
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpch, &value ) );
|
|
}
|
|
|
|
/* Add another similar grouped AVP, to have lot of padding */
|
|
ADD_AVP( msg, MSG_BRW_LAST_CHILD, avpi, 73565, "AVP Test - grouped" );
|
|
ADD_AVP( avpi, MSG_BRW_LAST_CHILD, avpch, 73565, "AVP Test - os" );
|
|
{
|
|
value.os.data = (unsigned char *)"1";
|
|
value.os.len = 1;
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpch, &value ) );
|
|
}
|
|
ADD_AVP( avpi, MSG_BRW_LAST_CHILD, avpch, 73565, "AVP Test - os" );
|
|
{
|
|
value.os.data = (unsigned char *)"1234567";
|
|
value.os.len = 7;
|
|
CHECK( 0, fd_msg_avp_setvalue ( avpch, &value ) );
|
|
}
|
|
|
|
/* Set the application to the test application: 73566 */
|
|
msgdata->msg_appl = 73566;
|
|
|
|
/* Set the hop-by-hop ID to a random value: 0x4b44b41d */
|
|
msgdata->msg_hbhid = 0x4b44b41d;
|
|
/* Set the end-to-end ID to a random value: 0xe2ee2e1d */
|
|
msgdata->msg_eteid = 0xe2ee2e1d;
|
|
}
|
|
|
|
CHECK( 0, fd_msg_bufferize( msg, &buf, NULL ) );
|
|
|
|
LOG_D( "Test message: %s", fd_msg_dump_treeview(FD_DUMP_TEST_PARAMS, msg, NULL, 0, 1));
|
|
|
|
/* Now free the message, we keep only the buffer. */
|
|
CHECK( 0, fd_msg_free( msg ) );
|
|
|
|
}
|
|
|
|
/* We have our "buf" now, length is 344 -- cf. testmesg.c. */
|
|
redo:
|
|
/* Test the throughput of the different functions function */
|
|
{
|
|
struct stress_struct {
|
|
struct msg * m;
|
|
uint8_t * b;
|
|
} * stress_array;
|
|
int i;
|
|
struct timespec start, end;
|
|
|
|
/* Create the copies of the message buffer */
|
|
stress_array = calloc(test_parameter, sizeof(struct stress_struct));
|
|
CHECK( stress_array ? 1 : 0, 1);
|
|
|
|
for (i=0; i < test_parameter; i++) {
|
|
stress_array[i].b = malloc(344);
|
|
if (!stress_array[i].b)
|
|
break;
|
|
memcpy(stress_array[i].b, buf, 344);
|
|
}
|
|
CHECK( test_parameter, i ); /* if false, a malloc failed */
|
|
|
|
/* fd_msg_parse_buffer */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &start) );
|
|
|
|
/* Test the msg_parse_buffer function */
|
|
for (i=0; i < test_parameter; i++) {
|
|
if (0 != fd_msg_parse_buffer( &stress_array[i].b, 344, &stress_array[i].m) )
|
|
break;
|
|
}
|
|
CHECK( test_parameter, i ); /* if false, a call failed */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
|
|
display_result(test_parameter, &start, &end, "fd_msg_parse_buffer", "buffers", "parsed");
|
|
|
|
/* fd_msg_parse_dict */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &start) );
|
|
|
|
/* Test the fd_msg_parse_dict function */
|
|
for (i=0; i < test_parameter; i++) {
|
|
if (0 != fd_msg_parse_dict( stress_array[i].m, fd_g_config->cnf_dict, NULL ) )
|
|
break;
|
|
}
|
|
CHECK( test_parameter, i ); /* if false, a call failed */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
|
|
display_result(test_parameter, &start, &end, "fd_msg_parse_dict", "messages", "parsed");
|
|
|
|
|
|
/* fd_msg_parse_rules */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &start) );
|
|
|
|
/* Test the fd_msg_parse_rules function */
|
|
for (i=0; i < test_parameter; i++) {
|
|
if (0 != fd_msg_parse_rules( stress_array[i].m, fd_g_config->cnf_dict, NULL ) )
|
|
break;
|
|
}
|
|
CHECK( test_parameter, i ); /* if false, a call failed */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
|
|
display_result(test_parameter, &start, &end, "fd_msg_parse_rules", "messages", "parsed");
|
|
|
|
|
|
/* fd_msg_new_answer_from_req (0) */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &start) );
|
|
|
|
/* Test the fd_msg_new_answer_from_req function */
|
|
for (i=0; i < test_parameter; i++) {
|
|
if (0 != fd_msg_new_answer_from_req( fd_g_config->cnf_dict, &stress_array[i].m, 0 ) )
|
|
break;
|
|
}
|
|
CHECK( test_parameter, i ); /* if false, a call failed */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
|
|
display_result(test_parameter, &start, &end, "new_answer(normal)", "messages", "created");
|
|
|
|
/* unlink answers and go back to request messages */
|
|
for (i=0; i < test_parameter; i++) {
|
|
struct msg * ans = stress_array[i].m;
|
|
if (0 != fd_msg_answ_getq( ans, &stress_array[i].m ) )
|
|
break;
|
|
if (0 != fd_msg_answ_detach( ans ) )
|
|
break;
|
|
fd_msg_free( ans );
|
|
}
|
|
CHECK( test_parameter, i ); /* if false, a call failed */
|
|
|
|
|
|
/* fd_msg_new_answer_from_req (MSGFL_ANSW_ERROR) */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &start) );
|
|
|
|
/* Test the fd_msg_new_answer_from_req function */
|
|
for (i=0; i < test_parameter; i++) {
|
|
if ( 0 != fd_msg_new_answer_from_req( fd_g_config->cnf_dict, &stress_array[i].m, MSGFL_ANSW_ERROR ) )
|
|
break;
|
|
}
|
|
CHECK( test_parameter, i ); /* if false, a call failed */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
|
|
display_result(test_parameter, &start, &end, "new_answer(error)", "messages", "created");
|
|
|
|
/* unlink answers and go back to request messages */
|
|
for (i=0; i < test_parameter; i++) {
|
|
struct msg * ans = stress_array[i].m;
|
|
if (0 != fd_msg_answ_getq( ans, &stress_array[i].m ) )
|
|
break;
|
|
if (0 != fd_msg_answ_detach( ans ) )
|
|
break;
|
|
fd_msg_free( ans );
|
|
}
|
|
|
|
|
|
/* fd_msg_bufferize */
|
|
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &start) );
|
|
|
|
/* Test the fd_msg_bufferize function */
|
|
for (i=0; i < test_parameter; i++) {
|
|
size_t len = 0;
|
|
if (0 != fd_msg_bufferize( stress_array[i].m, &stress_array[i].b, &len ) )
|
|
break;
|
|
}
|
|
CHECK( test_parameter, i ); /* if false, a call failed */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
|
|
display_result(test_parameter, &start, &end, "fd_msg_bufferize", "buffers", "created");
|
|
|
|
|
|
/* fd_msg_free */
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &start) );
|
|
|
|
/* Free those messages */
|
|
for (i=0; i < test_parameter; i++) {
|
|
fd_msg_free( stress_array[i].m );
|
|
}
|
|
|
|
CHECK( 0, clock_gettime(CLOCK_REALTIME, &end) );
|
|
display_result(test_parameter, &start, &end, "fd_msg_free", "messages", "freed");
|
|
|
|
|
|
for (i=0; i < test_parameter; i++) {
|
|
free(stress_array[i].b);
|
|
}
|
|
free(stress_array);
|
|
}
|
|
|
|
if (!dictionaries_loaded) {
|
|
load_all_extensions("dict_");
|
|
dictionaries_loaded = 1;
|
|
printf("Loaded all dictionary extensions, restarting...\n");
|
|
goto redo;
|
|
}
|
|
|
|
/* That's all for the tests yet */
|
|
PASSTEST();
|
|
}
|
|
|