Эхлэл Бүгдийг харах Тусламж
Нэвтрэх
Kamailio
/
kamailio-docs
-ын хуулбар https://github.com/kamailio/kamailio-docs.git
2
0
Салаа 0
Файлууд Асуудлууд 0 Мэдлэгийн сан
Мод: 4ca5588759
Салаанууд Тагууд
kamailio-docs
/
kamailio-kemi-framework
/
docs
/
modules.md

modules.md 426 KB
Түүх Анхны өгөгдөл

KEMI Module Functions

The following sections list all exported KEMI functions. More information regarding a function can be found by clicking the KEMI prototype, which will take you to the original module's documentation.

Because the native kamailio.cfg scripting language allows variadic functions, but exports to KEMI are functions with fixed number of parameters, there can be a group of KEMI functions to offer the capabilities of a single kamailio.cfg function. In such case, the KEMI functions share a common naming prefix, usually the name of the kamailio.cfg function.

For example, the kamailio.cfg function ds_is_from_list(...) from dispatcher module has the prototype:

int ds_is_from_list([groupid [, mode [, uri] ] ])

And the corresponding KEMI exports are:

int KSR.dispatcher.ds_is_from_lists();
int KSR.dispatcher.ds_is_from_list(int groupid);
int KSR.dispatcher.ds_is_from_list_mode(int groupid, int mode);
int KSR.dispatcher.ds_is_from_list_uri(int groupid, int mode, str "uri");

acc

The functions exported by acc module to KEMI are listed in the next sections.

Exported functions:

KSR.acc.acc_db_request()

int KSR.acc.acc_db_request(str "comment", str "dbtable");

Equivalent of native kamailio.cfg function: acc_db_request("comment", "dbtable").

KSR.acc.acc_log_request()

int KSR.acc.acc_log_request(str "comment");

Equivalent of native kamailio.cfg function: acc_log_request("comment").

KSR.acc.acc_request()

int KSR.acc.acc_request(str "comment", str "dbtable");

Equivalent of native kamailio.cfg function: acc_request("comment", "dbtable").

acc_radius

Exported functions:

KSR.acc_radius.request()

int KSR.acc_radius.request(str "comment");

alias_db

Exported functions:

KSR.alias_db.lookup()

int KSR.alias_db.lookup(str "stable");

KSR.alias_db.lookup_ex()

int KSR.alias_db.lookup_ex(str "stable", str "sflags");

app_jsdt

Exported functions:

KSR.app_jsdt.dofile()

int KSR.app_jsdt.dofile(str "script");

KSR.app_jsdt.dostring()

int KSR.app_jsdt.dostring(str "script");

KSR.app_jsdt.run()

int KSR.app_jsdt.run(str "func");

KSR.app_jsdt.run_p1()

int KSR.app_jsdt.run_p1(str "func", str "p1");

KSR.app_jsdt.run_p2()

int KSR.app_jsdt.run_p2(str "func", str "p1", str "p2");

KSR.app_jsdt.run_p3()

int KSR.app_jsdt.run_p3(str "func", str "p1", str "p2", str "p3");

KSR.app_jsdt.runstring()

int KSR.app_jsdt.runstring(str "script");

app_lua

Exported functions:

KSR.app_lua.dofile()

int KSR.app_lua.dofile(str "script");

KSR.app_lua.dostring()

int KSR.app_lua.dostring(str "script");

KSR.app_lua.run()

int KSR.app_lua.run(str "func");

KSR.app_lua.run_p1()

int KSR.app_lua.run_p1(str "func", str "p1");

KSR.app_lua.run_p2()

int KSR.app_lua.run_p2(str "func", str "p1", str "p2");

KSR.app_lua.run_p3()

int KSR.app_lua.run_p3(str "func", str "p1", str "p2", str "p3");

KSR.app_lua.runstring()

int KSR.app_lua.runstring(str "script");

app_python

Exported functions:

KSR.app_python.exec()

int KSR.app_python.exec(str "method");

KSR.app_python.exec_p1()

int KSR.app_python.exec_p1(str "method", str "p1");

KSR.app_python.execx()

int KSR.app_python.execx(str "method");

app_python3

Exported functions:

KSR.app_python3.exec()

int KSR.app_python3.exec(str "method");

KSR.app_python3.exec_p1()

int KSR.app_python3.exec_p1(str "method", str "p1");

KSR.app_python3.execx()

int KSR.app_python3.execx(str "method");

app_python3s

Exported functions:

KSR.app_python3s.exec()

int KSR.app_python3s.exec(str "method");

KSR.app_python3s.exec_p1()

int KSR.app_python3s.exec_p1(str "method", str "p1");

KSR.app_python3s.execx()

int KSR.app_python3s.execx(str "method");

app_ruby

Exported functions:

KSR.app_ruby.run()

int KSR.app_ruby.run(str "func");

KSR.app_ruby.run_p1()

int KSR.app_ruby.run_p1(str "func", str "p1");

KSR.app_ruby.run_p2()

int KSR.app_ruby.run_p2(str "func", str "p1", str "p2");

KSR.app_ruby.run_p3()

int KSR.app_ruby.run_p3(str "func", str "p1", str "p2", str "p3");

async

Exported functions:

KSR.async.get_data()

xval KSR.async.get_data();

KSR.async.get_gname()

xval KSR.async.get_gname();

KSR.async.ms_route()

int KSR.async.ms_route(str "rn", int s);

KSR.async.route()

int KSR.async.route(str "rn", int s);

KSR.async.task_data()

int KSR.async.task_data(str "rn", str "sdata");

KSR.async.task_group_data()

int KSR.async.task_group_data(str "rn", str "gn", str "sdata");

KSR.async.task_group_route()

int KSR.async.task_group_route(str "rn", str "gn");

KSR.async.task_route()

int KSR.async.task_route(str "rn");

auth

Exported functions:

KSR.auth.auth_algorithm()

int KSR.auth.auth_algorithm(str "alg");

KSR.auth.auth_challenge()

int KSR.auth.auth_challenge(str "realm", int flags);

KSR.auth.auth_get_www_authenticate()

int KSR.auth.auth_get_www_authenticate(str "realm", int flags, str "pvdst");

KSR.auth.consume_credentials()

int KSR.auth.consume_credentials();

KSR.auth.has_credentials()

int KSR.auth.has_credentials(str "srealm");

KSR.auth.proxy_challenge()

int KSR.auth.proxy_challenge(str "realm", int flags);

KSR.auth.pv_auth_check()

int KSR.auth.pv_auth_check(str "srealm", str "spasswd", int vflags, int vchecks);

KSR.auth.pv_proxy_authenticate()

int KSR.auth.pv_proxy_authenticate(str "realm", str "passwd", int flags);

KSR.auth.pv_www_authenticate()

int KSR.auth.pv_www_authenticate(str "realm", str "passwd", int flags);

KSR.auth.pv_www_authenticate_method()

int KSR.auth.pv_www_authenticate_method(str "realm", str "passwd", int flags, str "method");

KSR.auth.www_challenge()

int KSR.auth.www_challenge(str "realm", int flags);

auth_db

Exported functions:

KSR.auth_db.auth_check()

int KSR.auth_db.auth_check(str "srealm", str "stable", int iflags);

KSR.auth_db.is_subscriber()

int KSR.auth_db.is_subscriber(str "suri", str "stable", int iflags);

KSR.auth_db.www_authenticate()

int KSR.auth_db.www_authenticate(str "realm", str "table");

KSR.auth_db.www_authenticate_method()

int KSR.auth_db.www_authenticate_method(str "realm", str "table", str "method");

auth_ephemeral

Exported functions:

KSR.auth_ephemeral.autheph_authenticate()

int KSR.auth_ephemeral.autheph_authenticate(str "susername", str "spassword");

KSR.auth_ephemeral.autheph_check()

int KSR.auth_ephemeral.autheph_check(str "srealm");

KSR.auth_ephemeral.autheph_proxy()

int KSR.auth_ephemeral.autheph_proxy(str "srealm");

KSR.auth_ephemeral.autheph_www()

int KSR.auth_ephemeral.autheph_www(str "srealm");

KSR.auth_ephemeral.autheph_www_method()

int KSR.auth_ephemeral.autheph_www_method(str "srealm", str "smethod");

auth_radius

Exported functions:

KSR.auth_radius.proxy_authorize()

int KSR.auth_radius.proxy_authorize(str "srealm");

KSR.auth_radius.proxy_authorize_user()

int KSR.auth_radius.proxy_authorize_user(str "srealm", str "suser");

KSR.auth_radius.www_authorize()

int KSR.auth_radius.www_authorize(str "srealm");

KSR.auth_radius.www_authorize_user()

int KSR.auth_radius.www_authorize_user(str "srealm", str "suser");

auth_xkeys

Exported functions:

KSR.auth_xkeys.auth_xkeys_add()

int KSR.auth_xkeys.auth_xkeys_add(str "shdr", str "skey", str "salg", str "sdata");

KSR.auth_xkeys.auth_xkeys_check()

int KSR.auth_xkeys.auth_xkeys_check(str "shdr", str "skey", str "salg", str "sdata");

avpops

Exported functions:

KSR.avpops.avp_check()

int KSR.avpops.avp_check(str "param", str "check");

KSR.avpops.avp_copy()

int KSR.avpops.avp_copy(str "name1", str "name2");

benchmark

Exported functions:

KSR.benchmark.bm_log_timer()

int KSR.benchmark.bm_log_timer(str "tname");

KSR.benchmark.bm_start_timer()

int KSR.benchmark.bm_start_timer(str "tname");

blst

Exported functions:

KSR.blst.blst_add()

int KSR.blst.blst_add(int t);

KSR.blst.blst_add_default()

int KSR.blst.blst_add_default();

KSR.blst.blst_add_retry_after()

int KSR.blst.blst_add_retry_after(int t_min, int t_max);

KSR.blst.blst_clear_ignore()

int KSR.blst.blst_clear_ignore(int mask);

KSR.blst.blst_clear_ignore_all()

int KSR.blst.blst_clear_ignore_all();

KSR.blst.blst_del()

int KSR.blst.blst_del();

KSR.blst.blst_is_blocklisted()

int KSR.blst.blst_is_blocklisted();

KSR.blst.blst_rpl_clear_ignore()

int KSR.blst.blst_rpl_clear_ignore(int mask);

KSR.blst.blst_rpl_clear_ignore_all()

int KSR.blst.blst_rpl_clear_ignore_all();

KSR.blst.blst_rpl_set_ignore()

int KSR.blst.blst_rpl_set_ignore(int mask);

KSR.blst.blst_rpl_set_ignore_all()

int KSR.blst.blst_rpl_set_ignore_all();

KSR.blst.blst_set_ignore()

int KSR.blst.blst_set_ignore(int mask);

KSR.blst.blst_set_ignore_all()

int KSR.blst.blst_set_ignore_all();

call_control

Exported functions:

KSR.call_control.call_control()

int KSR.call_control.call_control();

call_obj

Exported functions:

KSR.call_obj.free()

int KSR.call_obj.free(int num_obj);

KSR.call_obj.get()

int KSR.call_obj.get();

carrierroute

Exported functions:

KSR.carrierroute.cr_next_domain()

int KSR.carrierroute.cr_next_domain(str "_carrier", str "_domain", str "_prefix_matching", str "_host", str "_reply_code", str "_dstavp");

KSR.carrierroute.cr_nofallback_route()

int KSR.carrierroute.cr_nofallback_route(str "_carrier", str "_domain", str "_prefix_matching", str "_rewrite_user", str "_hsrc");

KSR.carrierroute.cr_nofallback_route_info()

int KSR.carrierroute.cr_nofallback_route_info(str "_carrier", str "_domain", str "_prefix_matching", str "_rewrite_user", str "_hsrc", str "_dstvar");

KSR.carrierroute.cr_route()

int KSR.carrierroute.cr_route(str "_carrier", str "_domain", str "_prefix_matching", str "_rewrite_user", str "_hsrc");

KSR.carrierroute.cr_route_info()

int KSR.carrierroute.cr_route_info(str "_carrier", str "_domain", str "_prefix_matching", str "_rewrite_user", str "_hsrc", str "_dstvar");

KSR.carrierroute.cr_user_carrier()

int KSR.carrierroute.cr_user_carrier(str "user", str "domain", str "dstvar");

cdp

Exported functions:

KSR.cdp.cdp_check_peer()

int KSR.cdp.cdp_check_peer(str "peer");

KSR.cdp.cdp_has_app()

int KSR.cdp.cdp_has_app(str "appid");

KSR.cdp.cdp_has_app2()

int KSR.cdp.cdp_has_app2(str "vendor", str "appid");

cfgutils

Exported functions:

KSR.cfgutils.abort()

int KSR.cfgutils.abort();

KSR.cfgutils.check_route_exists()

int KSR.cfgutils.check_route_exists(str "route");

KSR.cfgutils.core_hash()

int KSR.cfgutils.core_hash(str "s1", str "s2", int sz);

KSR.cfgutils.lock()

int KSR.cfgutils.lock(str "lkey");

KSR.cfgutils.lock_key2()

int KSR.cfgutils.lock_key2(str "lkey", str "lkey2");

KSR.cfgutils.pkg_status()

int KSR.cfgutils.pkg_status();

KSR.cfgutils.pkg_summary()

int KSR.cfgutils.pkg_summary();

KSR.cfgutils.rand_event()

int KSR.cfgutils.rand_event();

KSR.cfgutils.rand_get_prob()

int KSR.cfgutils.rand_get_prob();

KSR.cfgutils.rand_reset_prob()

int KSR.cfgutils.rand_reset_prob();

KSR.cfgutils.rand_set_prob()

int KSR.cfgutils.rand_set_prob(int percent_par);

KSR.cfgutils.route_if_exists()

int KSR.cfgutils.route_if_exists(str "route");

KSR.cfgutils.shm_status()

int KSR.cfgutils.shm_status();

KSR.cfgutils.shm_summary()

int KSR.cfgutils.shm_summary();

KSR.cfgutils.sleep()

int KSR.cfgutils.sleep(int v);

KSR.cfgutils.trylock()

int KSR.cfgutils.trylock(str "lkey");

KSR.cfgutils.trylock_key2()

int KSR.cfgutils.trylock_key2(str "lkey", str "lkey2");

KSR.cfgutils.unlock()

int KSR.cfgutils.unlock(str "lkey");

KSR.cfgutils.unlock_key2()

int KSR.cfgutils.unlock_key2(str "lkey", str "lkey2");

KSR.cfgutils.usleep()

int KSR.cfgutils.usleep(int v);

cnxcc

Exported functions:

KSR.cnxcc.get_channel_count()

int KSR.cnxcc.get_channel_count(str "sclient", str "pvname");

KSR.cnxcc.set_max_channels()

int KSR.cnxcc.set_max_channels(str "sclient", int max_chan);

KSR.cnxcc.set_max_credit()

int KSR.cnxcc.set_max_credit(str "sclient", str "scredit", str "sconnect", str "scps", int initp, int finishp);

KSR.cnxcc.set_max_time()

int KSR.cnxcc.set_max_time(str "sclient", int max_secs);

KSR.cnxcc.terminate_all()

int KSR.cnxcc.terminate_all(str "sclient");

KSR.cnxcc.update_max_time()

int KSR.cnxcc.update_max_time(str "sclient", int secs);

corex

Exported functions:

KSR.corex.append_branch()

int KSR.corex.append_branch();

KSR.corex.append_branch_uri()

int KSR.corex.append_branch_uri(str "uri");

KSR.corex.append_branch_uri_q()

int KSR.corex.append_branch_uri_q(str "uri", str "q");

KSR.corex.file_read()

xval KSR.corex.file_read(str "fname");

KSR.corex.file_write()

int KSR.corex.file_write(str "fname", str "fdata");

KSR.corex.forward_uac()

int KSR.corex.forward_uac();

KSR.corex.forward_uac_uri()

int KSR.corex.forward_uac_uri(str "vuri");

KSR.corex.has_ruri_user()

int KSR.corex.has_ruri_user();

KSR.corex.has_user_agent()

int KSR.corex.has_user_agent();

KSR.corex.is_faked_msg()

int KSR.corex.is_faked_msg();

KSR.corex.is_socket_name()

int KSR.corex.is_socket_name(str "sockname");

KSR.corex.isxflagset()

int KSR.corex.isxflagset(int fval);

KSR.corex.resetxflag()

int KSR.corex.resetxflag(int fval);

KSR.corex.send_data()

int KSR.corex.send_data(str "uri", str "data");

KSR.corex.sendx()

int KSR.corex.sendx(str "uri", str "sock", str "data");

KSR.corex.set_recv_socket()

int KSR.corex.set_recv_socket(str "ssock");

KSR.corex.set_recv_socket_name()

int KSR.corex.set_recv_socket_name(str "ssock");

KSR.corex.set_send_socket()

int KSR.corex.set_send_socket(str "ssock");

KSR.corex.set_send_socket_name()

int KSR.corex.set_send_socket_name(str "ssock");

KSR.corex.set_source_address()

int KSR.corex.set_source_address(str "saddr");

KSR.corex.setxflag()

int KSR.corex.setxflag(int fval);

KSR.corex.via_add_srvid()

int KSR.corex.via_add_srvid(int fval);

KSR.corex.via_add_xavp_params()

int KSR.corex.via_add_xavp_params(int fval);

KSR.corex.via_reply_add_xavp_params()

int KSR.corex.via_reply_add_xavp_params(int fval);

