Navigation


Changeset 3:ef303f1078ab in freeDiameter


Ignore:
Timestamp:
Sep 2, 2009, 6:22:00 PM (12 years ago)
Author:
Sebastien Decugis <sdecugis@nict.go.jp>
Branch:
default
Phase:
public
Message:

Progress; added session module; testsess to be completed

Files:
3 added
7 edited

Legend:

Unmodified
Added
Removed
  • freeDiameter/main.c

    r1 r3  
    5151        CHECK_FCT( fd_dict_base_protocol(fd_g_dict) );
    5252       
    53         /* For debug */
    54         fd_dict_dump(fd_g_dict);
    55        
    5653        TRACE_DEBUG(INFO, "freeDiameter daemon initialized.");
    5754       
  • freeDiameter/tests/CMakeLists.txt

    r2 r3  
    1212# List the test cases
    1313SET(TEST_LIST
     14        testlist
    1415        testdict
    1516        testmesg
    1617        testmq
     18        testsess
    1719)
    1820
  • freeDiameter/tests/tests.h

    r2 r3  
    9898/* Minimum inits */
    9999#define INIT_FD() {                                     \
    100         pthread_key_create(&fd_log_thname, free);       \
     100        CHECK( 0, fd_lib_init() );                      \
    101101        fd_log_threadname(basename(__FILE__));          \
    102102        CHECK( 0, fd_dict_init(&fd_g_dict) );           \
  • include/freeDiameter/libfreeDiameter.h

    r2 r3  
    142142extern int fd_g_debug_lvl;
    143143
    144 /* helper macros (pre-processor hacks to allow macro arguments) */
    145 #define __str( arg )  #arg
    146 #define _stringize( arg ) __str( arg )
    147 #define __agr( arg1, arg2 ) arg1 ## arg2
    148 #define _aggregate( arg1, arg2 ) __agr( arg1, arg2 )
    149 
    150144/* Some portability code to get nice function name in __PRETTY_FUNCTION__ */
    151145#if __STDC_VERSION__ < 199901L
     
    286280}
    287281
    288 /****************************** Socket helpers ************************************/
     282
     283/*============================================================*/
     284/*                          MACROS                            */
     285/*============================================================*/
     286
     287/* helper macros (pre-processor hacks to allow macro arguments) */
     288#define __str( arg )  #arg
     289#define _stringize( arg ) __str( arg )
     290#define __agr( arg1, arg2 ) arg1 ## arg2
     291#define _aggregate( arg1, arg2 ) __agr( arg1, arg2 )
    289292
    290293/* Some aliases to socket addresses structures */
     
    339342        (((in_addr_t *)(a6))[3])
    340343
    341 /*
    342  * Other macros
    343  */
    344344
    345345/* We provide macros to convert 64 bit values to and from network byte-order, on systems where it is not already provided. */
     
    356356#endif /* HAVE_NTOHLL */
    357357
    358 /* This macro will pad a size to the next multiple of 4. */
     358/* This macro will give the next multiple of 4 for an integer (used for padding sizes of AVP). */
    359359#define PAD4(_x) ((_x) + ( (4 - (_x)) & 3 ) )
    360360
    361 /* Useful to display as ASCII some bytes values */
     361/* Useful to display as safe ASCII a value (will garbage UTF-8 output...) */
    362362#define ASCII(_c) ( ((_c < 32) || (_c > 127)) ? ( _c ? '?' : ' ' ) : _c )
    363363
     
    367367          || ((ts1)->tv_nsec < (ts2)->tv_nsec) )
    368368
    369 /* Some constants for dumping flags and values */
    370 #define DUMP_AVPFL_str  "%c%c"
    371 #define DUMP_AVPFL_val(_val) (_val & AVP_FLAG_VENDOR)?'V':'-' , (_val & AVP_FLAG_MANDATORY)?'M':'-'
    372 #define DUMP_CMDFL_str  "%c%c%c%c"
    373 #define DUMP_CMDFL_val(_val) (_val & CMD_FLAG_REQUEST)?'R':'-' , (_val & CMD_FLAG_PROXIABLE)?'P':'-' , (_val & CMD_FLAG_ERROR)?'E':'-' , (_val & CMD_FLAG_RETRANSMIT)?'T':'-'
    374369
    375370/*============================================================*/
     
    593588be freed automatically along with the object itself with call to dict_fini later.
    594589 
    595 - dict_new:
     590- fd_dict_new:
    596591 The "parent" parameter is not used for vendors.
    597592 Sample code to create a vendor:
     
    600595         struct dict_object * myvendor;
    601596         struct dict_vendor_data myvendordata = { 23455, "my vendor name" };  -- just an example...
    602          ret = dict_new ( DICT_VENDOR, &myvendordata, NULL, &myvendor );
     597         ret = fd_dict_new ( dict, DICT_VENDOR, &myvendordata, NULL, &myvendor );
    603598 }
    604599
    605 - dict_search:
     600- fd_dict_search:
    606601 Sample codes to look for a vendor object, by its id or name:
    607602 {
     
    609604         struct dict_object * vendor_found;
    610605         vendor_id_t vendorid = 23455;
    611          ret = dict_search ( DICT_VENDOR, VENDOR_BY_ID, &vendorid, &vendor_found, ENOENT);
     606         ret = fd_dict_search ( dict, DICT_VENDOR, VENDOR_BY_ID, &vendorid, &vendor_found, ENOENT);
    612607         - or -
    613          ret = dict_search ( DICT_VENDOR, VENDOR_BY_NAME, "my vendor name", &vendor_found, ENOENT);
     608         ret = fd_dict_search ( dict, DICT_VENDOR, VENDOR_BY_NAME, "my vendor name", &vendor_found, ENOENT);
    614609 }
    615610 
    616  - dict_getval:
     611 - fd_dict_getval:
    617612 Sample code to retrieve the data from a vendor object:
    618613 {
     
    620615         struct dict_object * myvendor;
    621616         struct dict_vendor_data myvendordata;
    622          ret = dict_search ( DICT_VENDOR, VENDOR_BY_NAME, "my vendor name", &myvendor, ENOENT);
    623          ret = dict_getval ( myvendor, &myvendordata );
     617         ret = fd_dict_search ( dict, DICT_VENDOR, VENDOR_BY_NAME, "my vendor name", &myvendor, ENOENT);
     618         ret = fd_dict_getval ( myvendor, &myvendordata );
    624619         printf("my vendor id: %d\n", myvendordata.vendor_id );
    625620 }
     
    662657The vendor associated to an application is retrieved with VENDOR_OF_APPLICATION search criteria on vendors.
    663658
    664 - dict_new:
     659- fd_dict_new:
    665660 Sample code for application creation:
    666661 {
     
    677672         };
    678673       
    679          ret = dict_new ( DICT_VENDOR, &vendor_data, NULL, &vendor );
    680          ret = dict_new ( DICT_APPLICATION, &app_data, vendor, &appl );
     674         ret = fd_dict_new ( dict, DICT_VENDOR, &vendor_data, NULL, &vendor );
     675         ret = fd_dict_new ( dict, DICT_APPLICATION, &app_data, vendor, &appl );
    681676 }
    682677
    683 - dict_search:
     678- fd_dict_search:
    684679 Sample code to retrieve the vendor of an application
    685680 {
     
    687682         struct dict_object * vendor, * appli;
    688683         
    689          ret = dict_search ( DICT_APPLICATION, APPLICATION_BY_NAME, "my vendor's application", &appli, ENOENT);
    690          ret = dict_search ( DICT_VENDOR, VENDOR_OF_APPLICATION, appli, &vendor, ENOENT);
     684         ret = fd_dict_search ( dict, DICT_APPLICATION, APPLICATION_BY_NAME, "my vendor's application", &appli, ENOENT);
     685         ret = fd_dict_search ( dict, DICT_VENDOR, VENDOR_OF_APPLICATION, appli, &vendor, ENOENT);
    691686 }
    692687 
    693  - dict_getval:
     688 - fd_dict_getval:
    694689 Sample code to retrieve the data from an application object:
    695690 {
     
    697692         struct dict_object * appli;
    698693         struct dict_application_data appl_data;
    699          ret = dict_search ( DICT_APPLICATION, APPLICATION_BY_NAME, "my vendor's application", &appli, ENOENT);
    700          ret = dict_getval ( appli, &appl_data );
     694         ret = fd_dict_search ( dict, DICT_APPLICATION, APPLICATION_BY_NAME, "my vendor's application", &appli, ENOENT);
     695         ret = fd_dict_getval ( appli, &appl_data );
    701696         printf("my application id: %s\n", appl_data.application_id );
    702697 }
     
    799794 *  API usage :
    800795
    801 - dict_new:
     796- fd_dict_new:
    802797 The "parent" parameter may point to an application object, when a type is defined by a Diameter application.
    803798 
     
    813808                 NULL
    814809                };
    815          ret = dict_new ( DICT_TYPE, &mytypedata, NULL, &mytype );
     810         ret = fd_dict_new ( dict, DICT_TYPE, &mytypedata, NULL, &mytype );
    816811 }
    817812
    818 - dict_search:
     813- fd_dict_search:
    819814 Sample code:
    820815 {
    821816         int ret;
    822817         struct dict_object * address_type;
    823          ret = dict_search ( DICT_TYPE, TYPE_BY_NAME, "Address", &address_type, ENOENT);
     818         ret = fd_dict_search ( dict, DICT_TYPE, TYPE_BY_NAME, "Address", &address_type, ENOENT);
    824819 }
    825820 
     
    860855 *  API usage :
    861856
    862 - dict_new:
     857- fd_dict_new:
    863858 The "parent" parameter must point to a derived type object.
    864859 Sample code to create a type "Boolean" with two constants "True" and "False":
     
    883878                 .enum_value.i32 = -1
    884879                };
    885          ret = dict_new ( DICT_TYPE, &type_boolean_data, NULL, &type_boolean );
    886          ret = dict_new ( DICT_ENUMVAL, &boolean_false, type_boolean, NULL );
    887          ret = dict_new ( DICT_ENUMVAL, &boolean_true , type_boolean, NULL );
     880         ret = fd_dict_new ( dict, DICT_TYPE, &type_boolean_data, NULL, &type_boolean );
     881         ret = fd_dict_new ( dict, DICT_ENUMVAL, &boolean_false, type_boolean, NULL );
     882         ret = fd_dict_new ( dict, DICT_ENUMVAL, &boolean_true , type_boolean, NULL );
    888883         
    889884 }
    890885
    891 - dict_search:
     886- fd_dict_search:
    892887 Sample code to look for a constant name, by its value:
    893888 {
     
    901896                };
    902897         
    903          ret = dict_search ( DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &boolean_by_value, &value_found, ENOENT);
     898         ret = fd_dict_search ( dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &boolean_by_value, &value_found, ENOENT);
    904899 }
    905900 
    906  - dict_getval:
     901 - fd_dict_getval:
    907902 Sample code to retrieve the data from a constant object:
    908903 {
     
    917912                };
    918913         
    919          ret = dict_search ( DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &boolean_by_value, &value_found, ENOENT);
    920          ret = dict_getval ( value_found, &boolean_data );
     914         ret = fd_dict_search ( dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &boolean_by_value, &value_found, ENOENT);
     915         ret = fd_dict_getval ( value_found, &boolean_data );
    921916         printf(" Boolean with value 0: %s", boolean_data.enum_name );
    922917 }
     
    946941#define AVP_FLAG_RESERVED8      0x01
    947942
     943/* For dumping flags and values */
     944#define DUMP_AVPFL_str  "%c%c"
     945#define DUMP_AVPFL_val(_val) (_val & AVP_FLAG_VENDOR)?'V':'-' , (_val & AVP_FLAG_MANDATORY)?'M':'-'
    948946
    949947/* Type to hold data associated to an avp */
     
    983981To create the rules (ABNF) for children of Grouped AVP, see the DICT_RULE related part.
    984982
    985 - dict_new:
     983- fd_dict_new:
    986984 Sample code for AVP creation:
    987985 {
     
    10081006       
    10091007         -- Create an AVP with a base type --
    1010          ret = dict_new ( DICT_AVP, &user_name_data, NULL, &user_name_avp );
     1008         ret = fd_dict_new ( dict, DICT_AVP, &user_name_data, NULL, &user_name_avp );
    10111009         
    10121010         -- Create an AVP with a derived type --
    1013          ret = dict_search ( DICT_TYPE, TYPE_BY_NAME, "Boolean", &boolean_type, ENOENT);
    1014          ret = dict_new ( DICT_AVP, &sample_boolean_data , boolean_type, &sample_boolean_avp );
     1011         ret = fd_dict_search ( dict, DICT_TYPE, TYPE_BY_NAME, "Boolean", &boolean_type, ENOENT);
     1012         ret = fd_dict_new ( dict, DICT_AVP, &sample_boolean_data , boolean_type, &sample_boolean_avp );
    10151013         
    10161014 }
    10171015
    1018 - dict_search:
     1016- fd_dict_search:
    10191017 Sample code to look for an AVP
    10201018 {
     
    10281026                };
    10291027         
    1030          ret = dict_search ( DICT_AVP, AVP_BY_NAME, "User-Name", &avp_username, ENOENT);
     1028         ret = fd_dict_search ( dict, DICT_AVP, AVP_BY_NAME, "User-Name", &avp_username, ENOENT);
    10311029         
    1032          ret = dict_search ( DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avpvendorboolean, &avp_sampleboolean, ENOENT);
     1030         ret = fd_dict_search ( dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avpvendorboolean, &avp_sampleboolean, ENOENT);
    10331031         
    10341032 }
    10351033 
    1036  - dict_getval:
     1034 - fd_dict_getval:
    10371035 Sample code to retrieve the data from an AVP object:
    10381036 {
     
    10401038         struct dict_object * avp_username;
    10411039         struct dict_avp_data user_name_data;
    1042          ret = dict_search ( DICT_AVP, AVP_BY_NAME, "User-Name", &avp_username, ENOENT);
    1043          ret = dict_getval ( avp_username, &user_name_data );
     1040         ret = fd_dict_search ( dict, DICT_AVP, AVP_BY_NAME, "User-Name", &avp_username, ENOENT);
     1041         ret = fd_dict_getval ( avp_username, &user_name_data );
    10441042         printf("User-Name code: %d\n", user_name_data.avp_code );
    10451043 }
     
    10701068#define CMD_FLAG_RESERVED8      0x01
    10711069
     1070/* For dumping flags and values */
     1071#define DUMP_CMDFL_str  "%c%c%c%c"
     1072#define DUMP_CMDFL_val(_val) (_val & CMD_FLAG_REQUEST)?'R':'-' , (_val & CMD_FLAG_PROXIABLE)?'P':'-' , (_val & CMD_FLAG_ERROR)?'E':'-' , (_val & CMD_FLAG_RETRANSMIT)?'T':'-'
     1073
    10721074/* Type to hold data associated to a command */
    10731075struct dict_cmd_data {
     
    10971099Note that the "Request" and "Answer" commands are two independant objects. This allows to have different rules for each.
    10981100
    1099 - dict_new:
     1101- fd_dict_new:
    11001102 Sample code for command creation:
    11011103 {
     
    11101112         };
    11111113       
    1112          ret = dict_new ( DICT_COMMAND, &ce_data, NULL, &cer );
     1114         ret = fd_dict_new (dict, DICT_COMMAND, &ce_data, NULL, &cer );
    11131115         
    11141116         ce_data.cmd_name = "Capabilities-Exchange-Answer";
    11151117         ce_data.cmd_flag_val = 0;                      // Same constraint on "R" flag, but this time it must be cleared.
    11161118
    1117          ret = dict_new ( DICT_COMMAND, &ce_data, NULL, &cea );
     1119         ret = fd_dict_new ( dict, DICT_COMMAND, &ce_data, NULL, &cea );
    11181120 }
    11191121
    1120 - dict_search:
     1122- fd_dict_search:
    11211123 Sample code to look for a command
    11221124 {
     
    11241126         struct dict_object * cer, * cea;
    11251127         command_code_t code = 257;
    1126          ret = dict_search ( DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &cer, ENOENT);
    1127          ret = dict_search ( DICT_COMMAND, CMD_BY_CODE_R, &code, &cer, ENOENT);
     1128         ret = fd_dict_search ( dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &cer, ENOENT);
     1129         ret = fd_dict_search ( dict, DICT_COMMAND, CMD_BY_CODE_R, &code, &cer, ENOENT);
    11281130 }
    11291131 
    1130  - dict_getval:
     1132 - fd_dict_getval:
    11311133 Sample code to retrieve the data from a command object:
    11321134 {
     
    11351137         struct dict_object * cea;
    11361138         struct dict_cmd_data cea_data;
    1137          ret = dict_search ( DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &cer, ENOENT);
    1138          ret = dict_search ( DICT_COMMAND, CMD_ANSWER, cer, &cea, ENOENT);
    1139          ret = dict_getval ( cea, &cea_data );
     1139         ret = fd_dict_search ( dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &cer, ENOENT);
     1140         ret = fd_dict_search ( dict, DICT_COMMAND, CMD_ANSWER, cer, &cea, ENOENT);
     1141         ret = fd_dict_getval ( cea, &cea_data );
    11401142         printf("Answer to CER: %s\n", cea_data.cmd_name );
    11411143 }
     
    11881190The "parent" parameter can not be NULL. It points to the object (grouped avp or command) to which this rule apply (i.e. for which the ABNF is defined).
    11891191
    1190 - dict_new:
     1192- fd_dict_new:
    11911193 Sample code for rule creation. Let's create the Proxy-Info grouped AVP for example.
    11921194 {
     
    12031205       
    12041206        -- Create the parent AVP
    1205         ret = dict_new ( DICT_AVP, &proxy_info_data, NULL, &proxy_info_avp );
     1207        ret = fd_dict_new ( dict, DICT_AVP, &proxy_info_data, NULL, &proxy_info_avp );
    12061208       
    12071209        -- Create the first child AVP.
    1208         ret = dict_new ( DICT_TYPE, &di_type_data, NULL, &diameteridentity_type );
    1209         ret = dict_new ( DICT_AVP, &proxy_host_data, diameteridentity_type, &proxy_host_avp );
     1210        ret = fd_dict_new ( dict, DICT_TYPE, &di_type_data, NULL, &diameteridentity_type );
     1211        ret = fd_dict_new ( dict, DICT_AVP, &proxy_host_data, diameteridentity_type, &proxy_host_avp );
    12101212       
    12111213        -- Create the other child AVP
    1212         ret = dict_new ( DICT_AVP, &proxy_state_data, NULL, &proxy_state_avp );
     1214        ret = fd_dict_new ( dict, DICT_AVP, &proxy_state_data, NULL, &proxy_state_avp );
    12131215       
    12141216        -- Now we can create the rules. Both children AVP are mandatory.
     
    12181220       
    12191221        rule_data.rule_avp = proxy_host_avp;
    1220         ret = dict_new ( DICT_RULE, &rule_data, proxy_info_avp, NULL );
     1222        ret = fd_dict_new ( dict, DICT_RULE, &rule_data, proxy_info_avp, NULL );
    12211223       
    12221224        rule_data.rule_avp = proxy_state_avp;
    1223         ret = dict_new ( DICT_RULE, &rule_data, proxy_info_avp, NULL );
     1225        ret = fd_dict_new ( dict, DICT_RULE, &rule_data, proxy_info_avp, NULL );
    12241226}
    12251227
    1226 - dict_search and dict_getval are similar to previous examples.
     1228- fd_dict_search and fd_dict_getval are similar to previous examples.
    12271229
    12281230*/
     
    12811283/*============================================================*/
    12821284
    1283 
    1284 
    1285 /*
    1286  * The libfreeDiameter does not provide a full support of the sessions state machines as described in the RFC3588.
    1287  * It only provides a basic support allowing an extension to associate some state with a session identifier, and retrieve
    1288  * this data later.
    1289  *
    1290  * A session is an opaque object, associated with a value of a Session-Id AVP.
    1291  * An extension that wants to associate data with the session must first register as session module client
    1292  * with the sess_regext function to get an identifier object (sess_reg_t).
    1293  *
    1294  * The module manages tuplets ( sess_id_t *, sess_reg_t *, void *). The following functions are used to manage these tuplets:
    1295  * sess_data_reg  : associate a pointer with a given session for a given module client.
    1296  * sess_data_dereg: removes an association.
    1297  * sess_data_get  : get the pointer associated with an association without changing it.
    1298  *
    1299  * Note that creating an association calls sess_link as a side effect, and removing the association calls sess_unlink.
    1300  *
    1301  * QUICK TUTORIAL:
    1302  *  For an extension that wants to implement a session state machine, here is a quick guide.
    1303  *
    1304  * First, the extension must define a structure to save the session state, for example appstate_t.
    1305  *
    1306  * Since the extension will use the session module, it creates a sess_reg_t by calling sess_regext.
    1307  *
    1308  * If the extension behaves as a client, it receives external events that trig the start of a new sessions.
    1309  * When such event occurs, the extension calls sess_new with the appropriate parameters to create a new session.
    1310  * It initializes an appstate_t structure with the data of this session and creates an association with sess_data_reg (%).
    1311  * Then it creates a message (application-specific) to request authentication and/or authorization for the service
    1312  * and the message is sent.
    1313  *
    1314  * Later, assuming that the extension has registered appropriate callbacks in the dispatcher module, when a message
    1315  * is received, the extension can retrieve the state of the session with the sess_data_get function.
    1316  *
    1317  * Finaly, when the extension decides to terminate the session (timer, or as result of a message exchange), it
    1318  * calls sess_data_dereg in order to destroy the binding in the daemon. When last message refering this session is freed,
    1319  * the session data is freed.
    1320  *
    1321  * (%) A this time, the extension must call sess_unlink in order to counter the effects of the sess_new function.
    1322  * This allows to have the session destroyed when no more data is associated to it.
    1323 
     1285/* Modules that want to associate a state with a Session-Id must first register a handler of this type */
     1286struct session_handler;
     1287
     1288/* This opaque structure represents a session associated with a Session-Id */
     1289struct session;
     1290
     1291/* The state information that a module associate with a session -- each module define its own data format */
     1292typedef void session_state;
     1293
     1294/*
     1295 * FUNCTION:    fd_sess_handler_create
     1296 *
     1297 * PARAMETERS:
     1298 *  handler     : location where the new handler must be stored.
     1299 *  cleanup     : a callback function that must be called when the session with associated data is destroyed.
     1300 *
     1301 * DESCRIPTION:
     1302 *  Create a new session handler. This is needed by a module to associate a state with a session object.
     1303 * The cleanup handler is called when the session timeout expires, or fd_sess_destroy is called. It must free
     1304 * the state associated with the session, and eventually trig other actions (send a STR, ...).
     1305 *
     1306 * RETURN VALUE:
     1307 *  0           : The new handler has been created.
     1308 *  EINVAL      : A parameter is invalid.
     1309 *  ENOMEM      : Not enough memory to complete the operation
     1310 */
     1311int fd_sess_handler_create_int ( struct session_handler ** handler, void (*cleanup)(char * sid, session_state * state) );
     1312/* Macro to avoid casting everywhere */
     1313#define fd_sess_handler_create( _handler, _cleanup ) \
     1314        fd_sess_handler_create_int( (_handler), (void (*)(char *, session_state *))(_cleanup) )
     1315
     1316/*
     1317 * FUNCTION:    fd_sess_handler_destroy
     1318 *
     1319 * PARAMETERS:
     1320 *  handler     : location of an handler created by fd_sess_handler_create.
     1321 *
     1322 * DESCRIPTION:
     1323 *  This destroys a session handler (typically called when an application is shutting down).
     1324 * If sessions states are registered with this handler, the cleanup callback is called on them.
     1325 *
     1326 * RETURN VALUE:
     1327 *  0           : The handler was destroyed.
     1328 *  EINVAL      : A parameter is invalid.
     1329 *  ENOMEM      : Not enough memory to complete the operation
     1330 */
     1331int fd_sess_handler_destroy ( struct session_handler ** handler );
     1332
     1333
     1334
     1335/*
     1336 * FUNCTION:    fd_sess_new
     1337 *
     1338 * PARAMETERS:
     1339 *  session       : The location where the session object will be created upon success.
     1340 *  diamId        : \0-terminated string containing a Diameter Identity.
     1341 *  opt           : Additional string. Usage is described bellow.
     1342 *  optlen        : if opt is \0-terminated, this can be 0. Otherwise, the length of opt.
     1343 *
     1344 * DESCRIPTION:
     1345 *   Create a new session object. The Session-Id string associated with this session is generated as follow:
     1346 *  If diamId parameter is provided, the string is created according to the RFC: <diamId>;<high32>;<low32>[;opt] where
     1347 *    diamId is a Diameter Identity.
     1348 *    high32 and low32 are the parts of a monotonic 64 bits counter initialized to (time, 0) at startup.
     1349 *    opt is an optional string that can be concatenated to the identifier.
     1350 *  If diamId is NULL, the string is exactly the content of opt.
     1351 *
     1352 * RETURN VALUE:
     1353 *  0           : The session is created.
     1354 *  EINVAL      : A parameter is invalid.
     1355 *  EALREADY    : A session with the same name already exists (returned in *session)
     1356 *  ENOMEM      : Not enough memory to complete the operation
     1357 */
     1358int fd_sess_new ( struct session ** session, char * diamId, char * opt, size_t optlen );
     1359
     1360/*
     1361 * FUNCTION:    fd_sess_fromsid
     1362 *
     1363 * PARAMETERS:
     1364 *  sid         : pointer to a string containing a Session-Id (UTF-8).
     1365 *  len         : length of the sid string (which does not need to be '\0'-terminated)
     1366 *  session     : On success, pointer to the session object created / retrieved.
     1367 *  new         : if not NULL, set to 1 on return if the session object has been created, 0 if it was simply retrieved.
     1368 *
     1369 * DESCRIPTION:
     1370 *   Retrieve a session object from a Session-Id string. Calling this function makes an implicit call to the
     1371 *  fd_sess_link function on the returned session. In case no session object was previously existing with this
     1372 *  id, a new object is silently created (equivalent to fd_sess_new with flag SESSION_NEW_FULL).
     1373 *
     1374 * RETURN VALUE:
     1375 *  0           : The session parameter has been updated.
     1376 *  EINVAL      : A parameter is invalid.
     1377 *  ENOMEM      : Not enough memory to complete the operation
     1378 */
     1379int fd_sess_fromsid ( char * sid, size_t len, struct session ** session, int * new);
     1380
     1381/*
     1382 * FUNCTION:    fd_sess_getsid
     1383 *
     1384 * PARAMETERS:
     1385 *  session     : Pointer to a session object.
     1386 *  sid         : On success, the location of a (\0-terminated) string is stored here.
     1387 *
     1388 * DESCRIPTION:
     1389 *   Retrieve the session identifier (Session-Id) corresponding to a session object.
     1390 *  The returned sid is an UTF-8 string terminated by \0, suitable for calls to strlen and strcpy.
     1391 *  It may be used for example to set the value of an AVP.
     1392 *  Note that the sid string is not copied, just its reference... do not free it!
     1393 *
     1394 * RETURN VALUE:
     1395 *  0           : The sid parameter has been updated.
     1396 *  EINVAL      : A parameter is invalid.
     1397 */
     1398int fd_sess_getsid ( struct session * session, char ** sid );
     1399
     1400/*
     1401 * FUNCTION:    fd_sess_settimeout
     1402 *
     1403 * PARAMETERS:
     1404 *  session     : The session for which to set the timeout.
     1405 *  timeout     : The date when the session times out.
     1406 *
     1407 * DESCRIPTION:
     1408 *   Set the lifetime for a given session object. This function may be
     1409 * called several times on the same object to update the timeout value.
     1410 *   When the timeout date is reached, the cleanup handler of each
     1411 * module that registered data with this session is called, then the
     1412 * session is cleared.
     1413 *
     1414 *   There is a possible race condition between cleanup of the session
     1415 * and use of its data; applications should ensure that they are not
     1416 * using data from a session that is about to expire / expired.
     1417 *
     1418 * RETURN VALUE:
     1419 *  0           : The session timeout has been updated.
     1420 *  EINVAL      : A parameter is invalid.
     1421 */
     1422int fd_sess_settimeout( struct session * session, const struct timespec * timeout );
     1423
     1424/*
     1425 * FUNCTION:    fd_sess_destroy
     1426 *
     1427 * PARAMETERS:
     1428 *  session     : Pointer to a session object.
     1429 *
     1430 * DESCRIPTION:
     1431 *   Destroys a session an all associated data, if any.
     1432 * Equivalent to a session timeout expired, but the effect is immediate.
     1433 *
     1434 * RETURN VALUE:
     1435 *  0           : The session no longer exists.
     1436 *  EINVAL      : A parameter is invalid.
     1437 */
     1438int fd_sess_destroy ( struct session ** session );
     1439
     1440
     1441
     1442/*
     1443 * FUNCTION:    fd_sess_state_store
     1444 *
     1445 * PARAMETERS:
     1446 *  handler     : The handler with which the state is registered.
     1447 *  session     : The session object with which the state is registered.
     1448 *  state       : An application state (opaque data) to store with the session.
     1449 *
     1450 * DESCRIPTION:
     1451 *  Stores an application state with a session. This state can later be retrieved
     1452 * with fd_sess_state_retrieve, or implicitly in the cleanup handler when the session
     1453 * is destroyed.
     1454 *
     1455 * RETURN VALUE:
     1456 *  0           : The state has been stored.
     1457 *  EINVAL      : A parameter is invalid.
     1458 *  EALREADY    : Data was already associated with this session and client.
     1459 *  ENOMEM      : Not enough memory to complete the operation
     1460 */
     1461int fd_sess_state_store ( struct session_handler * handler, struct session * session, session_state ** state );
     1462
     1463/*
     1464 * FUNCTION:    fd_sess_state_retrieve
     1465 *
     1466 * PARAMETERS:
     1467 *  handler     : The handler with which the state was registered.
     1468 *  session     : The session object with which the state was registered.
     1469 *  state       : Location where the state must be saved if it is found.
     1470 *
     1471 * DESCRIPTION:
     1472 *  Retrieves a state saved by fd_sess_state_store.
     1473 * After this function has been called, the state is no longer associated with
     1474 * the session. A new call to fd_sess_state_store must be performed in order to
     1475 * store again the data with the session.
     1476 *
     1477 * RETURN VALUE:
     1478 *  0           : *state is updated (NULL or points to the state if it was found).
     1479 *  EINVAL      : A parameter is invalid.
     1480 */
     1481int fd_sess_state_retrieve ( struct session_handler * handler, struct session * session, session_state ** state );
     1482
     1483
     1484/* For debug */
     1485void fd_sess_dump(int level, struct session * session);
     1486void fd_sess_dump_hdl(int level, struct session_handler * handler);
    13241487
    13251488
  • libfreeDiameter/CMakeLists.txt

    r2 r3  
    1313        messages.c
    1414        mqueues.c
     15        sessions.c
    1516        )
    1617
  • libfreeDiameter/init.c

    r1 r3  
    4747        }
    4848       
    49         /* Initialize the end-to-end id counter with random value as described in RFC3588 */
     49        /* Initialize the modules that need it */
    5050        fd_msg_eteid_init();
     51        CHECK_FCT( fd_sess_init() );
    5152       
    5253        return 0;
  • libfreeDiameter/libfD.h

    r2 r3  
    4545extern const char * type_base_name[];
    4646void fd_msg_eteid_init(void);
     47int fd_sess_init(void);
    4748
    4849/* Iterator on the rules of a parent object */
Note: See TracChangeset for help on using the changeset viewer.