Changeset 3:ef303f1078ab in freeDiameter
- Timestamp:
- Sep 2, 2009, 6:22:00 PM (15 years ago)
- Branch:
- default
- Phase:
- public
- Files:
-
- 3 added
- 7 edited
Legend:
- Unmodified
- Added
- Removed
-
freeDiameter/main.c
r1 r3 51 51 CHECK_FCT( fd_dict_base_protocol(fd_g_dict) ); 52 52 53 /* For debug */54 fd_dict_dump(fd_g_dict);55 56 53 TRACE_DEBUG(INFO, "freeDiameter daemon initialized."); 57 54 -
freeDiameter/tests/CMakeLists.txt
r2 r3 12 12 # List the test cases 13 13 SET(TEST_LIST 14 testlist 14 15 testdict 15 16 testmesg 16 17 testmq 18 testsess 17 19 ) 18 20 -
freeDiameter/tests/tests.h
r2 r3 98 98 /* Minimum inits */ 99 99 #define INIT_FD() { \ 100 pthread_key_create(&fd_log_thname, free);\100 CHECK( 0, fd_lib_init() ); \ 101 101 fd_log_threadname(basename(__FILE__)); \ 102 102 CHECK( 0, fd_dict_init(&fd_g_dict) ); \ -
include/freeDiameter/libfreeDiameter.h
r2 r3 142 142 extern int fd_g_debug_lvl; 143 143 144 /* helper macros (pre-processor hacks to allow macro arguments) */145 #define __str( arg ) #arg146 #define _stringize( arg ) __str( arg )147 #define __agr( arg1, arg2 ) arg1 ## arg2148 #define _aggregate( arg1, arg2 ) __agr( arg1, arg2 )149 150 144 /* Some portability code to get nice function name in __PRETTY_FUNCTION__ */ 151 145 #if __STDC_VERSION__ < 199901L … … 286 280 } 287 281 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 ) 289 292 290 293 /* Some aliases to socket addresses structures */ … … 339 342 (((in_addr_t *)(a6))[3]) 340 343 341 /*342 * Other macros343 */344 344 345 345 /* We provide macros to convert 64 bit values to and from network byte-order, on systems where it is not already provided. */ … … 356 356 #endif /* HAVE_NTOHLL */ 357 357 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). */ 359 359 #define PAD4(_x) ((_x) + ( (4 - (_x)) & 3 ) ) 360 360 361 /* Useful to display as ASCII some bytes values*/361 /* Useful to display as safe ASCII a value (will garbage UTF-8 output...) */ 362 362 #define ASCII(_c) ( ((_c < 32) || (_c > 127)) ? ( _c ? '?' : ' ' ) : _c ) 363 363 … … 367 367 || ((ts1)->tv_nsec < (ts2)->tv_nsec) ) 368 368 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':'-'374 369 375 370 /*============================================================*/ … … 593 588 be freed automatically along with the object itself with call to dict_fini later. 594 589 595 - dict_new:590 - fd_dict_new: 596 591 The "parent" parameter is not used for vendors. 597 592 Sample code to create a vendor: … … 600 595 struct dict_object * myvendor; 601 596 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 ); 603 598 } 604 599 605 - dict_search:600 - fd_dict_search: 606 601 Sample codes to look for a vendor object, by its id or name: 607 602 { … … 609 604 struct dict_object * vendor_found; 610 605 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); 612 607 - 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); 614 609 } 615 610 616 - dict_getval:611 - fd_dict_getval: 617 612 Sample code to retrieve the data from a vendor object: 618 613 { … … 620 615 struct dict_object * myvendor; 621 616 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 ); 624 619 printf("my vendor id: %d\n", myvendordata.vendor_id ); 625 620 } … … 662 657 The vendor associated to an application is retrieved with VENDOR_OF_APPLICATION search criteria on vendors. 663 658 664 - dict_new:659 - fd_dict_new: 665 660 Sample code for application creation: 666 661 { … … 677 672 }; 678 673 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 ); 681 676 } 682 677 683 - dict_search:678 - fd_dict_search: 684 679 Sample code to retrieve the vendor of an application 685 680 { … … 687 682 struct dict_object * vendor, * appli; 688 683 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); 691 686 } 692 687 693 - dict_getval:688 - fd_dict_getval: 694 689 Sample code to retrieve the data from an application object: 695 690 { … … 697 692 struct dict_object * appli; 698 693 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 ); 701 696 printf("my application id: %s\n", appl_data.application_id ); 702 697 } … … 799 794 * API usage : 800 795 801 - dict_new:796 - fd_dict_new: 802 797 The "parent" parameter may point to an application object, when a type is defined by a Diameter application. 803 798 … … 813 808 NULL 814 809 }; 815 ret = dict_new (DICT_TYPE, &mytypedata, NULL, &mytype );810 ret = fd_dict_new ( dict, DICT_TYPE, &mytypedata, NULL, &mytype ); 816 811 } 817 812 818 - dict_search:813 - fd_dict_search: 819 814 Sample code: 820 815 { 821 816 int ret; 822 817 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); 824 819 } 825 820 … … 860 855 * API usage : 861 856 862 - dict_new:857 - fd_dict_new: 863 858 The "parent" parameter must point to a derived type object. 864 859 Sample code to create a type "Boolean" with two constants "True" and "False": … … 883 878 .enum_value.i32 = -1 884 879 }; 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 ); 888 883 889 884 } 890 885 891 - dict_search:886 - fd_dict_search: 892 887 Sample code to look for a constant name, by its value: 893 888 { … … 901 896 }; 902 897 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); 904 899 } 905 900 906 - dict_getval:901 - fd_dict_getval: 907 902 Sample code to retrieve the data from a constant object: 908 903 { … … 917 912 }; 918 913 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 ); 921 916 printf(" Boolean with value 0: %s", boolean_data.enum_name ); 922 917 } … … 946 941 #define AVP_FLAG_RESERVED8 0x01 947 942 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':'-' 948 946 949 947 /* Type to hold data associated to an avp */ … … 983 981 To create the rules (ABNF) for children of Grouped AVP, see the DICT_RULE related part. 984 982 985 - dict_new:983 - fd_dict_new: 986 984 Sample code for AVP creation: 987 985 { … … 1008 1006 1009 1007 -- 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 ); 1011 1009 1012 1010 -- 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 ); 1015 1013 1016 1014 } 1017 1015 1018 - dict_search:1016 - fd_dict_search: 1019 1017 Sample code to look for an AVP 1020 1018 { … … 1028 1026 }; 1029 1027 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); 1031 1029 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); 1033 1031 1034 1032 } 1035 1033 1036 - dict_getval:1034 - fd_dict_getval: 1037 1035 Sample code to retrieve the data from an AVP object: 1038 1036 { … … 1040 1038 struct dict_object * avp_username; 1041 1039 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 ); 1044 1042 printf("User-Name code: %d\n", user_name_data.avp_code ); 1045 1043 } … … 1070 1068 #define CMD_FLAG_RESERVED8 0x01 1071 1069 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 1072 1074 /* Type to hold data associated to a command */ 1073 1075 struct dict_cmd_data { … … 1097 1099 Note that the "Request" and "Answer" commands are two independant objects. This allows to have different rules for each. 1098 1100 1099 - dict_new:1101 - fd_dict_new: 1100 1102 Sample code for command creation: 1101 1103 { … … 1110 1112 }; 1111 1113 1112 ret = dict_new (DICT_COMMAND, &ce_data, NULL, &cer );1114 ret = fd_dict_new (dict, DICT_COMMAND, &ce_data, NULL, &cer ); 1113 1115 1114 1116 ce_data.cmd_name = "Capabilities-Exchange-Answer"; 1115 1117 ce_data.cmd_flag_val = 0; // Same constraint on "R" flag, but this time it must be cleared. 1116 1118 1117 ret = dict_new (DICT_COMMAND, &ce_data, NULL, &cea );1119 ret = fd_dict_new ( dict, DICT_COMMAND, &ce_data, NULL, &cea ); 1118 1120 } 1119 1121 1120 - dict_search:1122 - fd_dict_search: 1121 1123 Sample code to look for a command 1122 1124 { … … 1124 1126 struct dict_object * cer, * cea; 1125 1127 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); 1128 1130 } 1129 1131 1130 - dict_getval:1132 - fd_dict_getval: 1131 1133 Sample code to retrieve the data from a command object: 1132 1134 { … … 1135 1137 struct dict_object * cea; 1136 1138 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 ); 1140 1142 printf("Answer to CER: %s\n", cea_data.cmd_name ); 1141 1143 } … … 1188 1190 The "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). 1189 1191 1190 - dict_new:1192 - fd_dict_new: 1191 1193 Sample code for rule creation. Let's create the Proxy-Info grouped AVP for example. 1192 1194 { … … 1203 1205 1204 1206 -- 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 ); 1206 1208 1207 1209 -- 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 ); 1210 1212 1211 1213 -- 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 ); 1213 1215 1214 1216 -- Now we can create the rules. Both children AVP are mandatory. … … 1218 1220 1219 1221 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 ); 1221 1223 1222 1224 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 ); 1224 1226 } 1225 1227 1226 - dict_search anddict_getval are similar to previous examples.1228 - fd_dict_search and fd_dict_getval are similar to previous examples. 1227 1229 1228 1230 */ … … 1281 1283 /*============================================================*/ 1282 1284 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 */ 1286 struct session_handler; 1287 1288 /* This opaque structure represents a session associated with a Session-Id */ 1289 struct session; 1290 1291 /* The state information that a module associate with a session -- each module define its own data format */ 1292 typedef 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 */ 1311 int 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 */ 1331 int 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 */ 1358 int 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 */ 1379 int 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 */ 1398 int 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 */ 1422 int 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 */ 1438 int 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 */ 1461 int 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 */ 1481 int fd_sess_state_retrieve ( struct session_handler * handler, struct session * session, session_state ** state ); 1482 1483 1484 /* For debug */ 1485 void fd_sess_dump(int level, struct session * session); 1486 void fd_sess_dump_hdl(int level, struct session_handler * handler); 1324 1487 1325 1488 -
libfreeDiameter/CMakeLists.txt
r2 r3 13 13 messages.c 14 14 mqueues.c 15 sessions.c 15 16 ) 16 17 -
libfreeDiameter/init.c
r1 r3 47 47 } 48 48 49 /* Initialize the end-to-end id counter with random value as described in RFC3588*/49 /* Initialize the modules that need it */ 50 50 fd_msg_eteid_init(); 51 CHECK_FCT( fd_sess_init() ); 51 52 52 53 return 0; -
libfreeDiameter/libfD.h
r2 r3 45 45 extern const char * type_base_name[]; 46 46 void fd_msg_eteid_init(void); 47 int fd_sess_init(void); 47 48 48 49 /* Iterator on the rules of a parent object */
Note: See TracChangeset
for help on using the changeset viewer.