KSR.corex.via_use_xavp_fields()

int KSR.corex.via_use_xavp_fields(int fval);

counters

Exported functions:

KSR.counters.add()

int KSR.counters.add(str "sname", int v);

KSR.counters.inc()

int KSR.counters.inc(str "sname");

KSR.counters.reset()

int KSR.counters.reset(str "sname");

crypto

Exported functions:

KSR.crypto.aes_decrypt()

int KSR.crypto.aes_decrypt(str "ins", str "keys", str "dpv");

KSR.crypto.aes_encrypt()

int KSR.crypto.aes_encrypt(str "ins", str "keys", str "dpv");

KSR.crypto.hmac_sha256()

int KSR.crypto.hmac_sha256(str "ins", str "keys", str "dpv");

debugger

Exported functions:

KSR.debugger.dbg_pv_dump()

int KSR.debugger.dbg_pv_dump();

KSR.debugger.dbg_pv_dump_ex()

int KSR.debugger.dbg_pv_dump_ex(int mask, int level);

dialog

Exported functions:

KSR.dialog.dlg_bridge()

int KSR.dialog.dlg_bridge(str "sfrom", str "sto", str "soproxy");

KSR.dialog.dlg_bye()

int KSR.dialog.dlg_bye(str "side");

KSR.dialog.dlg_db_load_callid()

int KSR.dialog.dlg_db_load_callid(str "callid");

KSR.dialog.dlg_db_load_extra()

int KSR.dialog.dlg_db_load_extra();

KSR.dialog.dlg_get()

int KSR.dialog.dlg_get(str "sc", str "sf", str "st");

KSR.dialog.dlg_get_var()

xval KSR.dialog.dlg_get_var(str "sc", str "sf", str "st", str "key");

KSR.dialog.dlg_isflagset()

int KSR.dialog.dlg_isflagset(int val);

KSR.dialog.dlg_manage()

int KSR.dialog.dlg_manage();

KSR.dialog.dlg_req_within4()

int KSR.dialog.dlg_req_within4(str "side", str "method", str "content_type", str "content");

KSR.dialog.dlg_reset_property()

int KSR.dialog.dlg_reset_property(str "pval");

KSR.dialog.dlg_resetflag()

int KSR.dialog.dlg_resetflag(int val);

KSR.dialog.dlg_set_property()

int KSR.dialog.dlg_set_property(str "pval");

KSR.dialog.dlg_set_state()

int KSR.dialog.dlg_set_state(str "state");

KSR.dialog.dlg_set_timeout()

int KSR.dialog.dlg_set_timeout(int to);

KSR.dialog.dlg_set_timeout_id()

int KSR.dialog.dlg_set_timeout_id(int to, int he, int hi);

KSR.dialog.dlg_set_var()

int KSR.dialog.dlg_set_var(str "sc", str "sf", str "st", str "key", str "val");

KSR.dialog.dlg_setflag()

int KSR.dialog.dlg_setflag(int val);

KSR.dialog.dlg_update_state()

int KSR.dialog.dlg_update_state();

KSR.dialog.get_profile_size()

int KSR.dialog.get_profile_size(str "sprofile", str "svalue", str "spv");

KSR.dialog.get_profile_size_static()

int KSR.dialog.get_profile_size_static(str "sprofile", str "spv");

KSR.dialog.is_in_profile()

int KSR.dialog.is_in_profile(str "sprofile", str "svalue");

KSR.dialog.is_in_profile_static()

int KSR.dialog.is_in_profile_static(str "sprofile");

KSR.dialog.is_known_dlg()

int KSR.dialog.is_known_dlg();

KSR.dialog.set_dlg_profile()

int KSR.dialog.set_dlg_profile(str "sprofile", str "svalue");

KSR.dialog.set_dlg_profile_static()

int KSR.dialog.set_dlg_profile_static(str "sprofile");

KSR.dialog.unset_dlg_profile()

int KSR.dialog.unset_dlg_profile(str "sprofile", str "svalue");

KSR.dialog.unset_dlg_profile_static()

int KSR.dialog.unset_dlg_profile_static(str "sprofile");

KSR.dialog.var_get()

xval KSR.dialog.var_get(str "name");

KSR.dialog.var_gete()

xval KSR.dialog.var_gete(str "name");

KSR.dialog.var_getw()

xval KSR.dialog.var_getw(str "name");

KSR.dialog.var_is_null()

int KSR.dialog.var_is_null(str "name");

KSR.dialog.var_rm()

int KSR.dialog.var_rm(str "name");

KSR.dialog.var_sets()

int KSR.dialog.var_sets(str "name", str "val");

dialplan

Exported functions:

KSR.dialplan.dp_match()

int KSR.dialplan.dp_match(int dpid, str "src");

KSR.dialplan.dp_replace()

int KSR.dialplan.dp_replace(int dpid, str "src", str "dst");

KSR.dialplan.dp_translate()

int KSR.dialplan.dp_translate(int id);

KSR.dialplan.dp_translate_vars()

int KSR.dialplan.dp_translate_vars(int id, str "input", str "output");

dispatcher

Exported functions:

KSR.dispatcher.ds_is_active()

int KSR.dispatcher.ds_is_active(int set);

KSR.dispatcher.ds_is_active_uri()

int KSR.dispatcher.ds_is_active_uri(int set, str "uri");

KSR.dispatcher.ds_is_from_list()

int KSR.dispatcher.ds_is_from_list(int group);

KSR.dispatcher.ds_is_from_list_mode()

int KSR.dispatcher.ds_is_from_list_mode(int vset, int vmode);

KSR.dispatcher.ds_is_from_list_uri()

int KSR.dispatcher.ds_is_from_list_uri(int vset, int vmode, str "vuri");

KSR.dispatcher.ds_is_from_lists()

int KSR.dispatcher.ds_is_from_lists();

KSR.dispatcher.ds_list_exists()

int KSR.dispatcher.ds_list_exists(int set);

KSR.dispatcher.ds_load_unset()

int KSR.dispatcher.ds_load_unset();

KSR.dispatcher.ds_load_update()

int KSR.dispatcher.ds_load_update();

KSR.dispatcher.ds_mark_addr()

int KSR.dispatcher.ds_mark_addr(str "vstate", int vgroup, str "vuri");

KSR.dispatcher.ds_mark_dst()

int KSR.dispatcher.ds_mark_dst();

KSR.dispatcher.ds_mark_dst_state()

int KSR.dispatcher.ds_mark_dst_state(str "sval");

KSR.dispatcher.ds_next_domain()

int KSR.dispatcher.ds_next_domain();

KSR.dispatcher.ds_next_dst()

int KSR.dispatcher.ds_next_dst();

KSR.dispatcher.ds_reload()

int KSR.dispatcher.ds_reload();

KSR.dispatcher.ds_select()

int KSR.dispatcher.ds_select(int set, int alg);

KSR.dispatcher.ds_select_domain()

int KSR.dispatcher.ds_select_domain(int set, int alg);

KSR.dispatcher.ds_select_domain_limit()

int KSR.dispatcher.ds_select_domain_limit(int set, int alg, int limit);

KSR.dispatcher.ds_select_dst()

int KSR.dispatcher.ds_select_dst(int set, int alg);

KSR.dispatcher.ds_select_dst_limit()

int KSR.dispatcher.ds_select_dst_limit(int set, int alg, int limit);

KSR.dispatcher.ds_select_limit()

int KSR.dispatcher.ds_select_limit(int set, int alg, int limit);

KSR.dispatcher.ds_select_routes()

int KSR.dispatcher.ds_select_routes(str "srules", str "smode");

KSR.dispatcher.ds_select_routes_limit()

int KSR.dispatcher.ds_select_routes_limit(str "srules", str "smode", int rlimit);

KSR.dispatcher.ds_set_domain()

int KSR.dispatcher.ds_set_domain();

KSR.dispatcher.ds_set_dst()

int KSR.dispatcher.ds_set_dst();

diversion

Exported functions:

KSR.diversion.add_diversion()

int KSR.diversion.add_diversion(str "reason");

KSR.diversion.add_diversion_uri()

int KSR.diversion.add_diversion_uri(str "reason", str "uri");

dlgs

Exported functions:

KSR.dlgs.dlgs_count()

int KSR.dlgs.dlgs_count(str "vfield", str "vop", str "vdata");

KSR.dlgs.dlgs_init()

int KSR.dlgs.dlgs_init(str "src", str "dst", str "data");

KSR.dlgs.dlgs_tags_add()

int KSR.dlgs.dlgs_tags_add(str "vtags");

KSR.dlgs.dlgs_tags_count()

int KSR.dlgs.dlgs_tags_count(str "vtags");

KSR.dlgs.dlgs_tags_rm()

int KSR.dlgs.dlgs_tags_rm(str "vtags");

KSR.dlgs.dlgs_update()

int KSR.dlgs.dlgs_update();

dmq

Exported functions:

KSR.dmq.bcast_message()

int KSR.dmq.bcast_message(str "peer_str", str "body_str", str "ct_str");

KSR.dmq.handle_message()

int KSR.dmq.handle_message();

KSR.dmq.handle_message_rc()

int KSR.dmq.handle_message_rc(int returnval);

KSR.dmq.is_from_node()

int KSR.dmq.is_from_node();

KSR.dmq.process_message()

int KSR.dmq.process_message();

KSR.dmq.process_message_rc()

int KSR.dmq.process_message_rc(int returnval);

KSR.dmq.send_message()

int KSR.dmq.send_message(str "peer_str", str "to_str", str "body_str", str "ct_str");

KSR.dmq.t_replicate()

int KSR.dmq.t_replicate();

KSR.dmq.t_replicate_mode()

int KSR.dmq.t_replicate_mode(int mode);

domain

Exported functions:

KSR.domain.is_domain_local()

int KSR.domain.is_domain_local(str "sdomain");

KSR.domain.is_from_local()

int KSR.domain.is_from_local();

KSR.domain.is_uri_host_local()

int KSR.domain.is_uri_host_local();

KSR.domain.lookup_domain()

int KSR.domain.lookup_domain(str "_sdomain");

KSR.domain.lookup_domain_prefix()

int KSR.domain.lookup_domain_prefix(str "_sdomain", str "_sprefix");

drouting

Exported functions:

KSR.drouting.do_routing()

int KSR.drouting.do_routing(int grp_id);

KSR.drouting.do_routing_furi()

int KSR.drouting.do_routing_furi();

KSR.drouting.goes_to_gw()

int KSR.drouting.goes_to_gw();

KSR.drouting.goes_to_gw_type()

int KSR.drouting.goes_to_gw_type(int type);

KSR.drouting.is_from_gw()

int KSR.drouting.is_from_gw();

KSR.drouting.is_from_gw_type()

int KSR.drouting.is_from_gw_type(int type);

KSR.drouting.is_from_gw_type_flags()

int KSR.drouting.is_from_gw_type_flags(int type, int flags);

KSR.drouting.next_routing()

int KSR.drouting.next_routing();

KSR.drouting.use_next_gw()

int KSR.drouting.use_next_gw();

enum

Exported functions:

KSR.enum.enum_i_query_suffix()

int KSR.enum.enum_i_query_suffix(str "vsuffix");

KSR.enum.enum_pv_query()

int KSR.enum.enum_pv_query(str "ve164");

KSR.enum.enum_pv_query_suffix()

int KSR.enum.enum_pv_query_suffix(str "ve164", str "vsuffix");

KSR.enum.enum_pv_query_suffix_service()

int KSR.enum.enum_pv_query_suffix_service(str "ve164", str "vsuffix", str "vservice");

KSR.enum.enum_query()

int KSR.enum.enum_query();

KSR.enum.enum_query_suffix()

int KSR.enum.enum_query_suffix(str "vsuffix");

KSR.enum.enum_query_suffix_service()

int KSR.enum.enum_query_suffix_service(str "vsuffix", str "vservice");

KSR.enum.i_enum_query()

int KSR.enum.i_enum_query();

KSR.enum.i_enum_query_suffix_service()

int KSR.enum.i_enum_query_suffix_service(str "vsuffix", str "vservice");

KSR.enum.is_from_user_enum()

int KSR.enum.is_from_user_enum();

KSR.enum.is_from_user_enum_suffix()

int KSR.enum.is_from_user_enum_suffix(str "vsuffix");

KSR.enum.is_from_user_enum_suffix_service()

int KSR.enum.is_from_user_enum_suffix_service(str "vsuffix", str "vservice");

evapi

Exported functions:

KSR.evapi.async_multicast()

int KSR.evapi.async_multicast(str "sdata", str "stag");

KSR.evapi.async_relay()

int KSR.evapi.async_relay(str "sdata");

KSR.evapi.async_unicast()

int KSR.evapi.async_unicast(str "sdata", str "stag");

KSR.evapi.close()

int KSR.evapi.close();

KSR.evapi.relay()

int KSR.evapi.relay(str "sdata");

KSR.evapi.relay_multicast()

int KSR.evapi.relay_multicast(str "sdata", str "stag");

KSR.evapi.relay_unicast()

int KSR.evapi.relay_unicast(str "sdata", str "stag");

KSR.evapi.set_tag()

int KSR.evapi.set_tag(str "stag");

exec

Exported functions:

KSR.exec.exec_avp()

int KSR.exec.exec_avp(str "cmd");

KSR.exec.exec_cmd()

int KSR.exec.exec_cmd(str "cmd");

KSR.exec.exec_dset()

int KSR.exec.exec_dset(str "cmd");

KSR.exec.exec_msg()

int KSR.exec.exec_msg(str "cmd");

gcrypt

Exported functions:

KSR.gcrypt.aes_decrypt()

int KSR.gcrypt.aes_decrypt(str "ins", str "keys", str "dpv");

KSR.gcrypt.aes_encrypt()

int KSR.gcrypt.aes_encrypt(str "ins", str "keys", str "dpv");

geoip

Exported functions:

KSR.geoip.match()

int KSR.geoip.match(str "tomatch", str "pvclass");

geoip2

Exported functions:

KSR.geoip2.distance()

int KSR.geoip2.distance(str "_ipaddr", str "_lat", str "_lon");

KSR.geoip2.match()

int KSR.geoip2.match(str "tomatch", str "pvclass");

group

Exported functions:

KSR.group.is_user_in()

int KSR.group.is_user_in(str "uri", str "grp");

htable

Functions exported by htable module.

Exported functions:

KSR.htable.sht_dec()

int KSR.htable.sht_dec(str "htname", str "itname");

Do atomic decrement to the item value. It returns the new value or -255 if the hash table does not exist, or the item does not exist or the item value is not integer.

KSR.htable.sht_get()

xval KSR.htable.sht_get(str "htname", str "itname");

Return the integer or string value of the item.

If the item does not exists, it returns NULL. Note that NULL might be represented differently in various scripting languages, such as nil or None.

KSR.htable.sht_gete()

xval KSR.htable.sht_gete(str "htname", str "itname");

Return the integer or string value of the item.

If the item does not exists, it returns an empty string.

KSR.htable.sht_getw()

xval KSR.htable.sht_getw(str "htname", str "itname");

Return the integer or string value of the item.

If the item does not exists, it returns the string <null>, suitable for use when writing log messages.

KSR.htable.sht_inc()

int KSR.htable.sht_inc(str "htname", str "itname");

Do atomic increment to the item value. It returns the new value or -255 if the hash table does not exist, or the item does not exist or the item value is not integer.

KSR.htable.sht_is_null()

int KSR.htable.sht_is_null(str "htname", str "itname");

KSR.htable.sht_iterator_end()

int KSR.htable.sht_iterator_end(str "iname");

KSR.htable.sht_iterator_next()

int KSR.htable.sht_iterator_next(str "iname");

KSR.htable.sht_iterator_rm()

int KSR.htable.sht_iterator_rm(str "iname");

KSR.htable.sht_iterator_setex()

int KSR.htable.sht_iterator_setex(str "iname", int exval);

KSR.htable.sht_iterator_seti()

int KSR.htable.sht_iterator_seti(str "iname", int ival);

KSR.htable.sht_iterator_sets()

int KSR.htable.sht_iterator_sets(str "iname", str "sval");

KSR.htable.sht_iterator_start()

int KSR.htable.sht_iterator_start(str "iname", str "hname");

KSR.htable.sht_lock()

int KSR.htable.sht_lock(str "htname", str "skey");

KSR.htable.sht_match_name()

int KSR.htable.sht_match_name(str "sname", str "sop", str "sval");

KSR.htable.sht_match_str_value()

int KSR.htable.sht_match_str_value(str "sname", str "sop", str "sval");

KSR.htable.sht_reset()

int KSR.htable.sht_reset(str "hname");

KSR.htable.sht_rm()

int KSR.htable.sht_rm(str "hname", str "iname");

KSR.htable.sht_rm_name()

int KSR.htable.sht_rm_name(str "sname", str "sop", str "sval");

KSR.htable.sht_rm_name_re()

int KSR.htable.sht_rm_name_re(str "htname", str "rexp");

KSR.htable.sht_rm_value()

int KSR.htable.sht_rm_value(str "sname", str "sop", str "sval");

KSR.htable.sht_rm_value_re()

int KSR.htable.sht_rm_value_re(str "htname", str "rexp");

KSR.htable.sht_setex()

int KSR.htable.sht_setex(str "htname", str "itname", int itval);

KSR.htable.sht_seti()

int KSR.htable.sht_seti(str "htname", str "itname", int itval);

KSR.htable.sht_sets()

int KSR.htable.sht_sets(str "htname", str "itname", str "itval");

