Changeset 636:c23ca590fa57 in freeDiameter
- Timestamp:
- Dec 15, 2010, 6:24:33 PM (13 years ago)
- Branch:
- default
- Phase:
- public
- Files:
-
- 2 edited
-
doc/dbg_interactive.py.sample (modified) (12 diffs)
-
extensions/dbg_interactive/dbg_interactive.i (modified) (23 diffs)
Legend:
- Unmodified
- Added
- Removed
-
doc/dbg_interactive.py.sample
r635 r636 95 95 v.vendor_id = 123 96 96 v.vendor_name = "My test vendor" 97 r, my_vendor = fd_dict_new(d, DICT_VENDOR, v, None)97 my_vendor = d.new_obj(DICT_VENDOR, v) 98 98 del v 99 99 d.dump() … … 104 104 a.application_id = 99 105 105 a.application_name = "My test appl" 106 r, my_appl = fd_dict_new(d,DICT_APPLICATION, a, my_vendor)106 my_appl = d.new_obj(DICT_APPLICATION, a, my_vendor) 107 107 del a 108 108 … … 111 111 t.type_base = AVP_TYPE_INTEGER32 112 112 t.type_name = "My integer AVP" 113 r, my_type_int = fd_dict_new(d,DICT_TYPE, t, my_appl)113 my_type_int = d.new_obj(DICT_TYPE, t, my_appl) 114 114 t.type_base = AVP_TYPE_OCTETSTRING 115 115 t.type_name = "My binary buffer AVP" 116 r, my_type_os = fd_dict_new(d,DICT_TYPE, t, my_appl)116 my_type_os = d.new_obj(DICT_TYPE, t, my_appl) 117 117 del t 118 118 … … 121 121 c.enum_name = "AVP_VALUE_TROIS" 122 122 c.enum_value.i32 = 3 123 fd_dict_new(d,DICT_ENUMVAL, c, my_type_int)123 d.new_obj(DICT_ENUMVAL, c, my_type_int) 124 124 125 125 c.enum_name = "A_BUFFER_CONSTANT" 126 126 c.enum_value.os = "This is a very long AVP value that we prefer to represent as a constant" 127 127 c.enum_value.os.dump() 128 fd_dict_new(d,DICT_ENUMVAL, c, my_type_os)128 d.new_obj(DICT_ENUMVAL, c, my_type_os) 129 129 del c 130 130 … … 135 135 a.avp_flag_mask = AVP_FLAG_MANDATORY 136 136 a.avp_basetype = AVP_TYPE_INTEGER32 137 r, my_avp_int = fd_dict_new(d,DICT_AVP, a, my_type_int)137 my_avp_int = d.new_obj(DICT_AVP, a, my_type_int) 138 138 139 139 a.avp_vendor = 123 … … 142 142 a.avp_flag_val = AVP_FLAG_VENDOR 143 143 a.avp_basetype = AVP_TYPE_OCTETSTRING 144 r, my_avp_os = fd_dict_new(d,DICT_AVP, a, my_type_os)144 my_avp_os = d.new_obj(DICT_AVP, a, my_type_os) 145 145 del a 146 146 … … 151 151 c.cmd_flag_mask = CMD_FLAG_REQUEST + CMD_FLAG_PROXIABLE 152 152 c.cmd_flag_val = CMD_FLAG_REQUEST + CMD_FLAG_PROXIABLE 153 r, my_req = fd_dict_new(d,DICT_COMMAND, c, my_appl)153 my_req = d.new_obj(DICT_COMMAND, c, my_appl) 154 154 c.cmd_name = "My-Python-Answer" 155 155 c.cmd_flag_val = CMD_FLAG_PROXIABLE 156 r, my_ans = fd_dict_new(d,DICT_COMMAND, c, my_appl)156 my_ans = d.new_obj(DICT_COMMAND, c, my_appl) 157 157 del c 158 158 159 159 # Rule 160 r d= dict_rule_data()161 r d.rule_avp = my_avp_int162 r d.rule_position = RULE_REQUIRED163 r d.rule_min = -1164 r d.rule_max = -1165 r, my_rule1 = fd_dict_new(d, DICT_RULE, rd, my_req)166 r, my_rule2 = fd_dict_new(d, DICT_RULE, rd, my_ans)167 r d.rule_avp = my_avp_os168 r, my_rule3 = fd_dict_new(d, DICT_RULE, rd, my_req)169 r, my_rule4 = fd_dict_new(d, DICT_RULE, rd, my_ans)170 del r d160 r = dict_rule_data() 161 r.rule_avp = my_avp_int 162 r.rule_position = RULE_REQUIRED 163 r.rule_min = -1 164 r.rule_max = -1 165 d.new_obj(DICT_RULE, r, my_req) 166 d.new_obj(DICT_RULE, r, my_ans) 167 r.rule_avp = my_avp_os 168 d.new_obj(DICT_RULE, r, my_req) 169 d.new_obj(DICT_RULE, r, my_ans) 170 del r 171 171 172 172 d.dump() … … 178 178 gdict = cvar.fd_g_config.cnf_dict 179 179 180 r, appl = fd_dict_search ( gdict, DICT_APPLICATION, APPLICATION_BY_ID, 3, -1)181 obj.dump()182 r, avp = fd_dict_search( gdict, DICT_AVP, AVP_BY_NAME, "Origin-Host", -1)183 obj.dump()184 r, errcmd = fd_dict_get_error_cmd( gdict)185 186 data = dict_avp_data()187 fd_dict_getval(avp, data) 188 print data.avp_code 189 del data 190 191 r, t = fd_dict_gettype(appl) 180 appl = gdict.search ( DICT_APPLICATION, APPLICATION_BY_ID, 3 ) 181 appl.dump() 182 avp = gdict.search ( DICT_AVP, AVP_BY_NAME, "Origin-Host") 183 avp.dump() 184 errcmd = gdict.error_cmd() 185 186 v = avp.getval() 187 print v.avp_code 188 del v 189 190 t = avp.gettype() 191 print t 192 192 del t 193 193 194 r, dict = fd_dict_getdict(avp)194 dict = avp.getdict() 195 195 del dict 196 197 196 198 197 … … 203 202 print "Cleaning up python state for session:", sid 204 203 print "Received state:", state 204 del state 205 205 206 206 hdl = session_handler(my_cleanup) … … 208 208 del hdl 209 209 210 # Session 210 211 hdl = session_handler(my_cleanup) 211 212 213 # Session214 212 s1 = session() 215 213 s1.getsid() … … 217 215 r,s3,isnew = fd_sess_fromsid("this.is.a.full.session.id") 218 216 s4 = session("host.id", "opt.part") 219 220 217 s4.settimeout(30) # the python wrapper takes a number of seconds as parameter for simplicity 221 218 s4.dump() 222 219 223 224 # state 225 mystate = [ 34, "clah", [ 32, 12 ] ] 226 227 s4.store(hdl, mystate) 228 229 230 231 ## TODO : debug the following (segfault) 232 233 def my_cleanup(state,sid): 234 print "Cleaning up python state for session:", sid 235 print "Received state:", state 236 237 hdl = session_handler(my_cleanup) 238 s4 = session("host.id", "opt.part") 239 mystate = [ 34, "clah", [ 32, 12 ] ] 240 s4.store(hdl, mystate) 241 del hdl 242 243 220 # states 221 mystate = [ 34, "blah", [ 32, 12 ] ] 222 s1.store(hdl, mystate) 223 del mystate 224 gotstate = s1.retrieve(hdl) 225 print gotstate 226 del gotstate 227 228 229 ############# Routing ############ 230 231 rd = rt_data() 232 233 rd.add("p1.testbed.aaa", "testbed.aaa") 234 rd.add("p2.testbed.aaa", "testbed.aaa") 235 rd.add("p3.testbed.aaa", "testbed.aaa") 236 rd.add("p4.testbed.aaa", "testbed.aaa") 237 238 rd.remove("p2.testbed.aaa") 239 240 rd.error("p3.testbed.aaa", "relay.testbed.aaa", 3002) 241 242 list = rd.extract(-1) 243 list[0].dump() 244 244 245 245 … … 250 250 ######################### old stuff (need update) ###################### 251 251 252 # Routing data253 prtd = new_rt_data_pptr()254 fd_rtd_init(prtd)255 fd_rtd_candidate_add(rt_data_pptr_value(prtd), "p1.testbed.aaa", "testbed.aaa")256 fd_rtd_candidate_add(rt_data_pptr_value(prtd), "p2.testbed.aaa", "testbed.aaa")257 fd_rtd_candidate_add(rt_data_pptr_value(prtd), "p3.testbed.aaa", "testbed.aaa")258 fd_rtd_candidate_del(rt_data_pptr_value(prtd), "p2.testbed.aaa", 0)259 pcands = new_fd_list_pptr()260 fd_rtd_candidate_extract(rt_data_pptr_value(prtd), pcands, 0)261 li = fd_list_pptr_value(pcands)262 li = fd_list_next_get(li)263 c = fd_list_to_rtd_candidate(li)264 rtd_candidate_diamid_get(c)265 li = fd_list_next_get(li)266 c = fd_list_to_rtd_candidate(li)267 rtd_candidate_diamid_get(c)268 252 269 253 -
extensions/dbg_interactive/dbg_interactive.i
r635 r636 51 51 %include <typemaps.i> 52 52 53 /* Some functions are not available through the wrapper , or accessed differently*/53 /* Some functions are not available through the wrapper */ 54 54 %ignore fd_lib_init; 55 55 %ignore fd_lib_fini; 56 /* -- the following functions are better accessed differently, but we leave their definitions just in case 56 57 %ignore fd_dict_init; 57 58 %ignore fd_dict_fini; … … 64 65 %ignore fd_sess_state_store_internal; 65 66 %ignore fd_sess_state_retrieve_internal; 66 67 %ignore fd_rtd_init; 68 %ignore fd_rtd_free; 69 %ignore fd_rtd_candidate_add; 70 %ignore fd_rtd_candidate_del; 71 %ignore fd_rtd_candidate_extract; 72 %ignore fd_rtd_error_add; 73 */ 67 74 68 75 /* Inline functions seems to give problems to SWIG -- just remove the inline definition */ … … 75 82 76 83 84 /* Create a generic error handling mechanism so that functions can provoke an exception */ 85 %{ 86 /* This is not thread-safe etc. but it should work /most of the time/. */ 87 static int wrapper_errno; 88 static PyObject* wrapper_errno_py; 89 static char * wrapper_error_txt; /* if NULL, use strerror(errno) */ 90 #define DI_ERROR(code, pycode, str) { \ 91 fd_log_debug("[dbg_interactive] ERROR: %s: %s\n", __PRETTY_FUNCTION__, str ? str : strerror(code)); \ 92 wrapper_errno = code; \ 93 wrapper_errno_py = pycode; \ 94 wrapper_error_txt = str; \ 95 } 96 97 #define DI_ERROR_MALLOC \ 98 DI_ERROR(ENOMEM, PyExc_MemoryError, NULL) 99 100 %} 101 102 %exception { 103 /* reset the errno */ 104 wrapper_errno = 0; 105 /* Call the function -- it will use DI_ERROR macro in case of error */ 106 $action 107 /* Now, test for error */ 108 if (wrapper_errno) { 109 char * str = wrapper_error_txt ? wrapper_error_txt : strerror(wrapper_errno); 110 PyObject * exc = wrapper_errno_py; 111 if (!exc) { 112 switch (wrapper_errno) { 113 case ENOMEM: exc = PyExc_MemoryError; break; 114 case EINVAL: exc = PyExc_ValueError; break; 115 default: exc = PyExc_RuntimeError; 116 } 117 } 118 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 119 PyErr_SetString(exc, str); 120 SWIG_fail; 121 SWIG_PYTHON_THREAD_END_BLOCK; 122 } 123 } 124 77 125 78 126 /*********************************** … … 80 128 ***********************************/ 81 129 82 /* for fd_hash */83 130 %apply (char *STRING, size_t LENGTH) { ( char * string, size_t len ) }; 84 131 85 /* for dictionary functions */86 132 %typemap(in, numinputs=0,noblock=1) SWIGTYPE ** OUTPUT (void *temp = NULL) { 87 133 $1 = (void *)&temp; … … 90 136 %append_output(SWIG_NewPointerObj(*$1, $*1_descriptor, 0)); 91 137 } 92 %apply SWIGTYPE ** OUTPUT { struct dict_object ** ref }; 93 %apply SWIGTYPE ** OUTPUT { struct dict_object ** obj }; 94 %apply SWIGTYPE ** OUTPUT { struct dict_object ** result }; 95 %apply SWIGTYPE ** OUTPUT { struct dictionary ** dict }; /* this is for fd_dict_getdict, not fd_dict_init (use constructor) */ 138 96 139 %apply int * OUTPUT { enum dict_object_type * type }; 97 140 %apply (char *STRING, size_t LENGTH) { (char * sid, size_t len) }; 98 141 %apply SWIGTYPE ** OUTPUT { struct session ** session }; 99 142 %apply int * OUTPUT { int * new }; 143 144 /* Callbacks defined in python */ 145 %typemap(in) PyObject *PyCb { 146 if (!PyCallable_Check($input)) { 147 PyErr_SetString(PyExc_TypeError, "Need a callable object!"); 148 SWIG_fail; 149 } 150 $1 = $input; 151 } 152 153 100 154 101 155 /********************************************************* … … 121 175 li = (struct fd_list *) malloc(sizeof(struct fd_list)); 122 176 if (!li) { 123 fd_log_debug("Out of memory!\n"); 124 PyErr_SetString(PyExc_MemoryError,"Not enough memory"); 177 DI_ERROR_MALLOC; 125 178 return NULL; 126 179 } … … 153 206 int ret = fd_dict_init(&r); 154 207 if (ret != 0) { 155 fd_log_debug("Error: %s\n", strerror(ret)); 156 PyErr_SetString(PyExc_MemoryError,"Not enough memory"); 208 DI_ERROR(ret, NULL, NULL); 157 209 return NULL; 158 210 } … … 160 212 } 161 213 ~dictionary() { 162 if (self) { 163 struct dictionary *d = self; 164 int ret = fd_dict_fini(&d); 165 if (ret != 0) { 166 fd_log_debug("Error: %s\n", strerror(ret)); 167 } 168 return; 169 } 214 struct dictionary *d = self; 215 int ret = fd_dict_fini(&d); 216 if (ret != 0) { 217 DI_ERROR(ret, NULL, NULL); 218 } 219 return; 170 220 } 171 221 void dump() { 172 if ($self) { 173 fd_dict_dump($self); 174 } 222 fd_dict_dump($self); 175 223 } 176 224 PyObject * vendors_list() { 177 225 uint32_t *list = NULL, *li; 178 226 PyObject * ret; 179 if (!$self) { 180 PyErr_SetString(PyExc_SyntaxError,"dict_object cannot be created directly. Use fd_dict_new."); 181 return NULL; 182 } 227 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 183 228 ret = PyList_New(0); 184 229 list = fd_dict_get_vendorid_list($self); … … 187 232 } 188 233 free(list); 234 SWIG_PYTHON_THREAD_END_BLOCK; 189 235 return ret; 190 236 } 191 237 struct dict_object * new_obj(enum dict_object_type type, void * data, struct dict_object * parent = NULL) { 238 struct dict_object * obj = NULL; 239 int ret = fd_dict_new($self, type, data, parent, &obj); 240 if (ret != 0) { 241 DI_ERROR(ret, NULL, NULL); 242 return NULL; 243 } 244 return obj; 245 } 246 struct dict_object * search(enum dict_object_type type, int criteria, int what_by_val) { 247 struct dict_object * obj = NULL; 248 int ret = fd_dict_search ( $self, type, criteria, &what_by_val, &obj, ENOENT ); 249 if (ret != 0) { 250 DI_ERROR(ret, NULL, NULL); 251 return NULL; 252 } 253 return obj; 254 } 255 struct dict_object * search(enum dict_object_type type, int criteria, char * what_by_string) { 256 struct dict_object * obj = NULL; 257 int ret = fd_dict_search ( $self, type, criteria, what_by_string, &obj, ENOENT ); 258 if (ret != 0) { 259 DI_ERROR(ret, NULL, NULL); 260 return NULL; 261 } 262 return obj; 263 } 264 struct dict_object * search(enum dict_object_type type, int criteria, void * what) { 265 struct dict_object * obj = NULL; 266 int ret = fd_dict_search ( $self, type, criteria, what, &obj, ENOENT ); 267 if (ret != 0) { 268 DI_ERROR(ret, NULL, NULL); 269 return NULL; 270 } 271 return obj; 272 } 273 struct dict_object * error_cmd() { 274 struct dict_object * obj = NULL; 275 int ret = fd_dict_get_error_cmd ( $self, &obj ); 276 if (ret != 0) { 277 DI_ERROR(ret, NULL, NULL); 278 return NULL; 279 } 280 return obj; 281 } 192 282 } 193 283 … … 197 287 %extend dict_object { 198 288 dict_object() { 199 fd_log_debug("Error: dict_object cannot be created directly. Use fd_dict_new\n"); 200 PyErr_SetString(PyExc_SyntaxError,"dict_object cannot be created directly. Use fd_dict_new."); 289 DI_ERROR(EINVAL, PyExc_SyntaxError, "dict_object cannot be created directly. Use fd_dict_new()."); 201 290 return NULL; 202 291 } 203 292 ~dict_object() { 204 fd_log_debug("Error: dict_object cannot be destroyed directly. Destroy the parent dictionary.\n");293 DI_ERROR(EINVAL, PyExc_SyntaxError, "dict_object cannot be destroyed directly. Destroy the parent dictionary."); 205 294 return; 206 295 } 207 296 void dump() { 208 if ($self) { 209 fd_dict_dump_object($self); 210 } 211 } 212 } 213 214 /* overload the search function to allow passing integers & string criteria directly */ 215 %rename(fd_dict_search) fd_dict_search_int; 216 %inline %{ 217 int fd_dict_search_int ( struct dictionary * dict, enum dict_object_type type, int criteria, int what_by_val, struct dict_object ** result, int retval ) { 218 return fd_dict_search ( dict, type, criteria, &what_by_val, result, retval ); 219 } 220 %} 221 %rename(fd_dict_search) fd_dict_search_string; 222 %inline %{ 223 int fd_dict_search_string ( struct dictionary * dict, enum dict_object_type type, int criteria, char * what_by_string, struct dict_object ** result, int retval ) { 224 return fd_dict_search ( dict, type, criteria, what_by_string, result, retval ); 225 } 226 %} 297 fd_dict_dump_object($self); 298 } 299 enum dict_object_type gettype() { 300 enum dict_object_type t; 301 int ret = fd_dict_gettype ( $self, &t); 302 if (ret != 0) { 303 DI_ERROR(ret, NULL, NULL); 304 return 0; 305 } 306 return t; 307 } 308 struct dictionary * getdict() { 309 struct dictionary *d; 310 int ret = fd_dict_getdict ( $self, &d ); 311 if (ret != 0) { 312 DI_ERROR(ret, NULL, NULL); 313 return NULL; 314 } 315 return d; 316 } 317 /* Since casting the pointer requires intelligence, we do it here instead of giving it to SWIG */ 318 PyObject * getval() { 319 /* first, get the type */ 320 enum dict_object_type t; 321 int ret = fd_dict_gettype ( $self, &t); 322 if (ret != 0) { 323 DI_ERROR(ret, NULL, NULL); 324 return NULL; 325 } 326 switch (t) { 327 %define %GETVAL_CASE(TYPE,STRUCT) 328 case TYPE: { 329 PyObject * v = NULL; 330 struct STRUCT * data = NULL; 331 data = malloc(sizeof(struct STRUCT)); 332 if (!data) { 333 DI_ERROR_MALLOC; 334 return NULL; 335 } 336 ret = fd_dict_getval($self, data); 337 if (ret != 0) { 338 DI_ERROR(ret, NULL, NULL); 339 free(data); 340 return NULL; 341 } 342 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 343 v = SWIG_NewPointerObj((void *)data, SWIGTYPE_p_##STRUCT, SWIG_POINTER_OWN ); 344 Py_XINCREF(v); 345 SWIG_PYTHON_THREAD_END_BLOCK; 346 return v; 347 } break 348 %enddef 349 %GETVAL_CASE( DICT_VENDOR, dict_vendor_data ); 350 %GETVAL_CASE( DICT_APPLICATION, dict_application_data ); 351 %GETVAL_CASE( DICT_TYPE, dict_type_data ); 352 %GETVAL_CASE( DICT_ENUMVAL, dict_enumval_data ); 353 %GETVAL_CASE( DICT_AVP, dict_avp_data ); 354 %GETVAL_CASE( DICT_COMMAND, dict_cmd_data ); 355 %GETVAL_CASE( DICT_RULE, dict_rule_data ); 356 default: 357 DI_ERROR(EINVAL, PyExc_SystemError, "Internal error: Got invalid object type"); 358 } 359 return NULL; 360 } 361 } 362 227 363 228 364 /* The following wrapper leaks memory each time an union avp_value is assigned an octet string. … … 244 380 $self->os.data = malloc(LENGTH); 245 381 if (!$self->os.data) { 246 fd_log_debug("Out of memory!\n"); 247 PyErr_SetString(PyExc_MemoryError,"Not enough memory"); 382 DI_ERROR_MALLOC; 248 383 return; 249 384 } … … 255 390 $self->os.data = malloc(os->len); 256 391 if (!$self->os.data) { 257 fd_log_debug("Out of memory!\n"); 258 PyErr_SetString(PyExc_MemoryError,"Not enough memory"); 392 DI_ERROR_MALLOC; 259 393 return; 260 394 } … … 266 400 %extend avp_value_os { 267 401 void dump() { 268 if ($self) { 269 %#define LEN_MAX 20 270 int i, n=LEN_MAX; 271 if ($self->len < LEN_MAX) 272 n = $self->len; 273 fd_log_debug("l:%u, v:[", $self->len); 274 for (i=0; i < n; i++) 275 fd_log_debug("%02.2X", $self->data[i]); 276 fd_log_debug("] '%.*s%s'\n", n, $self->data, n == LEN_MAX ? "..." : ""); 277 } 402 %#define LEN_MAX 20 403 int i, n=LEN_MAX; 404 if ($self->len < LEN_MAX) 405 n = $self->len; 406 fd_log_debug("l:%u, v:[", $self->len); 407 for (i=0; i < n; i++) 408 fd_log_debug("%02.2X", $self->data[i]); 409 fd_log_debug("] '%.*s%s'\n", n, $self->data, n == LEN_MAX ? "..." : ""); 278 410 } 279 411 } … … 282 414 283 415 %{ 284 /* At the moment, only 1 callback is supported...*/416 /* store the python callback function here */ 285 417 static PyObject * py_cleanup_cb = NULL; 418 /* call it (might be called from a different thread than the interpreter, when session times out) */ 286 419 static void call_the_python_cleanup_callback(session_state * state, char * sid) { 287 420 PyObject *result; … … 290 423 291 424 /* Call the function */ 425 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 292 426 result = PyEval_CallFunction(py_cleanup_cb, "(Os)", state, sid); 293 294 427 Py_XDECREF(result); 428 SWIG_PYTHON_THREAD_END_BLOCK; 295 429 return; 296 430 } … … 302 436 %extend session_handler { 303 437 session_handler() { 304 fd_log_debug("Error: a cleanup callback parameter is required.\n"); 305 PyErr_SetString(PyExc_SyntaxError,"Error: a cleanup callback parameter is required.\n"); 438 DI_ERROR(EINVAL, PyExc_SyntaxError, "a cleanup callback parameter is required."); 306 439 return NULL; 307 440 } 308 session_handler(PyObject * PyC leanupCb) {441 session_handler(PyObject * PyCb) { 309 442 struct session_handler * hdl = NULL; 310 443 int ret; 311 444 if (py_cleanup_cb) { 312 fd_log_debug("dbg_interactive supports only 1 session handler in python at the moment\n"); 313 PyErr_SetString(PyExc_SyntaxError,"dbg_interactive supports only 1 session handler in python at the moment\n"); 314 return NULL; 315 } 316 if (!PyCallable_Check(PyCleanupCb)) { 317 PyErr_SetString(PyExc_TypeError, "Need a callable object!"); 318 return NULL; 319 } 320 py_cleanup_cb = PyCleanupCb; 445 DI_ERROR(EINVAL, PyExc_SyntaxError, "Only one session handler at a time is supported at the moment in this extension\n."); 446 return NULL; 447 } 448 py_cleanup_cb = PyCb; 321 449 Py_XINCREF(py_cleanup_cb); 322 450 323 451 ret = fd_sess_handler_create_internal ( &hdl, call_the_python_cleanup_callback ); 324 452 if (ret != 0) { 325 fd_log_debug("Error: %s\n", strerror(ret)); 326 PyErr_SetString(PyExc_MemoryError,"Not enough memory"); 453 DI_ERROR(ret, NULL, NULL); 327 454 return NULL; 328 455 } … … 330 457 } 331 458 ~session_handler() { 332 if (self) { 333 struct session_handler * hdl = self; 334 int ret = fd_sess_handler_destroy(&hdl); 335 if (ret != 0) { 336 fd_log_debug("Error: %s\n", strerror(ret)); 337 } 338 return; 339 } 459 struct session_handler * hdl = self; 460 int ret = fd_sess_handler_destroy(&hdl); 461 if (ret != 0) { 462 DI_ERROR(ret, NULL, NULL); 463 } 464 /* Now free the callback */ 465 Py_XDECREF(py_cleanup_cb); 466 py_cleanup_cb = NULL; 467 return; 340 468 } 341 469 void dump() { 342 if ($self) { 343 fd_sess_dump_hdl(0, $self); 344 } 470 fd_sess_dump_hdl(0, $self); 345 471 } 346 472 } … … 356 482 ret = fd_sess_new(&s, fd_g_config->cnf_diamid, "dbg_interactive", sizeof("dbg_interactive")); 357 483 if (ret != 0) { 358 fd_log_debug("Error: %s\n", strerror(ret)); 359 PyErr_SetString(PyExc_MemoryError,"Not enough memory"); 484 DI_ERROR(ret, NULL, NULL); 360 485 return NULL; 361 486 } … … 367 492 ret = fd_sess_new(&s, diamid, STRING, LENGTH); 368 493 if (ret != 0) { 369 fd_log_debug("Error: %s\n", strerror(ret)); 370 PyErr_SetString(PyExc_MemoryError,"Not enough memory"); 494 DI_ERROR(ret, NULL, NULL); 371 495 return NULL; 372 496 } … … 378 502 ret = fd_sess_fromsid(STRING, LENGTH, &s, &n); 379 503 if (ret != 0) { 380 fd_log_debug("Error: %s\n", strerror(ret)); 381 PyErr_SetString(PyExc_MemoryError,"Not enough memory"); 504 DI_ERROR(ret, NULL, NULL); 382 505 return NULL; 383 506 } 384 507 /* When defining n as OUTPUT parameter, we get something strange... Use fd_sess_fromsid if you need it */ 508 #if 0 385 509 if (n) { 386 510 fd_log_debug("A new session has been created\n"); … … 388 512 fd_log_debug("A session with same id already existed\n"); 389 513 } 514 #endif /* 0 */ 515 390 516 return s; 391 517 } 392 518 ~session() { 393 if (self) { 394 struct session * s = self; 395 int ret = fd_sess_reclaim(&s); 396 if (ret != 0) { 397 fd_log_debug("Error: %s\n", strerror(ret)); 398 } 399 return; 400 } 519 struct session * s = self; 520 int ret = fd_sess_reclaim(&s); 521 if (ret != 0) { 522 DI_ERROR(ret, NULL, NULL); 523 } 524 return; 401 525 } 402 526 char * getsid() { 403 527 int ret; 404 528 char * sid = NULL; 405 if (!$self)406 return NULL;407 529 ret = fd_sess_getsid( $self, &sid); 408 530 if (ret != 0) { 409 fd_log_debug("Error: %s\n", strerror(ret)); 410 PyErr_SetString(PyExc_MemoryError,"Problem..."); 531 DI_ERROR(ret, NULL, NULL); 411 532 return NULL; 412 533 } … … 420 541 ret = fd_sess_settimeout( $self, &timeout ); 421 542 if (ret != 0) { 422 fd_log_debug("Error: %s\n", strerror(ret)); 423 PyErr_SetString(PyExc_MemoryError,"Problem..."); 543 DI_ERROR(ret, NULL, NULL); 424 544 } 425 545 } 426 546 void dump() { 427 if ($self) { 428 fd_sess_dump(0, $self); 429 } 547 fd_sess_dump(0, $self); 430 548 } 431 549 void store(struct session_handler * handler, PyObject * state) { 432 550 int ret; 433 551 void * store = state; 434 Py_ INCREF(state);552 Py_XINCREF(state); 435 553 ret = fd_sess_state_store_internal(handler, $self, (void *) &store); 436 554 if (ret != 0) { 437 fd_log_debug("Error: %s\n", strerror(ret)); 438 PyErr_SetString(PyExc_MemoryError,"Problem..."); 555 DI_ERROR(ret, NULL, NULL); 439 556 } 440 557 } … … 444 561 ret = fd_sess_state_retrieve_internal(handler, $self, (void *) &state); 445 562 if (ret != 0) { 446 fd_log_debug("Error: %s\n", strerror(ret));447 PyErr_SetString(PyExc_MemoryError,"Problem...");563 DI_ERROR(ret, NULL, NULL); 564 return NULL; 448 565 } 449 566 if (state == NULL) { 567 Py_INCREF(Py_None); 450 568 return Py_None; 451 569 } 452 Py_DECREF(state);453 570 return state; 454 571 } 455 572 } 456 573 574 /****** ROUTING *********/ 575 576 struct rt_data { 577 }; 578 579 %extend rt_data { 580 rt_data() { 581 struct rt_data * r = NULL; 582 int ret = fd_rtd_init(&r); 583 if (ret != 0) { 584 DI_ERROR(ret, NULL, NULL); 585 return NULL; 586 } 587 return r; 588 } 589 ~rt_data() { 590 struct rt_data *r = self; 591 fd_rtd_free(&r); 592 } 593 void add(char * peerid, char * realm) { 594 int ret = fd_rtd_candidate_add($self, peerid, realm); 595 if (ret != 0) { 596 DI_ERROR(ret, NULL, NULL); 597 } 598 } 599 void remove(char * STRING, size_t LENGTH) { 600 fd_rtd_candidate_del($self, STRING, LENGTH); 601 } 602 void error(char * dest, char * STRING, size_t LENGTH, uint32_t rcode) { 603 int ret = fd_rtd_error_add($self, dest, (uint8_t *)STRING, LENGTH, rcode); 604 if (ret != 0) { 605 DI_ERROR(ret, NULL, NULL); 606 } 607 } 608 struct fd_list * extract_li(int score = 0) { 609 struct fd_list * li = NULL; 610 fd_rtd_candidate_extract($self, &li, score); 611 return li; 612 } 613 PyObject * extract(int score = 0) { 614 struct fd_list * list = NULL, *li; 615 PyObject * rl; 616 fd_rtd_candidate_extract($self, &list, score); 617 rl = PyList_New(0); 618 SWIG_PYTHON_THREAD_BEGIN_BLOCK; 619 for (li = list->next; li != list; li = li->next) { 620 PyList_Append(rl, SWIG_NewPointerObj((void *)li, SWIGTYPE_p_rtd_candidate, 0 )); 621 } 622 Py_XINCREF(rl); 623 SWIG_PYTHON_THREAD_END_BLOCK; 624 625 return rl; 626 } 627 } 628 629 %extend rtd_candidate { 630 void dump() { 631 fd_log_debug("candidate %p\n", $self); 632 fd_log_debug(" id : %s\n", $self->diamid); 633 fd_log_debug(" rlm: %s\n", $self->realm); 634 fd_log_debug(" sc : %d\n", $self->score); 635 } 636 } 637 457 638 458 639 459 640 /****** MESSAGES *********/ 641 642 struct msg { 643 }; 644 645 %extend msg { 646 msg() { 647 DI_ERROR(EINVAL, PyExc_SyntaxError, "A DICT_COMMAND object parameter (or None) is required."); 648 return NULL; 649 } 650 msg(struct dict_object * model, int flags = MSGFL_ALLOC_ETEID) { 651 struct msg * m = NULL; 652 int ret = fd_msg_new( model, flags, &m); 653 if (ret != 0) { 654 DI_ERROR(ret, NULL, NULL); 655 } 656 return m; 657 } 658 ~msg() { 659 int ret = fd_msg_free($self); 660 if (ret != 0) { 661 DI_ERROR(ret, NULL, NULL); 662 } 663 } 664 %newobject create_answer; 665 struct msg * create_answer(struct dictionary * dict = NULL, int flags = 0) { 666 /* if dict is not provided, attempt to get it from the request model */ 667 struct dictionary * d = dict; 668 struct msg * m = $self; 669 int ret; 670 if (!d) { 671 struct dict_object * mo = NULL; 672 ret = fd_msg_model($self, &mo); 673 if (ret != 0) { 674 DI_ERROR(ret, NULL, "Cannot guess the dictionary to use, please provide it as parameter."); 675 return NULL; 676 } 677 ret = fd_dict_getdict ( mo, &d ); 678 if (ret != 0) { 679 DI_ERROR(ret, NULL, "Cannot guess the dictionary to use, please provide it as parameter."); 680 return NULL; 681 } 682 } 683 ret = fd_msg_new_answer_from_req(d, &m, flags); 684 if (ret != 0) { 685 DI_ERROR(ret, NULL, "Cannot guess the dictionary to use, please provide it as parameter."); 686 return NULL; 687 } 688 return m; 689 } 690 } 691 692 struct avp { 693 }; 694 695 %extend avp { 696 avp() { 697 DI_ERROR(EINVAL, PyExc_SyntaxError, "A DICT_AVP object parameter (or None) is required."); 698 return NULL; 699 } 700 avp(struct dict_object * model, int flags = 0) { 701 struct avp * a = NULL; 702 int ret = fd_msg_avp_new( model, flags, &a); 703 if (ret != 0) { 704 DI_ERROR(ret, NULL, NULL); 705 } 706 return a; 707 } 708 ~avp() { 709 int ret = fd_msg_free($self); 710 if (ret != 0) { 711 DI_ERROR(ret, NULL, NULL); 712 } 713 } 714 } 715 716 460 717 461 718
Note: See TracChangeset
for help on using the changeset viewer.