KSR.htable.sht_setxi()

int KSR.htable.sht_setxi(str "htname", str "itname", int itval, int exval);

KSR.htable.sht_setxs()

int KSR.htable.sht_setxs(str "htname", str "itname", str "itval", int exval);

KSR.htable.sht_unlock()

int KSR.htable.sht_unlock(str "htname", str "skey");

http_async_client

Exported functions:

KSR.http_async_client.query()

int KSR.http_async_client.query(str "sdata", str "rn");

http_client

Exported functions:

KSR.http_client.curl_connect()

int KSR.http_client.curl_connect(str "con", str "url", str "dpv");

KSR.http_client.curl_connect_post()

int KSR.http_client.curl_connect_post(str "con", str "url", str "ctype", str "data", str "dpv");

KSR.http_client.get_hdrs()

int KSR.http_client.get_hdrs(str "url", str "body", str "hdrs", str "dpv");

KSR.http_client.query()

int KSR.http_client.query(str "url", str "dpv");

KSR.http_client.query_post()

int KSR.http_client.query_post(str "url", str "post", str "dpv");

KSR.http_client.query_post_hdrs()

int KSR.http_client.query_post_hdrs(str "url", str "post", str "hdrs", str "dpv");

KSR.http_client.query_request()

int KSR.http_client.query_request(str "met", str "url", str "body", str "hdrs", str "dpv");

KSR.http_client.query_request_v2pk()

int KSR.http_client.query_request_v2pk(str "met", str "url", str "body", str "hdrs", str "dpv");

imc

Exported functions:

KSR.imc.imc_manager()

int KSR.imc.imc_manager();

KSR.imc.imc_room_active()

int KSR.imc.imc_room_active(str "room");

KSR.imc.imc_room_member()

int KSR.imc.imc_room_member(str "room", str "member");

ims_charging

Exported functions:

KSR.ims_charging.Ro_CCR()

int KSR.ims_charging.Ro_CCR(str "s_route_name", str "s_direction", int reservation_units, str "s_incoming_trunk_id", str "s_outgoing_trunk_id");

KSR.ims_charging.Ro_CCR_Stop()

int KSR.ims_charging.Ro_CCR_Stop(str "p_direction", int p_code, str "p_reason");

KSR.ims_charging.Ro_set_session_id_avp()

int KSR.ims_charging.Ro_set_session_id_avp();

ims_dialog

Exported functions:

KSR.ims_dialog.get_profile_size()

int KSR.ims_dialog.get_profile_size(str "sprofile", str "svalue", str "spv");

KSR.ims_dialog.is_known_dlg()

int KSR.ims_dialog.is_known_dlg();

KSR.ims_dialog.set_dlg_profile()

int KSR.ims_dialog.set_dlg_profile(str "sprofile", str "svalue");

ims_diameter_server

Exported functions:

KSR.ims_diameter_server.diameter_request()

int KSR.ims_diameter_server.diameter_request(str "peer", int appid, int commandcode, str "message");

KSR.ims_diameter_server.diameter_request_async()

int KSR.ims_diameter_server.diameter_request_async(str "peer", int appid, int commandcode, str "message");

ims_qos

Exported functions:

KSR.ims_qos.Rx_AAR()

int KSR.ims_qos.Rx_AAR(str "route", str "dir", str "c_id", int id_type, str "sessionId");

KSR.ims_qos.Rx_AAR()

int KSR.ims_qos.Rx_AAR(str "route", str "dir", str "c_id", int id_type);

KSR.ims_qos.Rx_AAR_Register()

int KSR.ims_qos.Rx_AAR_Register(str "route", str "domain");

KSR.ims_qos.Rx_AAR_Register()

int KSR.ims_qos.Rx_AAR_Register(str "route", str "domain");

influxdbc

Exported functions:

KSR.influxdbc.ic_long()

int KSR.influxdbc.ic_long(str "name", int val);

KSR.influxdbc.measure()

int KSR.influxdbc.measure(str "name");

KSR.influxdbc.measureend()

int KSR.influxdbc.measureend();

KSR.influxdbc.push()

int KSR.influxdbc.push();

ipops

Exported functions:

KSR.ipops.compare_ips()

int KSR.ipops.compare_ips(str "_sval1", str "_sval2");

KSR.ipops.compare_pure_ips()

int KSR.ipops.compare_pure_ips(str "_sval1", str "_sval2");

KSR.ipops.detailed_ip_type()

int KSR.ipops.detailed_ip_type(str "_sval", str "_dpv");

KSR.ipops.detailed_ipv4_type()

int KSR.ipops.detailed_ipv4_type(str "_sval", str "_dpv");

KSR.ipops.detailed_ipv6_type()

int KSR.ipops.detailed_ipv6_type(str "_sval", str "_dpv");

KSR.ipops.dns_int_match_ip()

int KSR.ipops.dns_int_match_ip(str "vhn", str "vip");

KSR.ipops.dns_query()

int KSR.ipops.dns_query(str "naptrname", str "pvid");

KSR.ipops.dns_set_local_ttl()

int KSR.ipops.dns_set_local_ttl(int vttl);

KSR.ipops.dns_sys_match_ip()

int KSR.ipops.dns_sys_match_ip(str "vhn", str "vip");

KSR.ipops.ip_is_in_subnet()

int KSR.ipops.ip_is_in_subnet(str "_sval1", str "_sval2");

KSR.ipops.ip_type()

int KSR.ipops.ip_type(str "sval");

KSR.ipops.is_in_subnet()

int KSR.ipops.is_in_subnet(str "_sval1", str "_sval2");

KSR.ipops.is_ip()

int KSR.ipops.is_ip(str "sval");

KSR.ipops.is_ip4()

int KSR.ipops.is_ip4(str "sval");

KSR.ipops.is_ip6()

int KSR.ipops.is_ip6(str "sval");

KSR.ipops.is_ip6_reference()

int KSR.ipops.is_ip6_reference(str "sval");

KSR.ipops.is_ip_rfc1918()

int KSR.ipops.is_ip_rfc1918(str "sval");

KSR.ipops.is_pure_ip()

int KSR.ipops.is_pure_ip(str "sval");

KSR.ipops.naptr_query()

int KSR.ipops.naptr_query(str "naptrname", str "pvid");

KSR.ipops.ptr_query()

int KSR.ipops.ptr_query(str "ip", str "pvid");

KSR.ipops.srv_query()

int KSR.ipops.srv_query(str "naptrname", str "pvid");

jansson

Exported functions:

KSR.jansson.get()

int KSR.jansson.get(str "spath", str "sdoc", str "spv");

jsonrpcs

Exported functions:

KSR.jsonrpcs.dispatch()

int KSR.jsonrpcs.dispatch();

KSR.jsonrpcs.exec()

int KSR.jsonrpcs.exec(str "scmd");

KSR.jsonrpcs.execx()

int KSR.jsonrpcs.execx(str "scmd");

KSR.jsonrpcs.response()

xval KSR.jsonrpcs.response();

jwt

Exported functions:

KSR.jwt.jwt_generate()

int KSR.jwt.jwt_generate(str "key", str "alg", str "claims");

KSR.jwt.jwt_generate_hdrs()

int KSR.jwt.jwt_generate_hdrs(str "key", str "alg", str "claims", str "headers");

KSR.jwt.jwt_verify()

int KSR.jwt.jwt_verify(str "keypath", str "alg", str "claims", str "jwtval");

KSR.jwt.jwt_verify_key()

int KSR.jwt.jwt_verify_key(str "key", str "alg", str "claims", str "jwtval");

kafka

Exported functions:

KSR.kafka.send()

int KSR.kafka.send(str "s_topic", str "s_message");

KSR.kafka.send_key()

int KSR.kafka.send_key(str "s_topic", str "s_message", str "s_key");

kazoo

Exported functions:

KSR.kazoo.kazoo_publish()

int KSR.kazoo.kazoo_publish(str "exchange", str "routing_key", str "payload");

KSR.kazoo.kazoo_subscribe()

int KSR.kazoo.kazoo_subscribe(str "payload");

keepalive

Exported functions:

KSR.keepalive.add_destination()

int KSR.keepalive.add_destination(str "uri", str "owner");

KSR.keepalive.del_destination()

int KSR.keepalive.del_destination(str "uri", str "owner");

KSR.keepalive.is_alive()

int KSR.keepalive.is_alive(str "dest");

kex

Exported functions:

KSR.kex.resetdebug()

int KSR.kex.resetdebug();

KSR.kex.setdebug()

int KSR.kex.setdebug(int lval);

kx

Functions exported by kemix module and available in KEMI language under KSR.kx. They aim to provide a convenient way to retrieve string or integer values for most commonly used variables or runtime environment attributes.

Exported functions:

KSR.kx.get_au()

xval KSR.kx.get_au();

KSR.kx.get_body()

xval KSR.kx.get_body();

Return the body of the SIP message (the value of $rb).

KSR.kx.get_bodylen()

int KSR.kx.get_bodylen();

KSR.kx.get_callid()

xval KSR.kx.get_callid();

KSR.kx.get_conid()

int KSR.kx.get_conid();

Return the connection id for TCP, TLS and WebSocket, or -1 if no stream connection corresponds to current SIP message.

KSR.kx.get_cturi()

xval KSR.kx.get_cturi();

KSR.kx.get_def()

xval KSR.kx.get_def(str "dname");

KSR.kx.get_defn()

int KSR.kx.get_defn(str "dname");

KSR.kx.get_duri()

xval KSR.kx.get_duri();

Return the value of destination URI ($du).

KSR.kx.get_env()

xval KSR.kx.get_env(str "envname");

KSR.kx.get_envn()

int KSR.kx.get_envn(str "envname");

KSR.kx.get_fhost()

xval KSR.kx.get_fhost();

Return From-URI domain ($fd).

KSR.kx.get_furi()

xval KSR.kx.get_furi();

Return the From URI($fu).

KSR.kx.get_fuser()

xval KSR.kx.get_fuser();

Return the From-URI username ($fU).

KSR.kx.get_method()

xval KSR.kx.get_method();

Return the SIP method ($rm).

KSR.kx.get_msgbuf()

xval KSR.kx.get_msgbuf();

KSR.kx.get_msglen()

int KSR.kx.get_msglen();

KSR.kx.get_msgtype()

int KSR.kx.get_msgtype();

KSR.kx.get_nhuri()

xval KSR.kx.get_nhuri();

KSR.kx.get_ouri()

xval KSR.kx.get_ouri();

KSR.kx.get_proto()

xval KSR.kx.get_proto();

KSR.kx.get_protoid()

int KSR.kx.get_protoid();

KSR.kx.get_rcv_sock_name()

xval KSR.kx.get_rcv_sock_name();

KSR.kx.get_rcvaddr_sock()

xval KSR.kx.get_rcvaddr_sock();

KSR.kx.get_rcvadvip()

xval KSR.kx.get_rcvadvip();

KSR.kx.get_rcvadvport()

xval KSR.kx.get_rcvadvport();

KSR.kx.get_rcvip()

xval KSR.kx.get_rcvip();

KSR.kx.get_rcvport()

xval KSR.kx.get_rcvport();

KSR.kx.get_rhost()

xval KSR.kx.get_rhost();

Return the Request URI host (domain) part ($rd).

KSR.kx.get_ruri()

xval KSR.kx.get_ruri();

Return the Request URI ($ru).

KSR.kx.get_ruser()

xval KSR.kx.get_ruser();

Return the Request URI user part ($rU).

KSR.kx.get_send_sock()

xval KSR.kx.get_send_sock();

KSR.kx.get_send_sock_name()

xval KSR.kx.get_send_sock_name();

KSR.kx.get_send_sock_port()

int KSR.kx.get_send_sock_port();

KSR.kx.get_srcaddr_sock()

xval KSR.kx.get_srcaddr_sock();

KSR.kx.get_srcip()

xval KSR.kx.get_srcip();

KSR.kx.get_srcport()

xval KSR.kx.get_srcport();

KSR.kx.get_srcuri()

xval KSR.kx.get_srcuri();

KSR.kx.get_status()

int KSR.kx.get_status();

KSR.kx.get_thost()

xval KSR.kx.get_thost();

Return the To-URI host (domain) part ($td).

KSR.kx.get_timestamp()

int KSR.kx.get_timestamp();

KSR.kx.get_turi()

xval KSR.kx.get_turi();

Return the To URI ($tu).

KSR.kx.get_tuser()

xval KSR.kx.get_tuser();

Return the To-URI user part ($tU).

KSR.kx.get_ua()

xval KSR.kx.get_ua();

KSR.kx.gete_au()

xval KSR.kx.gete_au();

KSR.kx.gete_body()

xval KSR.kx.gete_body();

KSR.kx.gete_cturi()

xval KSR.kx.gete_cturi();

KSR.kx.gete_duri()

xval KSR.kx.gete_duri();

KSR.kx.gete_fhost()

xval KSR.kx.gete_fhost();

KSR.kx.gete_fuser()

xval KSR.kx.gete_fuser();

KSR.kx.gete_rhost()

xval KSR.kx.gete_rhost();

KSR.kx.gete_ruser()

xval KSR.kx.gete_ruser();

KSR.kx.gete_thost()

xval KSR.kx.gete_thost();

KSR.kx.gete_tuser()

xval KSR.kx.gete_tuser();

KSR.kx.gete_ua()

xval KSR.kx.gete_ua();

KSR.kx.gets_status()

xval KSR.kx.gets_status();

KSR.kx.getw_au()

xval KSR.kx.getw_au();

KSR.kx.getw_body()

xval KSR.kx.getw_body();

KSR.kx.getw_cturi()

xval KSR.kx.getw_cturi();

KSR.kx.getw_duri()

xval KSR.kx.getw_duri();

KSR.kx.getw_fhost()

xval KSR.kx.getw_fhost();

KSR.kx.getw_fuser()

xval KSR.kx.getw_fuser();

KSR.kx.getw_rhost()

xval KSR.kx.getw_rhost();

KSR.kx.getw_ruser()

xval KSR.kx.getw_ruser();

KSR.kx.getw_thost()

xval KSR.kx.getw_thost();

KSR.kx.getw_tuser()

xval KSR.kx.getw_tuser();

KSR.kx.getw_ua()

xval KSR.kx.getw_ua();

KSR.kx.ifdef()

bool KSR.kx.ifdef(str "dname");

KSR.kx.ifndef()

bool KSR.kx.ifndef(str "dname");

lcr

Exported functions:

KSR.lcr.defunct_gw()

int KSR.lcr.defunct_gw(int defunct_period);

KSR.lcr.from_any_gw()

int KSR.lcr.from_any_gw();

KSR.lcr.from_any_gw_addr()

int KSR.lcr.from_any_gw_addr(str "addr_str", int transport);

KSR.lcr.from_any_gw_addr_port()

int KSR.lcr.from_any_gw_addr_port(str "addr_str", int transport, int src_port);

KSR.lcr.from_gw()

int KSR.lcr.from_gw(int lcr_id);

KSR.lcr.from_gw_addr()

int KSR.lcr.from_gw_addr(int lcr_id, str "addr_str", int transport);

KSR.lcr.from_gw_addr_port()

int KSR.lcr.from_gw_addr_port(int lcr_id, str "addr_str", int transport, int src_port);

KSR.lcr.inactivate_gw()

int KSR.lcr.inactivate_gw();

KSR.lcr.load_gws()

int KSR.lcr.load_gws(int lcr_id);

KSR.lcr.load_gws_furi()

int KSR.lcr.load_gws_furi(int lcr_id, str "ruri_user", str "from_uri");

KSR.lcr.load_gws_ruser()

int KSR.lcr.load_gws_ruser(int lcr_id, str "ruri_user");

KSR.lcr.next_gw()

int KSR.lcr.next_gw();

KSR.lcr.to_any_gw()

int KSR.lcr.to_any_gw();

KSR.lcr.to_any_gw_addr()

int KSR.lcr.to_any_gw_addr(str "addr_str", int transport);

KSR.lcr.to_gw()

int KSR.lcr.to_gw(int lcr_id);

KSR.lcr.to_gw_addr()

int KSR.lcr.to_gw_addr(int lcr_id, str "addr_str", int transport);

ldap

Exported functions:

KSR.ldap.result_next()

int KSR.ldap.result_next();

KSR.ldap.search()

int KSR.ldap.search(str "ldapurl");

log_custom

Exported functions:

KSR.log_custom.log_udp()

int KSR.log_custom.log_udp(str "txt");

log_systemd

Exported functions:

KSR.log_systemd.sd_journal_print()

int KSR.log_systemd.sd_journal_print(str "slev", str "stxt");

KSR.log_systemd.sd_journal_send_xvap()

int KSR.log_systemd.sd_journal_send_xvap(str "xname");

lwsc

Exported functions:

KSR.lwsc.lwsc_notify()

int KSR.lwsc.lwsc_notify(str "wsurl", str "data");

KSR.lwsc.lwsc_notify_proto()

int KSR.lwsc.lwsc_notify_proto(str "wsurl", str "wsproto", str "data");

KSR.lwsc.lwsc_request()

int KSR.lwsc.lwsc_request(str "wsurl", str "data");

KSR.lwsc.lwsc_request_proto()

int KSR.lwsc.lwsc_request_proto(str "wsurl", str "wsproto", str "data");

maxfwd

Exported functions:

KSR.maxfwd.is_maxfwd_lt()

int KSR.maxfwd.is_maxfwd_lt(int limit);

KSR.maxfwd.process_maxfwd()

int KSR.maxfwd.process_maxfwd(int limit);

mediaproxy

Exported functions:

KSR.mediaproxy.end_media_session()

int KSR.mediaproxy.end_media_session();

KSR.mediaproxy.engage_media_proxy()

int KSR.mediaproxy.engage_media_proxy();

KSR.mediaproxy.use_media_proxy()

int KSR.mediaproxy.use_media_proxy();

microhttpd

Exported functions:

KSR.microhttpd.mhttpd_reply()

int KSR.microhttpd.mhttpd_reply(int rcode, str "sreason", str "sctype", str "sbody");

misc_radius

Exported functions:

KSR.misc_radius.does_uri_exist()

int KSR.misc_radius.does_uri_exist();

KSR.misc_radius.does_uri_exist_uval()

int KSR.misc_radius.does_uri_exist_uval(str "suri");

KSR.misc_radius.does_uri_user_exist()

int KSR.misc_radius.does_uri_user_exist();

KSR.misc_radius.does_uri_user_exist_uval()

int KSR.misc_radius.does_uri_user_exist_uval(str "user");

KSR.misc_radius.is_user_in()

int KSR.misc_radius.is_user_in(str "user", str "group");

KSR.misc_radius.load_callee_avps()

int KSR.misc_radius.load_callee_avps(str "user");

KSR.misc_radius.load_caller_avps()

int KSR.misc_radius.load_caller_avps(str "user");

mqtt

Exported functions:

KSR.mqtt.publish()

int KSR.mqtt.publish(str "topic", str "payload", int qos);

KSR.mqtt.subscribe()

int KSR.mqtt.subscribe(str "topic", int qos);

KSR.mqtt.unsubscribe()

int KSR.mqtt.unsubscribe(str "topic");

mqueue

Exported functions:

KSR.mqueue.mq_add()

int KSR.mqueue.mq_add(str "mq", str "key", str "val");

KSR.mqueue.mq_fetch()

int KSR.mqueue.mq_fetch(str "mq");

KSR.mqueue.mq_pv_free()

int KSR.mqueue.mq_pv_free(str "mq");

KSR.mqueue.mq_size()

int KSR.mqueue.mq_size(str "mq");

KSR.mqueue.mqk_get()

xval KSR.mqueue.mqk_get(str "qname");

KSR.mqueue.mqk_gete()

xval KSR.mqueue.mqk_gete(str "qname");

KSR.mqueue.mqk_getw()

xval KSR.mqueue.mqk_getw(str "qname");

KSR.mqueue.mqv_get()

xval KSR.mqueue.mqv_get(str "qname");

KSR.mqueue.mqv_gete()

xval KSR.mqueue.mqv_gete(str "qname");

KSR.mqueue.mqv_getw()

xval KSR.mqueue.mqv_getw(str "qname");

msilo

Exported functions:

KSR.msilo.mdump()

int KSR.msilo.mdump();

KSR.msilo.mdump_uri()

int KSR.msilo.mdump_uri(str "owner_s");

KSR.msilo.mstore()

int KSR.msilo.mstore();

KSR.msilo.mstore_addrs()

int KSR.msilo.mstore_addrs(str "owner", str "srcaddr", str "dstaddr");

KSR.msilo.mstore_uri()

int KSR.msilo.mstore_uri(str "owner");

msrp

Exported functions:

KSR.msrp.cmap_lookup()

int KSR.msrp.cmap_lookup();

KSR.msrp.cmap_save()

int KSR.msrp.cmap_save();

KSR.msrp.forward()

int KSR.msrp.forward(str "tpath", str "fpath");

KSR.msrp.is_reply()

int KSR.msrp.is_reply();

KSR.msrp.is_request()

int KSR.msrp.is_request();

KSR.msrp.relay()

int KSR.msrp.relay();

KSR.msrp.relay_flags()

int KSR.msrp.relay_flags(int rtflags);

KSR.msrp.reply()

int KSR.msrp.reply(str "rcode", str "rtext", str "rhdrs");

KSR.msrp.reply_flags()

int KSR.msrp.reply_flags(int rtflags);

KSR.msrp.set_dst()

int KSR.msrp.set_dst(str "rtaddr", str "rfsock");

mtree

Exported functions:

KSR.mtree.mt_match()

int KSR.mtree.mt_match(str "tname", str "tomatch", int mval);

nat_traversal

Exported functions:

KSR.nat_traversal.client_nat_test()

int KSR.nat_traversal.client_nat_test(int tests);

KSR.nat_traversal.fix_contact()

int KSR.nat_traversal.fix_contact();

KSR.nat_traversal.nat_keepalive()

int KSR.nat_traversal.nat_keepalive();

nathelper

Exported functions:

KSR.nathelper.add_contact_alias()

int KSR.nathelper.add_contact_alias();

KSR.nathelper.add_contact_alias_addr()

int KSR.nathelper.add_contact_alias_addr(str "ip_str", str "port_str", str "proto_str");

KSR.nathelper.add_rcv_param()

int KSR.nathelper.add_rcv_param(int upos);

KSR.nathelper.fix_nated_contact()

int KSR.nathelper.fix_nated_contact();

KSR.nathelper.fix_nated_register()

int KSR.nathelper.fix_nated_register();

KSR.nathelper.fix_nated_sdp()

int KSR.nathelper.fix_nated_sdp(int level);

KSR.nathelper.fix_nated_sdp_ip()

int KSR.nathelper.fix_nated_sdp_ip(int level, str "ip");

KSR.nathelper.handle_ruri_alias()

int KSR.nathelper.handle_ruri_alias();

KSR.nathelper.handle_ruri_alias_mode()

int KSR.nathelper.handle_ruri_alias_mode(int mode);

KSR.nathelper.is_rfc1918()

int KSR.nathelper.is_rfc1918(str "address");

KSR.nathelper.nat_uac_test()

int KSR.nathelper.nat_uac_test(int tests);

KSR.nathelper.set_alias_to_pv()

int KSR.nathelper.set_alias_to_pv(str "uri_avp");

KSR.nathelper.set_contact_alias()

int KSR.nathelper.set_contact_alias();

KSR.nathelper.set_contact_alias_trim()

int KSR.nathelper.set_contact_alias_trim();

nats

Exported functions:

KSR.nats.publish()

int KSR.nats.publish(str "subject", str "payload");

KSR.nats.publish_request()

int KSR.nats.publish_request(str "subject", str "payload", str "reply");

ndb_mongodb

Exported functions:

KSR.ndb_mongodb.exec()

int KSR.ndb_mongodb.exec(str "ssrv", str "sdname", str "scname", str "scmd", str "sres");

KSR.ndb_mongodb.exec_simple()

int KSR.ndb_mongodb.exec_simple(str "ssrv", str "sdname", str "scname", str "scmd", str "sres");

KSR.ndb_mongodb.execx()

int KSR.ndb_mongodb.execx(str "ssrv", str "sdname", str "scname", str "scmd", str "sres");

KSR.ndb_mongodb.find()

int KSR.ndb_mongodb.find(str "ssrv", str "sdname", str "scname", str "scmd", str "sres");

KSR.ndb_mongodb.find_one()

int KSR.ndb_mongodb.find_one(str "ssrv", str "sdname", str "scname", str "scmd", str "sres");

KSR.ndb_mongodb.free_reply()

int KSR.ndb_mongodb.free_reply(str "name");

KSR.ndb_mongodb.next_reply()

int KSR.ndb_mongodb.next_reply(str "name");

ndb_redis

Exported functions:

KSR.ndb_redis.redis_cmd()

int KSR.ndb_redis.redis_cmd(str "srv", str "rcmd", str "sres");

KSR.ndb_redis.redis_cmd_p1()

int KSR.ndb_redis.redis_cmd_p1(str "srv", str "rcmd", str "p1", str "sres");

KSR.ndb_redis.redis_cmd_p2()

int KSR.ndb_redis.redis_cmd_p2(str "srv", str "rcmd", str "p1", str "p2", str "sres");

KSR.ndb_redis.redis_cmd_p3()

int KSR.ndb_redis.redis_cmd_p3(str "srv", str "rcmd", str "p1", str "p2", str "p3", str "sres");

KSR.ndb_redis.redis_free()

int KSR.ndb_redis.redis_free(str "name");

nghttp2

Exported functions:

KSR.nghttp2.nghttp2_reply()

int KSR.nghttp2.nghttp2_reply(str "rcode", str "sbody");

KSR.nghttp2.nghttp2_reply_header()

int KSR.nghttp2.nghttp2_reply_header(str "sname", str "sbody");

path

Exported functions:

KSR.path.add_path()

int KSR.path.add_path();

KSR.path.add_path_received()

int KSR.path.add_path_received();

KSR.path.add_path_received_user()

int KSR.path.add_path_received_user(str "_user");

KSR.path.add_path_received_user_params()

int KSR.path.add_path_received_user_params(str "_user", str "_params");

KSR.path.add_path_user()

int KSR.path.add_path_user(str "_user");

KSR.path.add_path_user_params()

int KSR.path.add_path_user_params(str "_user", str "_params");

pdb

Exported functions:

KSR.pdb.pdb_query()

int KSR.pdb.pdb_query(str "number", str "dstvar");

pdt

Exported functions:

KSR.pdt.pd_translate()

int KSR.pdt.pd_translate(str "sd", int md);

KSR.pdt.pprefix2domain()

int KSR.pdt.pprefix2domain(int m, int s);

permissions

Exported functions:

KSR.permissions.allow_address()

int KSR.permissions.allow_address(int addr_group, str "ips", int port);

KSR.permissions.allow_address_group()

int KSR.permissions.allow_address_group(str "_addr", int _port);

KSR.permissions.allow_source_address()

int KSR.permissions.allow_source_address(int addr_group);

KSR.permissions.allow_source_address_group()

int KSR.permissions.allow_source_address_group();

KSR.permissions.allow_trusted()

int KSR.permissions.allow_trusted();

phonenum

Exported functions:

KSR.phonenum.match()

int KSR.phonenum.match(str "tomatch", str "pvclass");

KSR.phonenum.match_cn()

int KSR.phonenum.match_cn(str "tomatch", str "cnc", str "pvclass");

pike

Exported functions:

KSR.pike.pike_check_ip()

int KSR.pike.pike_check_ip(str "strip");

KSR.pike.pike_check_req()

int KSR.pike.pike_check_req();

pipelimit

Exported functions:

KSR.pipelimit.pl_active()

int KSR.pipelimit.pl_active(str "pipeid");

KSR.pipelimit.pl_check()

int KSR.pipelimit.pl_check(str "pipeid");

KSR.pipelimit.pl_check_limit()

int KSR.pipelimit.pl_check_limit(str "pipeid", str "alg", int limit);

KSR.pipelimit.pl_drop()

int KSR.pipelimit.pl_drop();

KSR.pipelimit.pl_drop_range()

int KSR.pipelimit.pl_drop_range(int rmin, int rmax);

KSR.pipelimit.pl_drop_retry()

int KSR.pipelimit.pl_drop_retry(int rafter);

posops

Exported functions:

KSR.posops.pos_append()

int KSR.posops.pos_append(int idx, str "val");

KSR.posops.pos_body_end()

int KSR.posops.pos_body_end();

KSR.posops.pos_body_start()

int KSR.posops.pos_body_start();

KSR.posops.pos_find_str()

int KSR.posops.pos_find_str(int idx, str "val");

KSR.posops.pos_findi_str()

int KSR.posops.pos_findi_str(int idx, str "val");

KSR.posops.pos_headers_end()

int KSR.posops.pos_headers_end();

KSR.posops.pos_headers_start()

int KSR.posops.pos_headers_start();

KSR.posops.pos_insert()

int KSR.posops.pos_insert(int idx, str "val");

KSR.posops.pos_rfind_str()

int KSR.posops.pos_rfind_str(int idx, str "val");

KSR.posops.pos_rfindi_str()

int KSR.posops.pos_rfindi_str(int idx, str "val");

KSR.posops.pos_rm()

int KSR.posops.pos_rm(int idx, int len);

KSR.posops.pos_rsearch()

int KSR.posops.pos_rsearch(int idx, str "sre");

KSR.posops.pos_search()

int KSR.posops.pos_search(int idx, str "sre");

KSR.posops.pos_set_char()

int KSR.posops.pos_set_char(int idx, str "val");

prefix_route

Exported functions:

KSR.prefix_route.prefix_route()

int KSR.prefix_route.prefix_route(str "ruser");

KSR.prefix_route.prefix_route_uri()

int KSR.prefix_route.prefix_route_uri();

presence

Exported functions:

KSR.presence.handle_publish()

int KSR.presence.handle_publish();

KSR.presence.handle_publish_uri()

int KSR.presence.handle_publish_uri(str "sender_uri");

KSR.presence.handle_subscribe()

int KSR.presence.handle_subscribe();

KSR.presence.handle_subscribe_uri()

int KSR.presence.handle_subscribe_uri(str "wuri");

KSR.presence.pres_auth_status()

int KSR.presence.pres_auth_status(str "watcher_uri", str "presentity_uri");

KSR.presence.pres_has_subscribers()

int KSR.presence.pres_has_subscribers(str "pres_uri", str "wevent");

KSR.presence.pres_refresh_watchers()

int KSR.presence.pres_refresh_watchers(str "pres", str "event", int type);

KSR.presence.pres_refresh_watchers_file()

int KSR.presence.pres_refresh_watchers_file(str "pres", str "event", int type, str "file_uri", str "filename");

KSR.presence.pres_update_watchers()

int KSR.presence.pres_update_watchers(str "pres_uri", str "event");

presence_xml

Exported functions:

KSR.presence_xml.pres_check_activities()

int KSR.presence_xml.pres_check_activities(str "pres_uri", str "activity");

KSR.presence_xml.pres_check_basic()

int KSR.presence_xml.pres_check_basic(str "pres_uri", str "status");

pua

Exported functions:

KSR.pua.pua_set_publish()

int KSR.pua.pua_set_publish();

KSR.pua.pua_update_contact()

int KSR.pua.pua_update_contact();

pua_json

Exported functions:

KSR.pua_json.publish()

int KSR.pua_json.publish(str "pjson");

pv_headers

Exported functions:

KSR.pv_headers.pvh_append_header()

int KSR.pv_headers.pvh_append_header(str "hname", str "hvalue");

KSR.pv_headers.pvh_apply_headers()

int KSR.pv_headers.pvh_apply_headers();

KSR.pv_headers.pvh_check_header()

int KSR.pv_headers.pvh_check_header(str "hname");

KSR.pv_headers.pvh_collect_headers()

int KSR.pv_headers.pvh_collect_headers();

KSR.pv_headers.pvh_header_param_exists()

int KSR.pv_headers.pvh_header_param_exists(str "hname", str "hvalue");

KSR.pv_headers.pvh_modify_header()

int KSR.pv_headers.pvh_modify_header(str "hname", str "hvalue", int indx);

KSR.pv_headers.pvh_remove_header()

int KSR.pv_headers.pvh_remove_header(str "hname", int indx);

KSR.pv_headers.pvh_remove_header_param()

int KSR.pv_headers.pvh_remove_header_param(str "hname", str "toRemove");

KSR.pv_headers.pvh_reset_headers()

int KSR.pv_headers.pvh_reset_headers();

pvtpl

Exported functions:

KSR.pvtpl.pvtpl_render()

int KSR.pvtpl.pvtpl_render(str "tplname", str "opv");

pvx

Exported functions:

KSR.pvx.avp_get()

xval KSR.pvx.avp_get(str "xname");

KSR.pvx.avp_gete()

xval KSR.pvx.avp_gete(str "xname");

KSR.pvx.avp_getw()

xval KSR.pvx.avp_getw(str "xname");

KSR.pvx.avp_is_null()

int KSR.pvx.avp_is_null(str "xname");

KSR.pvx.avp_rm()

int KSR.pvx.avp_rm(str "xname");

KSR.pvx.avp_seti()

int KSR.pvx.avp_seti(str "xname", int vn);

KSR.pvx.avp_sets()

int KSR.pvx.avp_sets(str "xname", str "vs");

KSR.pvx.evalx()

int KSR.pvx.evalx(str "dst", str "fmt");

KSR.pvx.pv_var_to_xavp()

int KSR.pvx.pv_var_to_xavp(str "varname", str "xname");

KSR.pvx.pv_xavi_print()

int KSR.pvx.pv_xavi_print();

KSR.pvx.pv_xavp_print()

int KSR.pvx.pv_xavp_print();

KSR.pvx.pv_xavp_to_var()

int KSR.pvx.pv_xavp_to_var(str "xname");

KSR.pvx.pv_xavu_print()

int KSR.pvx.pv_xavu_print();

KSR.pvx.sbranch_append()

int KSR.pvx.sbranch_append();

KSR.pvx.sbranch_reset()

int KSR.pvx.sbranch_reset();

KSR.pvx.sbranch_set_ruri()

int KSR.pvx.sbranch_set_ruri();

KSR.pvx.shv_get()

xval KSR.pvx.shv_get(str "vname");

KSR.pvx.shv_seti()

int KSR.pvx.shv_seti(str "vname", int ival);

KSR.pvx.shv_sets()

int KSR.pvx.shv_sets(str "vname", str "sval");

KSR.pvx.shvinc_get()

xval KSR.pvx.shvinc_get(str "vname");

KSR.pvx.var_get()

xval KSR.pvx.var_get(str "vname");

KSR.pvx.var_seti()

int KSR.pvx.var_seti(str "vname", int ival);

KSR.pvx.var_sets()

int KSR.pvx.var_sets(str "vname", str "sval");

KSR.pvx.xavi_child_get()

xval KSR.pvx.xavi_child_get(str "rname", str "cname");

KSR.pvx.xavi_child_gete()

xval KSR.pvx.xavi_child_gete(str "rname", str "cname");

KSR.pvx.xavi_child_getw()

xval KSR.pvx.xavi_child_getw(str "rname", str "cname");

KSR.pvx.xavi_child_is_null()

int KSR.pvx.xavi_child_is_null(str "rname", str "cname");

KSR.pvx.xavi_child_rm()

int KSR.pvx.xavi_child_rm(str "rname", str "cname");

KSR.pvx.xavi_child_seti()

int KSR.pvx.xavi_child_seti(str "rname", str "cname", int ival);

KSR.pvx.xavi_child_sets()

int KSR.pvx.xavi_child_sets(str "rname", str "cname", str "sval");

KSR.pvx.xavi_get()

xval KSR.pvx.xavi_get(str "rname");

KSR.pvx.xavi_get_keys()

xval KSR.pvx.xavi_get_keys(str "rname", int indx);

KSR.pvx.xavi_getd()

xval KSR.pvx.xavi_getd(str "rname");

KSR.pvx.xavi_getd_p1()

xval KSR.pvx.xavi_getd_p1(str "rname", int indx);

KSR.pvx.xavi_gete()

xval KSR.pvx.xavi_gete(str "rname");

KSR.pvx.xavi_getw()

xval KSR.pvx.xavi_getw(str "rname");

KSR.pvx.xavi_is_null()

int KSR.pvx.xavi_is_null(str "rname");

KSR.pvx.xavi_rm()

int KSR.pvx.xavi_rm(str "rname");

KSR.pvx.xavi_rm_all()

int KSR.pvx.xavi_rm_all(str "rname");

KSR.pvx.xavi_seti()

int KSR.pvx.xavi_seti(str "rname", int ival);

KSR.pvx.xavi_sets()

int KSR.pvx.xavi_sets(str "rname", str "sval");

KSR.pvx.xavp_child_get()

xval KSR.pvx.xavp_child_get(str "rname", str "cname");

KSR.pvx.xavp_child_gete()

xval KSR.pvx.xavp_child_gete(str "rname", str "cname");

KSR.pvx.xavp_child_getw()

xval KSR.pvx.xavp_child_getw(str "rname", str "cname");

KSR.pvx.xavp_child_is_null()

int KSR.pvx.xavp_child_is_null(str "rname", str "cname");

KSR.pvx.xavp_child_rm()

int KSR.pvx.xavp_child_rm(str "rname", str "cname");

KSR.pvx.xavp_child_seti()

int KSR.pvx.xavp_child_seti(str "rname", str "cname", int ival);

KSR.pvx.xavp_child_sets()

int KSR.pvx.xavp_child_sets(str "rname", str "cname", str "sval");

KSR.pvx.xavp_copy()

int KSR.pvx.xavp_copy(str "src_name", int src_idx, str "dst_name");

KSR.pvx.xavp_copy_dst()

int KSR.pvx.xavp_copy_dst(str "src_name", int src_idx, str "dst_name", int dst_idx);

KSR.pvx.xavp_get()

xval KSR.pvx.xavp_get(str "rname");

KSR.pvx.xavp_get_keys()

xval KSR.pvx.xavp_get_keys(str "rname", int indx);

KSR.pvx.xavp_getd()

xval KSR.pvx.xavp_getd(str "rname");

KSR.pvx.xavp_getd_p1()

xval KSR.pvx.xavp_getd_p1(str "rname", int indx);

KSR.pvx.xavp_gete()

xval KSR.pvx.xavp_gete(str "rname");

KSR.pvx.xavp_getw()

xval KSR.pvx.xavp_getw(str "rname");

KSR.pvx.xavp_is_null()

int KSR.pvx.xavp_is_null(str "rname");

KSR.pvx.xavp_lshift()

int KSR.pvx.xavp_lshift(str "xname", int idx);

KSR.pvx.xavp_params_explode()

int KSR.pvx.xavp_params_explode(str "sparams", str "sxname");

KSR.pvx.xavp_params_implode()

int KSR.pvx.xavp_params_implode(str "sxname", str "svname");

KSR.pvx.xavp_params_implode_qval()

int KSR.pvx.xavp_params_implode_qval(str "sxname", str "svname");

KSR.pvx.xavp_push_dst()

int KSR.pvx.xavp_push_dst(str "xname");

KSR.pvx.xavp_rm()

int KSR.pvx.xavp_rm(str "rname");

KSR.pvx.xavp_rm_all()

int KSR.pvx.xavp_rm_all(str "rname");

KSR.pvx.xavp_seti()

int KSR.pvx.xavp_seti(str "rname", int ival);

KSR.pvx.xavp_sets()

int KSR.pvx.xavp_sets(str "rname", str "sval");

KSR.pvx.xavp_slist_explode()

int KSR.pvx.xavp_slist_explode(str "slist", str "sep", str "mode", str "sxname");

KSR.pvx.xavp_xparams_explode()

int KSR.pvx.xavp_xparams_explode(str "sparams", str "sep", str "sxname");

KSR.pvx.xavu_child_get()

xval KSR.pvx.xavu_child_get(str "rname", str "cname");

KSR.pvx.xavu_child_gete()

xval KSR.pvx.xavu_child_gete(str "rname", str "cname");

KSR.pvx.xavu_child_getw()

xval KSR.pvx.xavu_child_getw(str "rname", str "cname");

KSR.pvx.xavu_child_is_null()

int KSR.pvx.xavu_child_is_null(str "rname", str "cname");

KSR.pvx.xavu_child_rm()

int KSR.pvx.xavu_child_rm(str "rname", str "cname");

KSR.pvx.xavu_child_seti()

int KSR.pvx.xavu_child_seti(str "rname", str "cname", int ival);

KSR.pvx.xavu_child_sets()

int KSR.pvx.xavu_child_sets(str "rname", str "cname", str "sval");

KSR.pvx.xavu_get()

xval KSR.pvx.xavu_get(str "rname");

KSR.pvx.xavu_gete()

xval KSR.pvx.xavu_gete(str "rname");

KSR.pvx.xavu_getw()

xval KSR.pvx.xavu_getw(str "rname");

KSR.pvx.xavu_is_null()

int KSR.pvx.xavu_is_null(str "rname");

KSR.pvx.xavu_params_explode()

int KSR.pvx.xavu_params_explode(str "sparams", str "sxname");

KSR.pvx.xavu_params_implode()

int KSR.pvx.xavu_params_implode(str "sxname", str "svname");

KSR.pvx.xavu_rm()

int KSR.pvx.xavu_rm(str "rname");

KSR.pvx.xavu_seti()

int KSR.pvx.xavu_seti(str "rname", int ival);

KSR.pvx.xavu_sets()

int KSR.pvx.xavu_sets(str "rname", str "sval");

rabbitmq

Exported functions:

KSR.rabbitmq.publish()

int KSR.rabbitmq.publish(str "exchange", str "routingkey", str "contenttype", str "messagebody");

KSR.rabbitmq.publish_consume()

int KSR.rabbitmq.publish_consume(str "exchange", str "routingkey", str "contenttype", str "messagebody", str "dpv");

ratelimit

Exported functions:

KSR.ratelimit.rl_check()

int KSR.ratelimit.rl_check();

KSR.ratelimit.rl_check_pipe()

int KSR.ratelimit.rl_check_pipe(int pipe);

regex

Exported functions:

KSR.regex.pcre_match()

int KSR.regex.pcre_match(str "string", str "regex");

KSR.regex.pcre_match_group()

int KSR.regex.pcre_match_group(str "string", int num_pcre);

registrar

Exported functions:

KSR.registrar.add_sock_hdr()

int KSR.registrar.add_sock_hdr(str "hdr_name");

KSR.registrar.lookup()

int KSR.registrar.lookup(str "table");

KSR.registrar.lookup_branches()

int KSR.registrar.lookup_branches(str "_dtable");

KSR.registrar.lookup_to_dset()

int KSR.registrar.lookup_to_dset(str "table", str "uri");

KSR.registrar.lookup_uri()

int KSR.registrar.lookup_uri(str "table", str "uri");

KSR.registrar.lookup_xavp()

int KSR.registrar.lookup_xavp(str "utname", str "uri", str "rxname", str "cxname");

KSR.registrar.reg_fetch_contacts()

int KSR.registrar.reg_fetch_contacts(str "dtable", str "uri", str "profile");

KSR.registrar.reg_free_contacts()

int KSR.registrar.reg_free_contacts(str "profile");

KSR.registrar.reg_from_user()

int KSR.registrar.reg_from_user(str "utname", str "uri", int vmode);

KSR.registrar.reg_send_reply()

int KSR.registrar.reg_send_reply();

KSR.registrar.registered()

int KSR.registrar.registered(str "table");

KSR.registrar.registered_action()

int KSR.registrar.registered_action(str "_dtable", str "_uri", int _f, int _aflags);

KSR.registrar.registered_flags()

int KSR.registrar.registered_flags(str "_dtable", str "_uri", int _f);

KSR.registrar.registered_uri()

int KSR.registrar.registered_uri(str "_dtable", str "_uri");

KSR.registrar.save()

int KSR.registrar.save(str "table", int flags);

KSR.registrar.save_uri()

int KSR.registrar.save_uri(str "table", int flags, str "uri");

KSR.registrar.set_q_override()

int KSR.registrar.set_q_override(str "new_q");

KSR.registrar.ulc_cget()

xval KSR.registrar.ulc_cget(str "rid", str "attr", int idx);

KSR.registrar.ulc_rget()

xval KSR.registrar.ulc_rget(str "rid", str "attr");

KSR.registrar.unregister()

int KSR.registrar.unregister(str "_dtable", str "_uri");

KSR.registrar.unregister_ruid()

int KSR.registrar.unregister_ruid(str "_dtable", str "_uri", str "_ruid");

rls

Exported functions:

KSR.rls.handle_notify()

int KSR.rls.handle_notify();

KSR.rls.handle_subscribe()

int KSR.rls.handle_subscribe();

KSR.rls.handle_subscribe_uri()

int KSR.rls.handle_subscribe_uri(str "wuri");

KSR.rls.update_subs()

int KSR.rls.update_subs(str "uri", str "event");

rr

Exported functions:

KSR.rr.add_rr_param()

int KSR.rr.add_rr_param(str "sparam");

KSR.rr.check_route_param()

int KSR.rr.check_route_param(str "sre");

KSR.rr.is_direction()

int KSR.rr.is_direction(str "dir");

KSR.rr.loose_route()

int KSR.rr.loose_route();

KSR.rr.loose_route_mode()

int KSR.rr.loose_route_mode(int vmode);

KSR.rr.loose_route_preloaded()

int KSR.rr.loose_route_preloaded();

KSR.rr.next_hop_route()

int KSR.rr.next_hop_route();

KSR.rr.record_route()

int KSR.rr.record_route();

KSR.rr.record_route_advertised_address()

int KSR.rr.record_route_advertised_address(str "addr");

KSR.rr.record_route_params()

int KSR.rr.record_route_params(str "sparams");

KSR.rr.record_route_preset()

int KSR.rr.record_route_preset(str "addr1", str "addr2");

KSR.rr.record_route_preset_one()

int KSR.rr.record_route_preset_one(str "addr1");

KSR.rr.remove_record_route()

int KSR.rr.remove_record_route();

rtjson

Exported functions:

KSR.rtjson.init_routes()

int KSR.rtjson.init_routes(str "srdoc");

KSR.rtjson.next_route()

int KSR.rtjson.next_route();

KSR.rtjson.push_routes()

int KSR.rtjson.push_routes();

KSR.rtjson.update_branch()

int KSR.rtjson.update_branch();

rtpengine

This module enables media streams to be proxied via RTPEngine, exporting the functions to interact with it.

Exported functions:

KSR.rtpengine.block_dtmf()

int KSR.rtpengine.block_dtmf(str "flags");

KSR.rtpengine.block_dtmf0()

int KSR.rtpengine.block_dtmf0();

KSR.rtpengine.block_dtmf2()

int KSR.rtpengine.block_dtmf2(str "flags", str "viabranch");

KSR.rtpengine.block_media()

int KSR.rtpengine.block_media(str "flags");

KSR.rtpengine.block_media0()

int KSR.rtpengine.block_media0();

KSR.rtpengine.block_media2()

int KSR.rtpengine.block_media2(str "flags", str "viabranch");

KSR.rtpengine.play_dtmf()

int KSR.rtpengine.play_dtmf(str "flags");

KSR.rtpengine.play_media()

int KSR.rtpengine.play_media(str "flags");

KSR.rtpengine.play_media2()

int KSR.rtpengine.play_media2(str "flags", str "viabranch");

KSR.rtpengine.rtpengine_answer()

int KSR.rtpengine.rtpengine_answer(str "flags");

KSR.rtpengine.rtpengine_answer0()

int KSR.rtpengine.rtpengine_answer0();

KSR.rtpengine.rtpengine_answer2()

int KSR.rtpengine.rtpengine_answer2(str "flags", str "viabranch");

KSR.rtpengine.rtpengine_delete()

int KSR.rtpengine.rtpengine_delete(str "flags");

KSR.rtpengine.rtpengine_delete0()

int KSR.rtpengine.rtpengine_delete0();

KSR.rtpengine.rtpengine_delete2()

int KSR.rtpengine.rtpengine_delete2(str "flags", str "viabranch");

KSR.rtpengine.rtpengine_manage()

int KSR.rtpengine.rtpengine_manage(str "flags");

KSR.rtpengine.rtpengine_manage0()

int KSR.rtpengine.rtpengine_manage0();

KSR.rtpengine.rtpengine_manage2()

int KSR.rtpengine.rtpengine_manage2(str "flags", str "viabranch");

KSR.rtpengine.rtpengine_offer()

int KSR.rtpengine.rtpengine_offer(str "flags");

KSR.rtpengine.rtpengine_offer0()

int KSR.rtpengine.rtpengine_offer0();

KSR.rtpengine.rtpengine_offer2()

int KSR.rtpengine.rtpengine_offer2(str "flags", str "viabranch");

KSR.rtpengine.rtpengine_query()

int KSR.rtpengine.rtpengine_query(str "flags");

KSR.rtpengine.rtpengine_query0()

int KSR.rtpengine.rtpengine_query0();

KSR.rtpengine.rtpengine_query2()

int KSR.rtpengine.rtpengine_query2(str "flags", str "viabranch");

KSR.rtpengine.rtpengine_query_v()

int KSR.rtpengine.rtpengine_query_v(str "fmt", str "dpv");

KSR.rtpengine.rtpengine_subscribe_answer()

int KSR.rtpengine.rtpengine_subscribe_answer(str "flags");

KSR.rtpengine.rtpengine_subscribe_request()

int KSR.rtpengine.rtpengine_subscribe_request(str "flags", str "sdp_spv", str "to_tag_spv", str "stream_xavp");

KSR.rtpengine.rtpengine_unsubscribe()

int KSR.rtpengine.rtpengine_unsubscribe(str "flags");

KSR.rtpengine.set_rtpengine_set()

int KSR.rtpengine.set_rtpengine_set(int r1);

KSR.rtpengine.set_rtpengine_set2()

int KSR.rtpengine.set_rtpengine_set2(int r1, int r2);

This function is the sibling function to set_rtpengine_set(). The original module function is declared as set_rtpengine_set(setid[, setid2]).

In KEMI set_rtpengine_set() takes only the first parameter and set_rtpengine_set2() allows for the second optional parameter to be passed.

KSR.rtpengine.set_rtpengine_set2(2, 1);
KSR.rtpengine.rtpengine_offer();

Please review the documentation for set_rtpengine_set() for more information.

KSR.rtpengine.silence_media()

int KSR.rtpengine.silence_media(str "flags");

KSR.rtpengine.silence_media0()

int KSR.rtpengine.silence_media0();

KSR.rtpengine.silence_media2()

int KSR.rtpengine.silence_media2(str "flags", str "viabranch");

KSR.rtpengine.start_recording()

int KSR.rtpengine.start_recording();

KSR.rtpengine.stop_media()

int KSR.rtpengine.stop_media(str "flags");

KSR.rtpengine.stop_media0()

int KSR.rtpengine.stop_media0();

KSR.rtpengine.stop_media2()

int KSR.rtpengine.stop_media2(str "flags", str "viabranch");

KSR.rtpengine.stop_recording()

int KSR.rtpengine.stop_recording();

KSR.rtpengine.unblock_dtmf()

int KSR.rtpengine.unblock_dtmf(str "flags");

KSR.rtpengine.unblock_dtmf0()

int KSR.rtpengine.unblock_dtmf0();

KSR.rtpengine.unblock_dtmf2()

int KSR.rtpengine.unblock_dtmf2(str "flags", str "viabranch");

KSR.rtpengine.unblock_media()

int KSR.rtpengine.unblock_media(str "flags");

KSR.rtpengine.unblock_media0()

int KSR.rtpengine.unblock_media0();

KSR.rtpengine.unblock_media2()

int KSR.rtpengine.unblock_media2(str "flags", str "viabranch");

KSR.rtpengine.unsilence_media()

int KSR.rtpengine.unsilence_media(str "flags");

KSR.rtpengine.unsilence_media0()

int KSR.rtpengine.unsilence_media0();

KSR.rtpengine.unsilence_media2()

int KSR.rtpengine.unsilence_media2(str "flags", str "viabranch");

rtpproxy

Exported functions:

KSR.rtpproxy.rtpproxy_answer()

int KSR.rtpproxy.rtpproxy_answer(str "flags");

KSR.rtpproxy.rtpproxy_answer0()

int KSR.rtpproxy.rtpproxy_answer0();

KSR.rtpproxy.rtpproxy_answer_ip()

int KSR.rtpproxy.rtpproxy_answer_ip(str "flags", str "mip");

KSR.rtpproxy.rtpproxy_destroy()

int KSR.rtpproxy.rtpproxy_destroy(str "flags");

KSR.rtpproxy.rtpproxy_destroy0()

int KSR.rtpproxy.rtpproxy_destroy0();

KSR.rtpproxy.rtpproxy_manage()

int KSR.rtpproxy.rtpproxy_manage(str "flags");

KSR.rtpproxy.rtpproxy_manage0()

int KSR.rtpproxy.rtpproxy_manage0();

KSR.rtpproxy.rtpproxy_manage_ip()

int KSR.rtpproxy.rtpproxy_manage_ip(str "flags", str "mip");

KSR.rtpproxy.rtpproxy_offer()

int KSR.rtpproxy.rtpproxy_offer(str "flags");

KSR.rtpproxy.rtpproxy_offer0()

int KSR.rtpproxy.rtpproxy_offer0();

KSR.rtpproxy.rtpproxy_offer_ip()

int KSR.rtpproxy.rtpproxy_offer_ip(str "flags", str "mip");

KSR.rtpproxy.rtpproxy_stop_stream2uac()

int KSR.rtpproxy.rtpproxy_stop_stream2uac();

KSR.rtpproxy.rtpproxy_stop_stream2uas()

int KSR.rtpproxy.rtpproxy_stop_stream2uas();

KSR.rtpproxy.rtpproxy_stream2uac()

int KSR.rtpproxy.rtpproxy_stream2uac(str "pname", int count);

KSR.rtpproxy.rtpproxy_stream2uas()

int KSR.rtpproxy.rtpproxy_stream2uas(str "pname", int count);

KSR.rtpproxy.set_rtpproxy_set()

int KSR.rtpproxy.set_rtpproxy_set(int rset);

KSR.rtpproxy.start_recording()

int KSR.rtpproxy.start_recording();

ruxc

Exported functions:

KSR.ruxc.http_delete()

int KSR.ruxc.http_delete(str "url", str "body", str "hdrs", str "dpv");

KSR.ruxc.http_get()

int KSR.ruxc.http_get(str "url", str "hdrs", str "dpv");

KSR.ruxc.http_post()

int KSR.ruxc.http_post(str "url", str "body", str "hdrs", str "dpv");

sanity

Exported functions:

KSR.sanity.sanity_check()

int KSR.sanity.sanity_check(int mflags, int uflags);

KSR.sanity.sanity_check_defaults()

int KSR.sanity.sanity_check_defaults();

KSR.sanity.sanity_reply()

int KSR.sanity.sanity_reply();

sca

Exported functions:

KSR.sca.call_info_update()

int KSR.sca.call_info_update(int update_mask, str "uri_to", str "uri_from");

KSR.sca.call_info_update_default()

int KSR.sca.call_info_update_default();

KSR.sca.call_info_update_mask()

int KSR.sca.call_info_update_mask(int umask);

KSR.sca.call_info_update_turi()

int KSR.sca.call_info_update_turi(int umask, str "sto");

KSR.sca.handle_subscribe()

int KSR.sca.handle_subscribe();

sdpops

Exported functions:

KSR.sdpops.keep_codecs_by_id()

int KSR.sdpops.keep_codecs_by_id(str "codecs", str "media");

KSR.sdpops.keep_codecs_by_name()

int KSR.sdpops.keep_codecs_by_name(str "codecs", str "media");

KSR.sdpops.remove_codecs_by_id()

int KSR.sdpops.remove_codecs_by_id(str "codecs", str "media");

KSR.sdpops.remove_codecs_by_name()

int KSR.sdpops.remove_codecs_by_name(str "codecs", str "media");

KSR.sdpops.remove_line_by_prefix()

int KSR.sdpops.remove_line_by_prefix(str "prefix", str "media");

KSR.sdpops.remove_media()

int KSR.sdpops.remove_media(str "media");

KSR.sdpops.sdp_content()

int KSR.sdpops.sdp_content();

KSR.sdpops.sdp_content_flags()

int KSR.sdpops.sdp_content_flags(int flags);

KSR.sdpops.sdp_get()

int KSR.sdpops.sdp_get(str "avp");

KSR.sdpops.sdp_get_line_startswith()

int KSR.sdpops.sdp_get_line_startswith(str "aname", str "sline");

KSR.sdpops.sdp_iterator_append()

int KSR.sdpops.sdp_iterator_append(str "iname", str "text");

KSR.sdpops.sdp_iterator_end()

int KSR.sdpops.sdp_iterator_end(str "iname");

KSR.sdpops.sdp_iterator_insert()

int KSR.sdpops.sdp_iterator_insert(str "iname", str "text");

KSR.sdpops.sdp_iterator_next()

int KSR.sdpops.sdp_iterator_next(str "iname");

KSR.sdpops.sdp_iterator_rm()

int KSR.sdpops.sdp_iterator_rm(str "iname");

KSR.sdpops.sdp_iterator_start()

int KSR.sdpops.sdp_iterator_start(str "iname");

KSR.sdpops.sdp_iterator_value()

xval KSR.sdpops.sdp_iterator_value(str "iname");

KSR.sdpops.sdp_print()

int KSR.sdpops.sdp_print(int llevel);

KSR.sdpops.sdp_transport()

int KSR.sdpops.sdp_transport(str "avp");

KSR.sdpops.sdp_with_active_media()

int KSR.sdpops.sdp_with_active_media(str "media");

KSR.sdpops.sdp_with_codecs_by_id()

int KSR.sdpops.sdp_with_codecs_by_id(str "codecs");

KSR.sdpops.sdp_with_codecs_by_name()

int KSR.sdpops.sdp_with_codecs_by_name(str "codecs");

KSR.sdpops.sdp_with_ice()

int KSR.sdpops.sdp_with_ice();

KSR.sdpops.sdp_with_media()

int KSR.sdpops.sdp_with_media(str "media");

KSR.sdpops.sdp_with_transport()

int KSR.sdpops.sdp_with_transport(str "transport");

KSR.sdpops.sdp_with_transport_like()

int KSR.sdpops.sdp_with_transport_like(str "transport");

secfilter

Exported functions:

KSR.secfilter.secf_check_contact_hdr()

int KSR.secfilter.secf_check_contact_hdr();

KSR.secfilter.secf_check_country()

int KSR.secfilter.secf_check_country(str "val");

KSR.secfilter.secf_check_dst()

int KSR.secfilter.secf_check_dst(str "val");

KSR.secfilter.secf_check_from_hdr()

int KSR.secfilter.secf_check_from_hdr();

KSR.secfilter.secf_check_ip()

int KSR.secfilter.secf_check_ip();

KSR.secfilter.secf_check_sqli_all()

int KSR.secfilter.secf_check_sqli_all();

KSR.secfilter.secf_check_to_hdr()

int KSR.secfilter.secf_check_to_hdr();

KSR.secfilter.secf_check_ua()

int KSR.secfilter.secf_check_ua();

KSR.secfilter.secf_sqli_hdr()

int KSR.secfilter.secf_sqli_hdr(str "cval");

secsipid

Exported functions:

KSR.secsipid.result_str()

int KSR.secsipid.result_str(str "attrname", str "avpname");

KSR.secsipid.secsipid_add_identity()

int KSR.secsipid.secsipid_add_identity(str "origtn", str "desttn", str "attest", str "origid", str "x5u", str "keypath");

KSR.secsipid.secsipid_build_identity()

int KSR.secsipid.secsipid_build_identity(str "origtn", str "desttn", str "attest", str "origid", str "x5u", str "keypath");

KSR.secsipid.secsipid_build_identity_prvkey()

int KSR.secsipid.secsipid_build_identity_prvkey(str "origtn", str "desttn", str "attest", str "origid", str "x5u", str "keydata");

KSR.secsipid.secsipid_check()

int KSR.secsipid.secsipid_check(str "sidentity", str "keypath");

KSR.secsipid.secsipid_check_identity()

int KSR.secsipid.secsipid_check_identity(str "keypath");

KSR.secsipid.secsipid_check_identity_pubkey()

int KSR.secsipid.secsipid_check_identity_pubkey(str "keyval");

KSR.secsipid.secsipid_get_url()

xval KSR.secsipid.secsipid_get_url(str "surl");

KSR.secsipid.secsipid_get_val()

xval KSR.secsipid.secsipid_get_val();

KSR.secsipid.secsipid_sign()

int KSR.secsipid.secsipid_sign(str "sheaders", str "spayload", str "keypath");

KSR.secsipid.secsipid_sign_prvkey()

int KSR.secsipid.secsipid_sign_prvkey(str "sheaders", str "spayload", str "keydata");

KSR.secsipid.secsipid_verify()

int KSR.secsipid.secsipid_verify(str "sidentity", str "keyval", str "opts");

sipcapture

Exported functions:

KSR.sipcapture.float2int()

int KSR.sipcapture.float2int(str "_val", str "_coof");

KSR.sipcapture.report_capture()

int KSR.sipcapture.report_capture(str "_table");

KSR.sipcapture.report_capture_cid()

int KSR.sipcapture.report_capture_cid(str "_table", str "_cid");

KSR.sipcapture.report_capture_data()

int KSR.sipcapture.report_capture_data(str "_table", str "_cid", str "_data");

KSR.sipcapture.sip_capture()

int KSR.sipcapture.sip_capture();

KSR.sipcapture.sip_capture_forward()

int KSR.sipcapture.sip_capture_forward(str "puri");

KSR.sipcapture.sip_capture_mode()

int KSR.sipcapture.sip_capture_mode(str "_table", str "_cmdata");

KSR.sipcapture.sip_capture_table()

int KSR.sipcapture.sip_capture_table(str "_table");

sipdump

Exported functions:

KSR.sipdump.get_buf()

xval KSR.sipdump.get_buf();

KSR.sipdump.get_dst_ip()

xval KSR.sipdump.get_dst_ip();

KSR.sipdump.get_src_ip()

xval KSR.sipdump.get_src_ip();

KSR.sipdump.get_tag()

xval KSR.sipdump.get_tag();

KSR.sipdump.send()

int KSR.sipdump.send(str "stag");

sipjson

Exported functions:

KSR.sipjson.sj_serialize()

int KSR.sipjson.sj_serialize(str "smode", str "pvn");

siprepo

Exported functions:

KSR.siprepo.sr_msg_async_pull()

int KSR.siprepo.sr_msg_async_pull(str "callid", str "msgid", str "gname", str "rname", int rmode);

KSR.siprepo.sr_msg_check()

int KSR.siprepo.sr_msg_check();

KSR.siprepo.sr_msg_pull()

int KSR.siprepo.sr_msg_pull(str "callid", str "msgid", str "rname", int rmode);

KSR.siprepo.sr_msg_push()

int KSR.siprepo.sr_msg_push(str "msgid", int rmode);

KSR.siprepo.sr_msg_rm()

int KSR.siprepo.sr_msg_rm(str "callid", str "msgid");

sipt

Exported functions:

KSR.sipt.destination()

bool KSR.sipt.destination(str "_destination", str "_hops", str "_nai");

KSR.sipt.destination_terminator()

bool KSR.sipt.destination_terminator(str "_destination", str "_hops", str "_nai", str "_terminator");

KSR.sipt.forwarding()

bool KSR.sipt.forwarding(str "_fwdnumber", str "_nai");

KSR.sipt.has_isup_body()

bool KSR.sipt.has_isup_body();

KSR.sipt.set_bci_1()

bool KSR.sipt.set_bci_1(str "_charge_indicator", str "_called_status", str "_called_category", str "_e2e_indicator");

KSR.sipt.set_calling()

bool KSR.sipt.set_calling(str "_origin", str "_nai", str "_pres", str "_screen");

siptrace

Exported functions:

KSR.siptrace.hlog()

int KSR.siptrace.hlog(str "message");

KSR.siptrace.hlog_cid()

int KSR.siptrace.hlog_cid(str "correlationid", str "message");

KSR.siptrace.sip_trace()

int KSR.siptrace.sip_trace();

KSR.siptrace.sip_trace_dst()

int KSR.siptrace.sip_trace_dst(str "duri");

KSR.siptrace.sip_trace_dst_cid()

int KSR.siptrace.sip_trace_dst_cid(str "duri", str "cid");

KSR.siptrace.sip_trace_dst_cid_type()

int KSR.siptrace.sip_trace_dst_cid_type(str "duri", str "cid", str "sflag");

KSR.siptrace.sip_trace_mode()

int KSR.siptrace.sip_trace_mode(str "smode");

KSR.siptrace.sip_trace_msg()

int KSR.siptrace.sip_trace_msg(str "vmsg", str "saddr", str "taddr", str "duri", str "corrid");

siputils

Exported functions:

KSR.siputils.add_uri_param()

int KSR.siputils.add_uri_param(str "param");

KSR.siputils.cmp_aor()

int KSR.siputils.cmp_aor(str "uri1", str "uri2");

KSR.siputils.cmp_hdr_name()

int KSR.siputils.cmp_hdr_name(str "shname1", str "shname2");

KSR.siputils.cmp_uri()

int KSR.siputils.cmp_uri(str "uri1", str "uri2");

KSR.siputils.contact_param_check()

int KSR.siputils.contact_param_check(str "nparam");

KSR.siputils.contact_param_decode()

int KSR.siputils.contact_param_decode(str "nparam");

KSR.siputils.contact_param_decode_ruri()

int KSR.siputils.contact_param_decode_ruri(str "nparam");

KSR.siputils.contact_param_encode()

int KSR.siputils.contact_param_encode(str "nparam", str "saddr");

KSR.siputils.contact_param_encode_alias()

int KSR.siputils.contact_param_encode_alias(str "nparam", str "saddr");

KSR.siputils.contact_param_rm()

int KSR.siputils.contact_param_rm(str "nparam");

KSR.siputils.decode_contact()

int KSR.siputils.decode_contact();

KSR.siputils.decode_contact_header()

int KSR.siputils.decode_contact_header();

KSR.siputils.encode_contact()

int KSR.siputils.encode_contact(str "eprefix", str "eaddr");

KSR.siputils.has_totag()

int KSR.siputils.has_totag();

KSR.siputils.hdr_date_check()

int KSR.siputils.hdr_date_check(int tdiff);

KSR.siputils.is_alphanum()

int KSR.siputils.is_alphanum(str "tval");

KSR.siputils.is_alphanumex()

int KSR.siputils.is_alphanumex(str "tval", str "eset");

KSR.siputils.is_first_hop()

int KSR.siputils.is_first_hop();

KSR.siputils.is_first_hop_mode()

int KSR.siputils.is_first_hop_mode(int mode);

KSR.siputils.is_gruu()

int KSR.siputils.is_gruu();

KSR.siputils.is_http()

int KSR.siputils.is_http();

KSR.siputils.is_numeric()

int KSR.siputils.is_numeric(str "tval");

KSR.siputils.is_reply()

int KSR.siputils.is_reply();

KSR.siputils.is_request()

int KSR.siputils.is_request();

KSR.siputils.is_sip()

int KSR.siputils.is_sip();

KSR.siputils.is_tel_number()

int KSR.siputils.is_tel_number(str "tval");

KSR.siputils.is_uri()

int KSR.siputils.is_uri(str "suri");

KSR.siputils.is_user()

int KSR.siputils.is_user(str "suser");

KSR.siputils.options_reply()

int KSR.siputils.options_reply();

KSR.siputils.sip_parse_headers()

int KSR.siputils.sip_parse_headers();

KSR.siputils.uri_param()

int KSR.siputils.uri_param(str "sparam");

KSR.siputils.uri_param_any()

int KSR.siputils.uri_param_any(str "sparam");

KSR.siputils.uri_param_rm()

int KSR.siputils.uri_param_rm(str "sparam");

KSR.siputils.uri_param_value()

int KSR.siputils.uri_param_value(str "sparam", str "svalue");

sl

Exported functions:

KSR.sl.send_reply()

int KSR.sl.send_reply(int code, str "reason");

KSR.sl.send_reply_error()

int KSR.sl.send_reply_error();

KSR.sl.send_reply_mode()

int KSR.sl.send_reply_mode(int code, str "reason", int mode);

KSR.sl.sl_forward_reply()

int KSR.sl.sl_forward_reply(str "code", str "reason");

KSR.sl.sl_reply_error()

int KSR.sl.sl_reply_error();

KSR.sl.sl_send_reply()

int KSR.sl.sl_send_reply(int code, str "reason");

slack

Exported functions:

KSR.slack.slack_send()

int KSR.slack.slack_send(str "slmsg");

speeddial

Exported functions:

KSR.speeddial.lookup()

int KSR.speeddial.lookup(str "stable");

KSR.speeddial.lookup_owner()

int KSR.speeddial.lookup_owner(str "stable", str "sowner");

sqlops

Exported functions:

KSR.sqlops.sql_is_null()

int KSR.sqlops.sql_is_null(str "sres", int i, int j);

KSR.sqlops.sql_num_columns()

int KSR.sqlops.sql_num_columns(str "sres");

KSR.sqlops.sql_num_rows()

int KSR.sqlops.sql_num_rows(str "sres");

KSR.sqlops.sql_pvquery()

int KSR.sqlops.sql_pvquery(str "scon", str "squery", str "sres");

KSR.sqlops.sql_query()

int KSR.sqlops.sql_query(str "scon", str "squery", str "sres");

KSR.sqlops.sql_query_async()

int KSR.sqlops.sql_query_async(str "scon", str "squery");

KSR.sqlops.sql_result_free()

int KSR.sqlops.sql_result_free(str "sres");

KSR.sqlops.sql_result_get()

xval KSR.sqlops.sql_result_get(str "resid", int row, int col);

KSR.sqlops.sql_result_gete()

xval KSR.sqlops.sql_result_gete(str "resid", int row, int col);

KSR.sqlops.sql_result_getz()

xval KSR.sqlops.sql_result_getz(str "resid", int row, int col);

KSR.sqlops.sql_xquery()

int KSR.sqlops.sql_xquery(str "scon", str "squery", str "xavp");

ss7ops

Exported functions:

KSR.ss7ops.isup_to_json()

int KSR.ss7ops.isup_to_json(int proto);

sst

Exported functions:

KSR.sst.sst_check_min()

int KSR.sst.sst_check_min(int flag);

statistics

Exported functions:

KSR.statistics.reset_stat()

int KSR.statistics.reset_stat(str "sname");

KSR.statistics.update_stat()

int KSR.statistics.update_stat(str "sname", int sval);

statsc

Exported functions:

KSR.statsc.statsc_reset()

int KSR.statsc.statsc_reset();

statsd

Exported functions:

KSR.statsd.statsd_decr()

int KSR.statsd.statsd_decr(str "key");

KSR.statsd.statsd_gauge()

int KSR.statsd.statsd_gauge(str "key", str "val");

KSR.statsd.statsd_histogram()

int KSR.statsd.statsd_histogram(str "key", str "val");

KSR.statsd.statsd_incr()

int KSR.statsd.statsd_incr(str "key");

KSR.statsd.statsd_labels_decr()

int KSR.statsd.statsd_labels_decr(str "key", str "labels");

KSR.statsd.statsd_labels_gauge()

int KSR.statsd.statsd_labels_gauge(str "key", str "val", str "labels");

KSR.statsd.statsd_labels_histogram()

int KSR.statsd.statsd_labels_histogram(str "key", str "val", str "labels");

KSR.statsd.statsd_labels_incr()

int KSR.statsd.statsd_labels_incr(str "key", str "labels");

KSR.statsd.statsd_labels_set()

int KSR.statsd.statsd_labels_set(str "key", str "val", str "labels");

KSR.statsd.statsd_labels_stop()

int KSR.statsd.statsd_labels_stop(str "key", str "labels");

KSR.statsd.statsd_set()

int KSR.statsd.statsd_set(str "key", str "val");

KSR.statsd.statsd_start()

int KSR.statsd.statsd_start(str "key");

KSR.statsd.statsd_stop()

int KSR.statsd.statsd_stop(str "key");

stirshaken

Exported functions:

KSR.stirshaken.stirshaken_add_identity()

int KSR.stirshaken.stirshaken_add_identity(str "x5u", str "attest", str "origtn_val", str "desttn_val", str "origid");

KSR.stirshaken.stirshaken_add_identity_with_key()

int KSR.stirshaken.stirshaken_add_identity_with_key(str "x5u", str "attest", str "origtn_val", str "desttn_val", str "origid", str "keypath");

KSR.stirshaken.stirshaken_check_identity()

int KSR.stirshaken.stirshaken_check_identity();

KSR.stirshaken.stirshaken_check_identity_with_cert()

int KSR.stirshaken.stirshaken_check_identity_with_cert(str "cert_path");

KSR.stirshaken.stirshaken_check_identity_with_key()

int KSR.stirshaken.stirshaken_check_identity_with_key(str "keypath");

sworker

Exported functions:

KSR.sworker.active()

int KSR.sworker.active();

KSR.sworker.task()

int KSR.sworker.task(str "gname");

tcpops

Exported functions:

KSR.tcpops.tcp_close_connection()

int KSR.tcpops.tcp_close_connection();

KSR.tcpops.tcp_close_connection_id()

int KSR.tcpops.tcp_close_connection_id(int conid);

KSR.tcpops.tcp_con_alive()

int KSR.tcpops.tcp_con_alive(str "saddr");

KSR.tcpops.tcp_conid_alive()

int KSR.tcpops.tcp_conid_alive(int i_conid);

KSR.tcpops.tcp_conid_state()

int KSR.tcpops.tcp_conid_state(int i_conid);

KSR.tcpops.tcp_enable_closed_event()

int KSR.tcpops.tcp_enable_closed_event();

KSR.tcpops.tcp_enable_closed_event_cid()

int KSR.tcpops.tcp_enable_closed_event_cid(int i_conid);

KSR.tcpops.tcp_get_conid()

int KSR.tcpops.tcp_get_conid(str "saddr", str "pvs");

KSR.tcpops.tcp_keepalive_disable()

int KSR.tcpops.tcp_keepalive_disable();

KSR.tcpops.tcp_keepalive_disable_cid()

int KSR.tcpops.tcp_keepalive_disable_cid(int i_con);

KSR.tcpops.tcp_keepalive_enable()

int KSR.tcpops.tcp_keepalive_enable(int i_idle, int i_cnt, int i_intvl);

KSR.tcpops.tcp_keepalive_enable_cid()

int KSR.tcpops.tcp_keepalive_enable_cid(int i_con, int i_idle, int i_cnt, int i_intvl);

KSR.tcpops.tcp_set_connection_lifetime()

int KSR.tcpops.tcp_set_connection_lifetime(int i_time);

KSR.tcpops.tcp_set_connection_lifetime_cid()

int KSR.tcpops.tcp_set_connection_lifetime_cid(int i_conid, int i_time);

KSR.tcpops.tcp_set_otcpid()

int KSR.tcpops.tcp_set_otcpid(int vconid);

KSR.tcpops.tcp_set_otcpid_flag()

int KSR.tcpops.tcp_set_otcpid_flag(int vmode);

textops

Exported functions:

KSR.textops.append_body_part()

int KSR.textops.append_body_part(str "txt", str "ct");

KSR.textops.append_body_part_cd()

int KSR.textops.append_body_part_cd(str "txt", str "ct", str "cd");

KSR.textops.append_body_part_hex()

int KSR.textops.append_body_part_hex(str "txt", str "ct");

KSR.textops.append_body_part_hex_cd()

int KSR.textops.append_body_part_hex_cd(str "htxt", str "ct", str "cd");

KSR.textops.cmp_istr()

int KSR.textops.cmp_istr(str "s1", str "s2");

KSR.textops.cmp_str()

int KSR.textops.cmp_str(str "s1", str "s2");

KSR.textops.ends_with()

int KSR.textops.ends_with(str "vstr", str "vsuffix");

KSR.textops.filter_body()

int KSR.textops.filter_body(str "content_type");

KSR.textops.get_body_part()

int KSR.textops.get_body_part(str "ctype", str "pvname");

KSR.textops.get_body_part_raw()

int KSR.textops.get_body_part_raw(str "ctype", str "pvname");

KSR.textops.has_body()

int KSR.textops.has_body();

KSR.textops.has_body_type()

int KSR.textops.has_body_type(str "ctype");

KSR.textops.in_list()

int KSR.textops.in_list(str "subject", str "list", str "vsep");

KSR.textops.in_list_prefix()

int KSR.textops.in_list_prefix(str "subject", str "list", str "vsep");

KSR.textops.is_audio_on_hold()

int KSR.textops.is_audio_on_hold();

KSR.textops.is_present_hf()

int KSR.textops.is_present_hf(str "hname");

KSR.textops.is_present_hf_re()

int KSR.textops.is_present_hf_re(str "ematch");

KSR.textops.is_privacy()

int KSR.textops.is_privacy(str "privacy");

KSR.textops.regex_substring()

int KSR.textops.regex_substring(str "input", str "regex", int mindex, int nmatch, str "dst");

KSR.textops.remove_body_part()

int KSR.textops.remove_body_part(str "content_type");

KSR.textops.remove_hf()

int KSR.textops.remove_hf(str "hname");

KSR.textops.remove_hf_exp()

int KSR.textops.remove_hf_exp(str "ematch", str "eskip");

KSR.textops.remove_hf_idx()

int KSR.textops.remove_hf_idx(str "hname", int idx);

KSR.textops.remove_hf_match()

int KSR.textops.remove_hf_match(str "hname", str "op", str "expr");

KSR.textops.remove_hf_re()

int KSR.textops.remove_hf_re(str "ematch");

KSR.textops.replace()

int KSR.textops.replace(str "sre", str "sval");

KSR.textops.replace_all()

int KSR.textops.replace_all(str "sre", str "sval");

KSR.textops.replace_body()

int KSR.textops.replace_body(str "sre", str "sval");

KSR.textops.replace_body_all()

int KSR.textops.replace_body_all(str "sre", str "sval");

KSR.textops.replace_body_atonce()

int KSR.textops.replace_body_atonce(str "sre", str "sval");

KSR.textops.replace_body_str()

int KSR.textops.replace_body_str(str "mkey", str "rval", str "rmode");

KSR.textops.replace_hdrs()

int KSR.textops.replace_hdrs(str "sre", str "sval");

KSR.textops.replace_hdrs_str()

int KSR.textops.replace_hdrs_str(str "mkey", str "rval", str "rmode");

KSR.textops.replace_str()

int KSR.textops.replace_str(str "mkey", str "rval", str "rmode");

KSR.textops.search()

int KSR.textops.search(str "sre");

KSR.textops.search_append()

int KSR.textops.search_append(str "ematch", str "val");

KSR.textops.search_append_body()

int KSR.textops.search_append_body(str "ematch", str "val");

KSR.textops.search_body()

int KSR.textops.search_body(str "sre");

KSR.textops.search_hf()

int KSR.textops.search_hf(str "hname", str "sre", str "flags");

KSR.textops.search_str()

int KSR.textops.search_str(str "stext", str "sre");

KSR.textops.set_body()

int KSR.textops.set_body(str "nb", str "nc");

KSR.textops.set_body_multipart()

int KSR.textops.set_body_multipart(str "nbody", str "ctype", str "boundary");

KSR.textops.set_body_multipart_boundary()

int KSR.textops.set_body_multipart_boundary(str "boundary");

KSR.textops.set_body_multipart_content()

int KSR.textops.set_body_multipart_content(str "nbody", str "ctype");

KSR.textops.set_body_multipart_mode()

int KSR.textops.set_body_multipart_mode();

KSR.textops.set_reply_body()

int KSR.textops.set_reply_body(str "nb", str "nc");

KSR.textops.starts_with()

int KSR.textops.starts_with(str "s1", str "s2");

KSR.textops.str_all_in()

int KSR.textops.str_all_in(str "txt", str "clist");

KSR.textops.str_any_in()

int KSR.textops.str_any_in(str "txt", str "clist");

KSR.textops.str_find()

int KSR.textops.str_find(str "txt", str "needle");

KSR.textops.str_ifind()

int KSR.textops.str_ifind(str "txt", str "needle");

KSR.textops.subst()

int KSR.textops.subst(str "subst");

KSR.textops.subst_body()

int KSR.textops.subst_body(str "subst");

KSR.textops.subst_hf()

int KSR.textops.subst_hf(str "hname", str "subst", str "flags");

KSR.textops.subst_uri()

int KSR.textops.subst_uri(str "subst");

KSR.textops.subst_user()

int KSR.textops.subst_user(str "subst");

KSR.textops.subst_v()

int KSR.textops.subst_v(str "itext", str "subex", str "opv");

textopsx

Exported functions:

KSR.textopsx.append_hf_value()

int KSR.textopsx.append_hf_value(str "hexp", str "val");

KSR.textopsx.assign_hf_value()

int KSR.textopsx.assign_hf_value(str "hexp", str "val");

KSR.textopsx.assign_hf_value2()

int KSR.textopsx.assign_hf_value2(str "hexp", str "val");

KSR.textopsx.bl_iterator_append()

int KSR.textopsx.bl_iterator_append(str "iname", str "text");

KSR.textopsx.bl_iterator_end()

int KSR.textopsx.bl_iterator_end(str "iname");

KSR.textopsx.bl_iterator_insert()

int KSR.textopsx.bl_iterator_insert(str "iname", str "text");

KSR.textopsx.bl_iterator_next()

int KSR.textopsx.bl_iterator_next(str "iname");

KSR.textopsx.bl_iterator_rm()

int KSR.textopsx.bl_iterator_rm(str "iname");

KSR.textopsx.bl_iterator_start()

int KSR.textopsx.bl_iterator_start(str "iname");

KSR.textopsx.bl_iterator_value()

xval KSR.textopsx.bl_iterator_value(str "iname");

Return the content of the body line for the current position of the cursor, including the EoL.

It is an alternative to getting the line content via $blitval(iname).

KSR.textopsx.change_reply_status()

int KSR.textopsx.change_reply_status(int code, str "reason");

KSR.textopsx.change_reply_status_code()

int KSR.textopsx.change_reply_status_code(int code);

KSR.textopsx.exclude_hf_value()

int KSR.textopsx.exclude_hf_value(str "hexp", str "val");

KSR.textopsx.fnmatch()

int KSR.textopsx.fnmatch(str "val", str "match");

KSR.textopsx.fnmatch_ex()

int KSR.textopsx.fnmatch_ex(str "val", str "match", str "flags");

KSR.textopsx.hf_iterator_append()

int KSR.textopsx.hf_iterator_append(str "iname", str "htext");

KSR.textopsx.hf_iterator_end()

int KSR.textopsx.hf_iterator_end(str "iname");

KSR.textopsx.hf_iterator_hbody()

xval KSR.textopsx.hf_iterator_hbody(str "iname");

KSR.textopsx.hf_iterator_hname()

xval KSR.textopsx.hf_iterator_hname(str "iname");

KSR.textopsx.hf_iterator_insert()

int KSR.textopsx.hf_iterator_insert(str "iname", str "htext");

KSR.textopsx.hf_iterator_next()

int KSR.textopsx.hf_iterator_next(str "iname");

KSR.textopsx.hf_iterator_prev()

int KSR.textopsx.hf_iterator_prev(str "iname");

KSR.textopsx.hf_iterator_rm()

int KSR.textopsx.hf_iterator_rm(str "iname");

KSR.textopsx.hf_iterator_start()

int KSR.textopsx.hf_iterator_start(str "iname");

KSR.textopsx.hf_value_exists()

int KSR.textopsx.hf_value_exists(str "hexp", str "val");

KSR.textopsx.include_hf_value()

int KSR.textopsx.include_hf_value(str "hexp", str "val");

KSR.textopsx.insert_hf_value()

int KSR.textopsx.insert_hf_value(str "hexp", str "val");

KSR.textopsx.keep_hf()

int KSR.textopsx.keep_hf();

KSR.textopsx.keep_hf_re()

int KSR.textopsx.keep_hf_re(str "sre");

KSR.textopsx.msg_apply_changes()

int KSR.textopsx.msg_apply_changes();

KSR.textopsx.msg_set_buffer()

int KSR.textopsx.msg_set_buffer(str "obuf");

KSR.textopsx.remove_body()

int KSR.textopsx.remove_body();

KSR.textopsx.remove_hf_value()

int KSR.textopsx.remove_hf_value(str "hexp");

KSR.textopsx.remove_hf_value2()

int KSR.textopsx.remove_hf_value2(str "hexp", str "val");

timer

Exported functions:

KSR.timer.timer_enable()

int KSR.timer.timer_enable(str "timerid", int enable);

tls

Exported functions:

KSR.tls.cget()

xval KSR.tls.cget(str "aname");

Return values corresponding the pseudo-variables exported by TLS module, related to TLS connection and certificates. The parameter has to be the name of the pseudo-variable (without $).

Example:

local vPeerSubjectCn = KSR.tls.cget("tls_peer_subject_cn");

KSR.tls.cget()

xval KSR.tls.cget(str "aname");

Return values corresponding the pseudo-variables exported by TLS module, related to TLS connection and certificates. The parameter has to be the name of the pseudo-variable (without $).

Example:

local vPeerSubjectCn = KSR.tls.cget("tls_peer_subject_cn");

KSR.tls.is_peer_verified()

int KSR.tls.is_peer_verified();

KSR.tls.is_peer_verified()

int KSR.tls.is_peer_verified();

KSR.tls.set_connect_server_id()

int KSR.tls.set_connect_server_id(str "srvid");

KSR.tls.set_connect_server_id()

int KSR.tls.set_connect_server_id(str "srvid");

tm

Exported functions:

KSR.tm.ki_t_load_contacts_mode()

int KSR.tm.ki_t_load_contacts_mode(int mode);

KSR.tm.t_any_replied()

int KSR.tm.t_any_replied();

KSR.tm.t_any_timeout()

int KSR.tm.t_any_timeout();

KSR.tm.t_branch_replied()

int KSR.tm.t_branch_replied();

KSR.tm.t_branch_timeout()

int KSR.tm.t_branch_timeout();

KSR.tm.t_check_status()

int KSR.tm.t_check_status(str "sexp");

KSR.tm.t_check_trans()

int KSR.tm.t_check_trans();

KSR.tm.t_clean()

int KSR.tm.t_clean();

KSR.tm.t_drop_replies()

int KSR.tm.t_drop_replies(str "mode");

KSR.tm.t_drop_replies_all()

int KSR.tm.t_drop_replies_all();

KSR.tm.t_exists()

int KSR.tm.t_exists();

KSR.tm.t_get_branch_index()

int KSR.tm.t_get_branch_index();

KSR.tm.t_get_status_code()

int KSR.tm.t_get_status_code();

KSR.tm.t_grep_status()

int KSR.tm.t_grep_status(int code);

KSR.tm.t_is_canceled()

int KSR.tm.t_is_canceled();

KSR.tm.t_is_expired()

int KSR.tm.t_is_expired();

KSR.tm.t_is_retr_async_reply()

int KSR.tm.t_is_retr_async_reply();

KSR.tm.t_is_set()

int KSR.tm.t_is_set(str "target");

KSR.tm.t_load_contacts()

int KSR.tm.t_load_contacts();

KSR.tm.t_lookup_cancel()

int KSR.tm.t_lookup_cancel();

KSR.tm.t_lookup_cancel_flags()

int KSR.tm.t_lookup_cancel_flags(int flags);

KSR.tm.t_lookup_request()

int KSR.tm.t_lookup_request();

KSR.tm.t_newtran()

int KSR.tm.t_newtran();

KSR.tm.t_next_contact_flow()

int KSR.tm.t_next_contact_flow();

KSR.tm.t_next_contacts()

int KSR.tm.t_next_contacts();

KSR.tm.t_on_branch()

int KSR.tm.t_on_branch(str "rname");

KSR.tm.t_on_branch_failure()

int KSR.tm.t_on_branch_failure(str "rname");

KSR.tm.t_on_failure()

int KSR.tm.t_on_failure(str "rname");

KSR.tm.t_on_reply()

int KSR.tm.t_on_reply(str "rname");

KSR.tm.t_relay()

int KSR.tm.t_relay();

KSR.tm.t_relay_to_flags()

int KSR.tm.t_relay_to_flags(int rflags);

KSR.tm.t_relay_to_proto()

int KSR.tm.t_relay_to_proto(str "sproto");

KSR.tm.t_relay_to_proto_addr()

int KSR.tm.t_relay_to_proto_addr(str "sproto", str "host", int port);

KSR.tm.t_relay_to_proxy()

int KSR.tm.t_relay_to_proxy(str "sproxy");

KSR.tm.t_relay_to_proxy_flags()

int KSR.tm.t_relay_to_proxy_flags(str "sproxy", int rflags);

KSR.tm.t_release()

int KSR.tm.t_release();

KSR.tm.t_replicate()

int KSR.tm.t_replicate(str "suri");

KSR.tm.t_reply()

int KSR.tm.t_reply(int code, str "reason");

KSR.tm.t_reply_error()

int KSR.tm.t_reply_error();

KSR.tm.t_reset_fr()

int KSR.tm.t_reset_fr();

KSR.tm.t_reset_max_lifetime()

int KSR.tm.t_reset_max_lifetime();

KSR.tm.t_reset_retr()

int KSR.tm.t_reset_retr();

KSR.tm.t_retransmit_reply()

int KSR.tm.t_retransmit_reply();

KSR.tm.t_save_lumps()

int KSR.tm.t_save_lumps();

KSR.tm.t_send_reply()

int KSR.tm.t_send_reply(int code, str "reason");

KSR.tm.t_set_auto_inv_100()

int KSR.tm.t_set_auto_inv_100(int state);

KSR.tm.t_set_disable_6xx()

int KSR.tm.t_set_disable_6xx(int state);

KSR.tm.t_set_disable_failover()

int KSR.tm.t_set_disable_failover(int state);

KSR.tm.t_set_disable_internal_reply()

int KSR.tm.t_set_disable_internal_reply(int state);

KSR.tm.t_set_fr()

int KSR.tm.t_set_fr(int fr_inv, int fr);

KSR.tm.t_set_fr_inv()

int KSR.tm.t_set_fr_inv(int fr_inv);

KSR.tm.t_set_max_lifetime()

int KSR.tm.t_set_max_lifetime(int t1, int t2);

KSR.tm.t_set_no_e2e_cancel_reason()

int KSR.tm.t_set_no_e2e_cancel_reason(int state);

KSR.tm.t_set_retr()

int KSR.tm.t_set_retr(int t1, int t2);

KSR.tm.t_uac_send()

int KSR.tm.t_uac_send(str "method", str "ruri", str "nexthop", str "ssock", str "hdrs", str "body");

KSR.tm.t_use_uac_headers()

int KSR.tm.t_use_uac_headers();

tmrec

Exported functions:

KSR.tmrec.is_leap_year()

int KSR.tmrec.is_leap_year(int y);

KSR.tmrec.is_leap_year_now()

int KSR.tmrec.is_leap_year_now();

KSR.tmrec.match()

int KSR.tmrec.match(str "rv");

KSR.tmrec.match_timestamp()

int KSR.tmrec.match_timestamp(str "rv", int ti);

KSR.tmrec.time_period_match()

int KSR.tmrec.time_period_match(str "period");

KSR.tmrec.time_period_match_timestamp()

int KSR.tmrec.time_period_match_timestamp(str "period", int ti);

tmx

Exported functions:

KSR.tmx.t_cancel_branches()

int KSR.tmx.t_cancel_branches(str "mode");

KSR.tmx.t_cancel_callid()

int KSR.tmx.t_cancel_callid(str "callid_s", str "cseq_s", int fl);

KSR.tmx.t_cancel_callid_reason()

int KSR.tmx.t_cancel_callid_reason(str "callid_s", str "cseq_s", int fl, int rcode);

KSR.tmx.t_continue()

int KSR.tmx.t_continue(int tindex, int tlabel, str "cbname");

KSR.tmx.t_drop()

int KSR.tmx.t_drop();

KSR.tmx.t_drop_rcode()

int KSR.tmx.t_drop_rcode(int rcode);

KSR.tmx.t_flush_flags()

int KSR.tmx.t_flush_flags();

KSR.tmx.t_flush_xflags()

int KSR.tmx.t_flush_xflags();

KSR.tmx.t_is_branch_route()

int KSR.tmx.t_is_branch_route();

KSR.tmx.t_is_failure_route()

int KSR.tmx.t_is_failure_route();

KSR.tmx.t_is_reply_route()

int KSR.tmx.t_is_reply_route();

KSR.tmx.t_is_request_route()

int KSR.tmx.t_is_request_route();

KSR.tmx.t_precheck_trans()

int KSR.tmx.t_precheck_trans();

KSR.tmx.t_reply_callid()

int KSR.tmx.t_reply_callid(str "callid_s", str "cseq_s", int code, str "status_s");

KSR.tmx.t_reuse_branch()

int KSR.tmx.t_reuse_branch();

KSR.tmx.t_suspend()

int KSR.tmx.t_suspend();

topos

Exported functions:

KSR.topos.tps_set_context()

int KSR.topos.tps_set_context(str "ctx");

tsilo

Exported functions:

KSR.tsilo.ts_append()

int KSR.tsilo.ts_append(str "_table", str "_ruri");

KSR.tsilo.ts_append_by_contact()

int KSR.tsilo.ts_append_by_contact(str "_table", str "_ruri");

KSR.tsilo.ts_append_by_contact_uri()

int KSR.tsilo.ts_append_by_contact_uri(str "_table", str "_ruri", str "_contact");

KSR.tsilo.ts_append_to()

int KSR.tsilo.ts_append_to(int tindex, int tlabel, str "_table");

KSR.tsilo.ts_append_to_uri()

int KSR.tsilo.ts_append_to_uri(int tindex, int tlabel, str "_table", str "_uri");

KSR.tsilo.ts_store()

int KSR.tsilo.ts_store();

KSR.tsilo.ts_store_uri()

int KSR.tsilo.ts_store_uri(str "puri");

uac

Exported functions:

KSR.uac.uac_auth()

int KSR.uac.uac_auth();

KSR.uac.uac_auth_mode()

int KSR.uac.uac_auth_mode(int mode);

KSR.uac.uac_reg_disable()

int KSR.uac.uac_reg_disable(str "attr", str "val");

KSR.uac.uac_reg_enable()

int KSR.uac.uac_reg_enable(str "attr", str "val");

KSR.uac.uac_reg_lookup()

int KSR.uac.uac_reg_lookup(str "userid", str "sdst");

KSR.uac.uac_reg_lookup_uri()

int KSR.uac.uac_reg_lookup_uri(str "suri", str "sdst");

KSR.uac.uac_reg_refresh()

int KSR.uac.uac_reg_refresh(str "l_uuid");

KSR.uac.uac_reg_request_to()

int KSR.uac.uac_reg_request_to(str "userid", int imode);

KSR.uac.uac_reg_status()

int KSR.uac.uac_reg_status(str "sruuid");

KSR.uac.uac_replace_from()

int KSR.uac.uac_replace_from(str "pdsp", str "puri");

KSR.uac.uac_replace_from_uri()

int KSR.uac.uac_replace_from_uri(str "puri");

KSR.uac.uac_replace_to()

int KSR.uac.uac_replace_to(str "pdsp", str "puri");

KSR.uac.uac_replace_to_uri()

int KSR.uac.uac_replace_to_uri(str "puri");

KSR.uac.uac_req_send()

int KSR.uac.uac_req_send();

KSR.uac.uac_restore_from()

int KSR.uac.uac_restore_from();

KSR.uac.uac_restore_to()

int KSR.uac.uac_restore_to();

uac_redirect

Exported functions:

KSR.uac_redirect.get_redirects()

int KSR.uac_redirect.get_redirects(int max_c, int max_b);

KSR.uac_redirect.get_redirects_acc()

int KSR.uac_redirect.get_redirects_acc(int max_c, int max_b, str "reason");

KSR.uac_redirect.get_redirects_all()

int KSR.uac_redirect.get_redirects_all();

uri_db

Exported functions:

KSR.uri_db.check_from()

int KSR.uri_db.check_from();

KSR.uri_db.check_to()

int KSR.uri_db.check_to();

KSR.uri_db.check_uri()

int KSR.uri_db.check_uri(str "suri");

KSR.uri_db.check_uri_realm()

int KSR.uri_db.check_uri_realm(str "suri", str "susername", str "srealm");

KSR.uri_db.does_uri_exist()

int KSR.uri_db.does_uri_exist();

userblocklist

Exported functions:

KSR.userblocklist.check_allowlist()

int KSR.userblocklist.check_allowlist(str "stable");

KSR.userblocklist.check_blocklist()

int KSR.userblocklist.check_blocklist(str "stable");

KSR.userblocklist.check_global_blocklist()

int KSR.userblocklist.check_global_blocklist();

KSR.userblocklist.check_user_allowlist()

int KSR.userblocklist.check_user_allowlist(str "suser", str "sdomain");

KSR.userblocklist.check_user_allowlist_number()

int KSR.userblocklist.check_user_allowlist_number(str "suser", str "sdomain", str "snumber");

KSR.userblocklist.check_user_allowlist_table()

int KSR.userblocklist.check_user_allowlist_table(str "suser", str "sdomain", str "snumber", str "stable");

KSR.userblocklist.check_user_blocklist()

int KSR.userblocklist.check_user_blocklist(str "suser", str "sdomain");

KSR.userblocklist.check_user_blocklist_number()

int KSR.userblocklist.check_user_blocklist_number(str "suser", str "sdomain", str "snumber");

KSR.userblocklist.check_user_blocklist_table()

int KSR.userblocklist.check_user_blocklist_table(str "suser", str "sdomain", str "snumber", str "stable");

utils

Exported functions:

KSR.utils.xcap_auth_status()

int KSR.utils.xcap_auth_status(str "watcher_uri", str "presentity_uri");

uuid

Exported functions:

KSR.uuid.get()

xval KSR.uuid.get();

KSR.uuid.rget()

xval KSR.uuid.rget();

KSR.uuid.tget()

xval KSR.uuid.tget();

websocket

Exported functions:

KSR.websocket.close()

int KSR.websocket.close();

KSR.websocket.close_conid()

int KSR.websocket.close_conid(int status, str "reason", int con);

KSR.websocket.close_reason()

int KSR.websocket.close_reason(int status, str "reason");

KSR.websocket.handle_handshake()

int KSR.websocket.handle_handshake();

xcap_server

Exported functions:

KSR.xcap_server.xcaps_del()

int KSR.xcap_server.xcaps_del(str "uri", str "path");

KSR.xcap_server.xcaps_get()

int KSR.xcap_server.xcaps_get(str "uri", str "path");

KSR.xcap_server.xcaps_put()

int KSR.xcap_server.xcaps_put(str "uri", str "path", str "pbody");

xhttp

Exported functions:

KSR.xhttp.get_hu()

xval KSR.xhttp.get_hu();

KSR.xhttp.xhttp_reply()

int KSR.xhttp.xhttp_reply(int code, str "reason", str "ctype", str "body");

xhttp_pi

Exported functions:

KSR.xhttp_pi.dispatch()

int KSR.xhttp_pi.dispatch();

xhttp_prom

Exported functions:

KSR.xhttp_prom.check_uri()

int KSR.xhttp_prom.check_uri();

KSR.xhttp_prom.counter_inc_l0()

int KSR.xhttp_prom.counter_inc_l0(str "s_name", int number);

KSR.xhttp_prom.counter_inc_l1()

int KSR.xhttp_prom.counter_inc_l1(str "s_name", int number, str "l1");

KSR.xhttp_prom.counter_inc_l2()

int KSR.xhttp_prom.counter_inc_l2(str "s_name", int number, str "l1", str "l2");

KSR.xhttp_prom.counter_inc_l3()

int KSR.xhttp_prom.counter_inc_l3(str "s_name", int number, str "l1", str "l2", str "l3");

KSR.xhttp_prom.counter_reset_l0()

int KSR.xhttp_prom.counter_reset_l0(str "s_name");

KSR.xhttp_prom.counter_reset_l1()

int KSR.xhttp_prom.counter_reset_l1(str "s_name", str "l1");

KSR.xhttp_prom.counter_reset_l2()

int KSR.xhttp_prom.counter_reset_l2(str "s_name", str "l1", str "l2");

KSR.xhttp_prom.counter_reset_l3()

int KSR.xhttp_prom.counter_reset_l3(str "s_name", str "l1", str "l2", str "l3");

KSR.xhttp_prom.dispatch()

int KSR.xhttp_prom.dispatch();

KSR.xhttp_prom.gauge_reset_l0()

int KSR.xhttp_prom.gauge_reset_l0(str "s_name");

KSR.xhttp_prom.gauge_reset_l1()

int KSR.xhttp_prom.gauge_reset_l1(str "s_name", str "l1");

KSR.xhttp_prom.gauge_reset_l2()

int KSR.xhttp_prom.gauge_reset_l2(str "s_name", str "l1", str "l2");

KSR.xhttp_prom.gauge_reset_l3()

int KSR.xhttp_prom.gauge_reset_l3(str "s_name", str "l1", str "l2", str "l3");

KSR.xhttp_prom.gauge_set_l0()

int KSR.xhttp_prom.gauge_set_l0(str "s_name", str "s_number");

KSR.xhttp_prom.gauge_set_l1()

int KSR.xhttp_prom.gauge_set_l1(str "s_name", str "s_number", str "l1");

KSR.xhttp_prom.gauge_set_l2()

int KSR.xhttp_prom.gauge_set_l2(str "s_name", str "s_number", str "l1", str "l2");

KSR.xhttp_prom.gauge_set_l3()

int KSR.xhttp_prom.gauge_set_l3(str "s_name", str "s_number", str "l1", str "l2", str "l3");

KSR.xhttp_prom.histogram_observe_l0()

int KSR.xhttp_prom.histogram_observe_l0(str "s_name", str "s_number");

KSR.xhttp_prom.histogram_observe_l1()

int KSR.xhttp_prom.histogram_observe_l1(str "s_name", str "s_number", str "l1");

KSR.xhttp_prom.histogram_observe_l2()

int KSR.xhttp_prom.histogram_observe_l2(str "s_name", str "s_number", str "l1", str "l2");

KSR.xhttp_prom.histogram_observe_l3()

int KSR.xhttp_prom.histogram_observe_l3(str "s_name", str "s_number", str "l1", str "l2", str "l3");

xhttp_rpc

Exported functions:

KSR.xhttp_rpc.dispatch()

int KSR.xhttp_rpc.dispatch();

xlog

Exported functions:

KSR.xlog.xalert()

int KSR.xlog.xalert(str "lmsg");

KSR.xlog.xcrit()

int KSR.xlog.xcrit(str "lmsg");

KSR.xlog.xdbg()

int KSR.xlog.xdbg(str "lmsg");

KSR.xlog.xerr()

int KSR.xlog.xerr(str "lmsg");

KSR.xlog.xinfo()

int KSR.xlog.xinfo(str "lmsg");

KSR.xlog.xlog()

int KSR.xlog.xlog(str "slevel", str "lmsg");

KSR.xlog.xlog_facility()

int KSR.xlog.xlog_facility(str "lfacility", str "slevel", str "lmsg");

KSR.xlog.xnotice()

int KSR.xlog.xnotice(str "lmsg");

KSR.xlog.xwarn()

int KSR.xlog.xwarn(str "lmsg");

xmlrpc

Exported functions:

KSR.xmlrpc.dispatch_rpc()

int KSR.xmlrpc.dispatch_rpc();

KSR.xmlrpc.xmlrpc_reply()

int KSR.xmlrpc.xmlrpc_reply(int rcode, str "reason");