KEMI Module FunctionsLink

The following sections lists all exported KEMI functions. More information regarding the function can be found by clicking the KEMI prototype which will take you 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");

accLink

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

Exported functions:

KSR.acc.acc_db_request()Link

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()Link

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

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

KSR.acc.acc_request()Link

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

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

acc_radiusLink

Exported functions:

KSR.acc_radius.request()Link

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

alias_dbLink

Exported functions:

KSR.alias_db.lookup()Link

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

KSR.alias_db.lookup_ex()Link

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

app_jsdtLink

Exported functions:

KSR.app_jsdt.dofile()Link

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

KSR.app_jsdt.dostring()Link

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

KSR.app_jsdt.run()Link

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

KSR.app_jsdt.run_p1()Link

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

KSR.app_jsdt.run_p2()Link

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

KSR.app_jsdt.run_p3()Link

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

KSR.app_jsdt.runstring()Link

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

app_luaLink

Exported functions:

KSR.app_lua.dofile()Link

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

KSR.app_lua.dostring()Link

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

KSR.app_lua.run()Link

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

KSR.app_lua.run_p1()Link

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

KSR.app_lua.run_p2()Link

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

KSR.app_lua.run_p3()Link

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

KSR.app_lua.runstring()Link

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

app_pythonLink

Exported functions:

KSR.app_python.exec()Link

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

KSR.app_python.exec_p1()Link

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

KSR.app_python.execx()Link

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

app_python3Link

Exported functions:

KSR.app_python3.exec()Link

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

KSR.app_python3.exec_p1()Link

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

KSR.app_python3.execx()Link

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

app_python3sLink

Exported functions:

KSR.app_python3s.exec()Link

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

KSR.app_python3s.exec_p1()Link

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

KSR.app_python3s.execx()Link

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

app_rubyLink

Exported functions:

KSR.app_ruby.run()Link

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

KSR.app_ruby.run_p1()Link

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

KSR.app_ruby.run_p2()Link

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

KSR.app_ruby.run_p3()Link

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

app_sqlangLink

Exported functions:

KSR.app_sqlang.dofile()Link

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

KSR.app_sqlang.dostring()Link

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

KSR.app_sqlang.run()Link

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

KSR.app_sqlang.run_p1()Link

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

KSR.app_sqlang.run_p2()Link

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

KSR.app_sqlang.run_p3()Link

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

KSR.app_sqlang.runstring()Link

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

asyncLink

Exported functions:

KSR.async.get_data()Link

xval KSR.async.get_data();

KSR.async.get_gname()Link

xval KSR.async.get_gname();

KSR.async.ms_route()Link

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

KSR.async.route()Link

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

KSR.async.task_data()Link

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

KSR.async.task_group_data()Link

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

KSR.async.task_group_route()Link

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

KSR.async.task_route()Link

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

authLink

Exported functions:

KSR.auth.auth_challenge()Link

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

KSR.auth.auth_get_www_authenticate()Link

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

KSR.auth.consume_credentials()Link

int KSR.auth.consume_credentials();

KSR.auth.has_credentials()Link

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

KSR.auth.proxy_challenge()Link

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

KSR.auth.pv_auth_check()Link

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

KSR.auth.www_challenge()Link

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

auth_dbLink

Exported functions:

KSR.auth_db.auth_check()Link

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

KSR.auth_db.is_subscriber()Link

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

KSR.auth_db.www_authenticate()Link

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

KSR.auth_db.www_authenticate_method()Link

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

auth_ephemeralLink

Exported functions:

KSR.auth_ephemeral.autheph_authenticate()Link

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

KSR.auth_ephemeral.autheph_check()Link

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

KSR.auth_ephemeral.autheph_proxy()Link

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

KSR.auth_ephemeral.autheph_www()Link

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

KSR.auth_ephemeral.autheph_www_method()Link

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

auth_radiusLink

Exported functions:

KSR.auth_radius.proxy_authorize()Link

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

KSR.auth_radius.proxy_authorize_user()Link

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

KSR.auth_radius.www_authorize()Link

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

KSR.auth_radius.www_authorize_user()Link

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

auth_xkeysLink

Exported functions:

KSR.auth_xkeys.auth_xkeys_add()Link

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

KSR.auth_xkeys.auth_xkeys_check()Link

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

avpopsLink

Exported functions:

KSR.avpops.avp_check()Link

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

KSR.avpops.avp_copy()Link

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

benchmarkLink

Exported functions:

KSR.benchmark.bm_log_timer()Link

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

KSR.benchmark.bm_start_timer()Link

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

blstLink

Exported functions:

KSR.blst.blst_add()Link

int KSR.blst.blst_add(int t);

KSR.blst.blst_add_default()Link

int KSR.blst.blst_add_default();

KSR.blst.blst_add_retry_after()Link

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

KSR.blst.blst_clear_ignore()Link

int KSR.blst.blst_clear_ignore(int mask);

KSR.blst.blst_clear_ignore_all()Link

int KSR.blst.blst_clear_ignore_all();

KSR.blst.blst_del()Link

int KSR.blst.blst_del();

KSR.blst.blst_is_blocklisted()Link

int KSR.blst.blst_is_blocklisted();

KSR.blst.blst_rpl_clear_ignore()Link

int KSR.blst.blst_rpl_clear_ignore(int mask);

KSR.blst.blst_rpl_clear_ignore_all()Link

int KSR.blst.blst_rpl_clear_ignore_all();

KSR.blst.blst_rpl_set_ignore()Link

int KSR.blst.blst_rpl_set_ignore(int mask);

KSR.blst.blst_rpl_set_ignore_all()Link

int KSR.blst.blst_rpl_set_ignore_all();

KSR.blst.blst_set_ignore()Link

int KSR.blst.blst_set_ignore(int mask);

KSR.blst.blst_set_ignore_all()Link

int KSR.blst.blst_set_ignore_all();

call_controlLink

Exported functions:

KSR.call_control.call_control()Link

int KSR.call_control.call_control();

call_objLink

Exported functions:

KSR.call_obj.free()Link

int KSR.call_obj.free(int num_obj);

KSR.call_obj.get()Link

int KSR.call_obj.get();

carrierrouteLink

Exported functions:

KSR.carrierroute.cr_next_domain()Link

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()Link

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

KSR.carrierroute.cr_nofallback_route_info()Link

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()Link

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

KSR.carrierroute.cr_route_info()Link

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()Link

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

cfgutilsLink

Exported functions:

KSR.cfgutils.abort()Link

int KSR.cfgutils.abort();

KSR.cfgutils.check_route_exists()Link

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

KSR.cfgutils.core_hash()Link

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

KSR.cfgutils.lock()Link

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

KSR.cfgutils.pkg_status()Link

int KSR.cfgutils.pkg_status();

KSR.cfgutils.pkg_summary()Link

int KSR.cfgutils.pkg_summary();

KSR.cfgutils.rand_event()Link

int KSR.cfgutils.rand_event();

KSR.cfgutils.rand_get_prob()Link

int KSR.cfgutils.rand_get_prob();

KSR.cfgutils.rand_reset_prob()Link

int KSR.cfgutils.rand_reset_prob();

KSR.cfgutils.rand_set_prob()Link

int KSR.cfgutils.rand_set_prob(int percent_par);

KSR.cfgutils.route_if_exists()Link

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

KSR.cfgutils.shm_status()Link

int KSR.cfgutils.shm_status();

KSR.cfgutils.shm_summary()Link

int KSR.cfgutils.shm_summary();

KSR.cfgutils.sleep()Link

int KSR.cfgutils.sleep(int v);

KSR.cfgutils.trylock()Link

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

KSR.cfgutils.unlock()Link

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

KSR.cfgutils.usleep()Link

int KSR.cfgutils.usleep(int v);

cnxccLink

Exported functions:

KSR.cnxcc.get_channel_count()Link

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

KSR.cnxcc.set_max_channels()Link

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

KSR.cnxcc.set_max_credit()Link

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

KSR.cnxcc.set_max_time()Link

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

KSR.cnxcc.terminate_all()Link

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

KSR.cnxcc.update_max_time()Link

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

corexLink

Exported functions:

KSR.corex.append_branch()Link

int KSR.corex.append_branch();

KSR.corex.append_branch_uri()Link

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

KSR.corex.append_branch_uri_q()Link

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

KSR.corex.file_read()Link

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

KSR.corex.file_write()Link

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

KSR.corex.has_ruri_user()Link

int KSR.corex.has_ruri_user();

KSR.corex.has_user_agent()Link

int KSR.corex.has_user_agent();

KSR.corex.is_faked_msg()Link

int KSR.corex.is_faked_msg();

KSR.corex.is_socket_name()Link

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

KSR.corex.isxflagset()Link

int KSR.corex.isxflagset(int fval);

KSR.corex.resetxflag()Link

int KSR.corex.resetxflag(int fval);

KSR.corex.send_data()Link

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

KSR.corex.sendx()Link

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

KSR.corex.set_recv_socket()Link

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

KSR.corex.set_recv_socket_name()Link

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

KSR.corex.set_send_socket()Link

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

KSR.corex.set_send_socket_name()Link

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

KSR.corex.set_source_address()Link

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

KSR.corex.setxflag()Link

int KSR.corex.setxflag(int fval);

KSR.corex.via_add_srvid()Link

int KSR.corex.via_add_srvid(int fval);

KSR.corex.via_add_xavp_params()Link

int KSR.corex.via_add_xavp_params(int fval);

KSR.corex.via_use_xavp_fields()Link

int KSR.corex.via_use_xavp_fields(int fval);

countersLink

Exported functions:

KSR.counters.add()Link

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

KSR.counters.inc()Link

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

KSR.counters.reset()Link

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

cryptoLink

Exported functions:

KSR.crypto.aes_decrypt()Link

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

KSR.crypto.aes_encrypt()Link

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

KSR.crypto.hmac_sha256()Link

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

debuggerLink

Exported functions:

KSR.debugger.dbg_pv_dump()Link

int KSR.debugger.dbg_pv_dump();

KSR.debugger.dbg_pv_dump_ex()Link

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

dialogLink

Exported functions:

KSR.dialog.dlg_bridge()Link

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

KSR.dialog.dlg_bye()Link

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

KSR.dialog.dlg_db_load_callid()Link

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

KSR.dialog.dlg_db_load_extra()Link

int KSR.dialog.dlg_db_load_extra();

KSR.dialog.dlg_get()Link

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

KSR.dialog.dlg_get_var()Link

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

KSR.dialog.dlg_isflagset()Link

int KSR.dialog.dlg_isflagset(int val);

KSR.dialog.dlg_manage()Link

int KSR.dialog.dlg_manage();

KSR.dialog.dlg_reset_property()Link

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

KSR.dialog.dlg_resetflag()Link

int KSR.dialog.dlg_resetflag(int val);

KSR.dialog.dlg_set_property()Link

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

KSR.dialog.dlg_set_timeout()Link

int KSR.dialog.dlg_set_timeout(int to);

KSR.dialog.dlg_set_timeout_id()Link

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

KSR.dialog.dlg_set_var()Link

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

KSR.dialog.dlg_setflag()Link

int KSR.dialog.dlg_setflag(int val);

KSR.dialog.get_profile_size()Link

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

KSR.dialog.get_profile_size_static()Link

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

KSR.dialog.is_in_profile()Link

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

KSR.dialog.is_in_profile_static()Link

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

KSR.dialog.is_known_dlg()Link

int KSR.dialog.is_known_dlg();

KSR.dialog.set_dlg_profile()Link

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

KSR.dialog.set_dlg_profile_static()Link

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

KSR.dialog.unset_dlg_profile()Link

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

KSR.dialog.unset_dlg_profile_static()Link

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

KSR.dialog.var_get()Link

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

KSR.dialog.var_gete()Link

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

KSR.dialog.var_getw()Link

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

KSR.dialog.var_is_null()Link

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

KSR.dialog.var_rm()Link

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

KSR.dialog.var_sets()Link

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

dialplanLink

Exported functions:

KSR.dialplan.dp_match()Link

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

KSR.dialplan.dp_replace()Link

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

KSR.dialplan.dp_translate()Link

int KSR.dialplan.dp_translate(int id);

KSR.dialplan.dp_translate_vars()Link

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

dispatcherLink

Exported functions:

KSR.dispatcher.ds_is_active()Link

int KSR.dispatcher.ds_is_active(int set);

KSR.dispatcher.ds_is_active_uri()Link

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

KSR.dispatcher.ds_is_from_list()Link

int KSR.dispatcher.ds_is_from_list(int group);

KSR.dispatcher.ds_is_from_list_mode()Link

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

KSR.dispatcher.ds_is_from_list_uri()Link

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

KSR.dispatcher.ds_is_from_lists()Link

int KSR.dispatcher.ds_is_from_lists();

KSR.dispatcher.ds_list_exists()Link

int KSR.dispatcher.ds_list_exists(int set);

KSR.dispatcher.ds_load_unset()Link

int KSR.dispatcher.ds_load_unset();

KSR.dispatcher.ds_load_update()Link

int KSR.dispatcher.ds_load_update();

KSR.dispatcher.ds_mark_dst()Link

int KSR.dispatcher.ds_mark_dst();

KSR.dispatcher.ds_mark_dst_state()Link

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

KSR.dispatcher.ds_next_domain()Link

int KSR.dispatcher.ds_next_domain();

KSR.dispatcher.ds_next_dst()Link

int KSR.dispatcher.ds_next_dst();

KSR.dispatcher.ds_reload()Link

int KSR.dispatcher.ds_reload();

KSR.dispatcher.ds_select()Link

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

KSR.dispatcher.ds_select_domain()Link

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

KSR.dispatcher.ds_select_domain_limit()Link

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

KSR.dispatcher.ds_select_dst()Link

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

KSR.dispatcher.ds_select_dst_limit()Link

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

KSR.dispatcher.ds_select_limit()Link

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

KSR.dispatcher.ds_select_routes()Link

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

KSR.dispatcher.ds_select_routes_limit()Link

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

KSR.dispatcher.ds_set_domain()Link

int KSR.dispatcher.ds_set_domain();

KSR.dispatcher.ds_set_dst()Link

int KSR.dispatcher.ds_set_dst();

diversionLink

Exported functions:

KSR.diversion.add_diversion()Link

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

KSR.diversion.add_diversion_uri()Link

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

dlgsLink

Exported functions:

KSR.dlgs.dlgs_count()Link

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

KSR.dlgs.dlgs_init()Link

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

KSR.dlgs.dlgs_tags_add()Link

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

KSR.dlgs.dlgs_tags_count()Link

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

KSR.dlgs.dlgs_tags_rm()Link

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

KSR.dlgs.dlgs_update()Link

int KSR.dlgs.dlgs_update();

dmqLink

Exported functions:

KSR.dmq.bcast_message()Link

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

KSR.dmq.handle_message()Link

int KSR.dmq.handle_message();

KSR.dmq.handle_message_rc()Link

int KSR.dmq.handle_message_rc(int returnval);

KSR.dmq.is_from_node()Link

int KSR.dmq.is_from_node();

KSR.dmq.process_message()Link

int KSR.dmq.process_message();

KSR.dmq.process_message_rc()Link

int KSR.dmq.process_message_rc(int returnval);

KSR.dmq.send_message()Link

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

KSR.dmq.t_replicate()Link

int KSR.dmq.t_replicate();

KSR.dmq.t_replicate_mode()Link

int KSR.dmq.t_replicate_mode(int mode);

domainLink

Exported functions:

KSR.domain.is_domain_local()Link

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

KSR.domain.is_from_local()Link

int KSR.domain.is_from_local();

KSR.domain.is_uri_host_local()Link

int KSR.domain.is_uri_host_local();

KSR.domain.lookup_domain()Link

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

KSR.domain.lookup_domain_prefix()Link

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

droutingLink

Exported functions:

KSR.drouting.do_routing()Link

int KSR.drouting.do_routing(int grp_id);

KSR.drouting.do_routing_furi()Link

int KSR.drouting.do_routing_furi();

KSR.drouting.goes_to_gw()Link

int KSR.drouting.goes_to_gw();

KSR.drouting.goes_to_gw_type()Link

int KSR.drouting.goes_to_gw_type(int type);

KSR.drouting.is_from_gw()Link

int KSR.drouting.is_from_gw();

KSR.drouting.is_from_gw_type()Link

int KSR.drouting.is_from_gw_type(int type);

KSR.drouting.is_from_gw_type_flags()Link

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

KSR.drouting.next_routing()Link

int KSR.drouting.next_routing();

KSR.drouting.use_next_gw()Link

int KSR.drouting.use_next_gw();

enumLink

Exported functions:

KSR.enum.enum_i_query_suffix()Link

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

KSR.enum.enum_pv_query()Link

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

KSR.enum.enum_pv_query_suffix()Link

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

KSR.enum.enum_pv_query_suffix_service()Link

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

KSR.enum.enum_query()Link

int KSR.enum.enum_query();

KSR.enum.enum_query_suffix()Link

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

KSR.enum.enum_query_suffix_service()Link

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

KSR.enum.i_enum_query()Link

int KSR.enum.i_enum_query();

KSR.enum.i_enum_query_suffix_service()Link

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

KSR.enum.is_from_user_enum()Link

int KSR.enum.is_from_user_enum();

KSR.enum.is_from_user_enum_suffix()Link

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

KSR.enum.is_from_user_enum_suffix_service()Link

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

evapiLink

Exported functions:

KSR.evapi.async_multicast()Link

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

KSR.evapi.async_relay()Link

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

KSR.evapi.async_unicast()Link

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

KSR.evapi.close()Link

int KSR.evapi.close();

KSR.evapi.relay()Link

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

KSR.evapi.relay_multicast()Link

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

KSR.evapi.relay_unicast()Link

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

KSR.evapi.set_tag()Link

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

execLink

Exported functions:

KSR.exec.exec_avp()Link

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

KSR.exec.exec_cmd()Link

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

KSR.exec.exec_dset()Link

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

KSR.exec.exec_msg()Link

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

geoipLink

Exported functions:

KSR.geoip.match()Link

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

geoip2Link

Exported functions:

KSR.geoip2.match()Link

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

groupLink

Exported functions:

KSR.group.is_user_in()Link

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

htableLink

Functions exported by htable module.

Exported functions:

KSR.htable.sht_dec()Link

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()Link

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()Link

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()Link

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()Link

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()Link

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

KSR.htable.sht_iterator_end()Link

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

KSR.htable.sht_iterator_next()Link

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

KSR.htable.sht_iterator_rm()Link

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

KSR.htable.sht_iterator_setex()Link

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

KSR.htable.sht_iterator_seti()Link

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

KSR.htable.sht_iterator_sets()Link

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

KSR.htable.sht_iterator_start()Link

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

KSR.htable.sht_lock()Link

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

KSR.htable.sht_match_name()Link

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

KSR.htable.sht_match_str_value()Link

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

KSR.htable.sht_reset()Link

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

KSR.htable.sht_rm()Link

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

KSR.htable.sht_rm_name()Link

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

KSR.htable.sht_rm_name_re()Link

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

KSR.htable.sht_rm_value()Link

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

KSR.htable.sht_rm_value_re()Link

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

KSR.htable.sht_setex()Link

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

KSR.htable.sht_seti()Link

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

KSR.htable.sht_sets()Link

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

KSR.htable.sht_setxi()Link

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

KSR.htable.sht_setxs()Link

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

KSR.htable.sht_unlock()Link

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

http_async_clientLink

Exported functions:

KSR.http_async_client.query()Link

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

http_clientLink

Exported functions:

KSR.http_client.curl_connect()Link

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

KSR.http_client.curl_connect_post()Link

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

KSR.http_client.get_hdrs()Link

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

KSR.http_client.query()Link

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

KSR.http_client.query_post()Link

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

KSR.http_client.query_post_hdrs()Link

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

imcLink

Exported functions:

KSR.imc.imc_manager()Link

int KSR.imc.imc_manager();

ims_chargingLink

Exported functions:

KSR.ims_charging.Ro_CCR()Link

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()Link

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

KSR.ims_charging.Ro_set_session_id_avp()Link

int KSR.ims_charging.Ro_set_session_id_avp();

ims_diameter_serverLink

Exported functions:

KSR.ims_diameter_server.diameter_request()Link

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

KSR.ims_diameter_server.diameter_request_async()Link

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

ipopsLink

Exported functions:

KSR.ipops.compare_ips()Link

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

KSR.ipops.compare_pure_ips()Link

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

KSR.ipops.detailed_ip_type()Link

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

KSR.ipops.detailed_ipv4_type()Link

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

KSR.ipops.detailed_ipv6_type()Link

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

KSR.ipops.dns_int_match_ip()Link

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

KSR.ipops.dns_query()Link

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

KSR.ipops.dns_set_local_ttl()Link

int KSR.ipops.dns_set_local_ttl(int vttl);

KSR.ipops.dns_sys_match_ip()Link

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

KSR.ipops.ip_is_in_subnet()Link

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

KSR.ipops.ip_type()Link

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

KSR.ipops.is_in_subnet()Link

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

KSR.ipops.is_ip()Link

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

KSR.ipops.is_ip4()Link

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

KSR.ipops.is_ip6()Link

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

KSR.ipops.is_ip6_reference()Link

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

KSR.ipops.is_ip_rfc1918()Link

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

KSR.ipops.is_pure_ip()Link

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

KSR.ipops.naptr_query()Link

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

KSR.ipops.srv_query()Link

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

janssonLink

Exported functions:

KSR.jansson.get()Link

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

jsonrpcsLink

Exported functions:

KSR.jsonrpcs.dispatch()Link

int KSR.jsonrpcs.dispatch();

KSR.jsonrpcs.exec()Link

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

KSR.jsonrpcs.execx()Link

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

KSR.jsonrpcs.response()Link

xval KSR.jsonrpcs.response();

jwtLink

Exported functions:

KSR.jwt.jwt_generate()Link

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

KSR.jwt.jwt_generate_hdrs()Link

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

KSR.jwt.jwt_verify()Link

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

KSR.jwt.jwt_verify_key()Link

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

kafkaLink

Exported functions:

KSR.kafka.send()Link

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

KSR.kafka.send_key()Link

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

kazooLink

Exported functions:

KSR.kazoo.kazoo_publish()Link

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

KSR.kazoo.kazoo_subscribe()Link

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

keepaliveLink

Exported functions:

KSR.keepalive.add_destination()Link

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

KSR.keepalive.del_destination()Link

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

KSR.keepalive.is_alive()Link

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

kexLink

Exported functions:

KSR.kex.resetdebug()Link

int KSR.kex.resetdebug();

KSR.kex.setdebug()Link

int KSR.kex.setdebug(int lval);

kxLink

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()Link

xval KSR.kx.get_au();

KSR.kx.get_body()Link

xval KSR.kx.get_body();

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

KSR.kx.get_bodylen()Link

int KSR.kx.get_bodylen();

KSR.kx.get_callid()Link

xval KSR.kx.get_callid();

KSR.kx.get_conid()Link

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()Link

xval KSR.kx.get_cturi();

KSR.kx.get_def()Link

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

KSR.kx.get_defn()Link

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

KSR.kx.get_duri()Link

xval KSR.kx.get_duri();

Return the value of destination URI ($du).

KSR.kx.get_env()Link

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

KSR.kx.get_envn()Link

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

KSR.kx.get_fhost()Link

xval KSR.kx.get_fhost();

Return From-URI domain ($fd).

KSR.kx.get_furi()Link

xval KSR.kx.get_furi();

Return the From URI($fu).

KSR.kx.get_fuser()Link

xval KSR.kx.get_fuser();

Return the From-URI username ($fU).

KSR.kx.get_method()Link

xval KSR.kx.get_method();

Return the SIP method ($rm).

KSR.kx.get_msgbuf()Link

xval KSR.kx.get_msgbuf();

KSR.kx.get_msglen()Link

int KSR.kx.get_msglen();

KSR.kx.get_msgtype()Link

int KSR.kx.get_msgtype();

KSR.kx.get_nhuri()Link

xval KSR.kx.get_nhuri();

KSR.kx.get_ouri()Link

xval KSR.kx.get_ouri();

KSR.kx.get_proto()Link

xval KSR.kx.get_proto();

KSR.kx.get_protoid()Link

int KSR.kx.get_protoid();

KSR.kx.get_rcv_sock_name()Link

xval KSR.kx.get_rcv_sock_name();

KSR.kx.get_rcvaddr_sock()Link

xval KSR.kx.get_rcvaddr_sock();

KSR.kx.get_rcvadvip()Link

xval KSR.kx.get_rcvadvip();

KSR.kx.get_rcvadvport()Link

xval KSR.kx.get_rcvadvport();

KSR.kx.get_rcvip()Link

xval KSR.kx.get_rcvip();

KSR.kx.get_rcvport()Link

xval KSR.kx.get_rcvport();

KSR.kx.get_rhost()Link

xval KSR.kx.get_rhost();

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

KSR.kx.get_ruri()Link

xval KSR.kx.get_ruri();

Return the Request URI ($ru).

KSR.kx.get_ruser()Link

xval KSR.kx.get_ruser();

Return the Request URI user part ($rU).

KSR.kx.get_send_sock()Link

xval KSR.kx.get_send_sock();

KSR.kx.get_send_sock_name()Link

xval KSR.kx.get_send_sock_name();

KSR.kx.get_send_sock_port()Link

int KSR.kx.get_send_sock_port();

KSR.kx.get_srcaddr_sock()Link

xval KSR.kx.get_srcaddr_sock();

KSR.kx.get_srcip()Link

xval KSR.kx.get_srcip();

KSR.kx.get_srcport()Link

xval KSR.kx.get_srcport();

KSR.kx.get_srcuri()Link

xval KSR.kx.get_srcuri();

KSR.kx.get_status()Link

int KSR.kx.get_status();

KSR.kx.get_thost()Link

xval KSR.kx.get_thost();

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

KSR.kx.get_timestamp()Link

int KSR.kx.get_timestamp();

KSR.kx.get_turi()Link

xval KSR.kx.get_turi();

Return the To URI ($tu).

KSR.kx.get_tuser()Link

xval KSR.kx.get_tuser();

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

KSR.kx.get_ua()Link

xval KSR.kx.get_ua();

KSR.kx.gete_au()Link

xval KSR.kx.gete_au();

KSR.kx.gete_body()Link

xval KSR.kx.gete_body();

KSR.kx.gete_cturi()Link

xval KSR.kx.gete_cturi();

KSR.kx.gete_duri()Link

xval KSR.kx.gete_duri();

KSR.kx.gete_fhost()Link

xval KSR.kx.gete_fhost();

KSR.kx.gete_fuser()Link

xval KSR.kx.gete_fuser();

KSR.kx.gete_rhost()Link

xval KSR.kx.gete_rhost();

KSR.kx.gete_ruser()Link

xval KSR.kx.gete_ruser();

KSR.kx.gete_thost()Link

xval KSR.kx.gete_thost();

KSR.kx.gete_tuser()Link

xval KSR.kx.gete_tuser();

KSR.kx.gete_ua()Link

xval KSR.kx.gete_ua();

KSR.kx.gets_status()Link

xval KSR.kx.gets_status();

KSR.kx.getw_au()Link

xval KSR.kx.getw_au();

KSR.kx.getw_body()Link

xval KSR.kx.getw_body();

KSR.kx.getw_cturi()Link

xval KSR.kx.getw_cturi();

KSR.kx.getw_duri()Link

xval KSR.kx.getw_duri();

KSR.kx.getw_fhost()Link

xval KSR.kx.getw_fhost();

KSR.kx.getw_fuser()Link

xval KSR.kx.getw_fuser();

KSR.kx.getw_rhost()Link

xval KSR.kx.getw_rhost();

KSR.kx.getw_ruser()Link

xval KSR.kx.getw_ruser();

KSR.kx.getw_thost()Link

xval KSR.kx.getw_thost();

KSR.kx.getw_tuser()Link

xval KSR.kx.getw_tuser();

KSR.kx.getw_ua()Link

xval KSR.kx.getw_ua();

KSR.kx.ifdef()Link

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

KSR.kx.ifndef()Link

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

lcrLink

Exported functions:

KSR.lcr.defunct_gw()Link

int KSR.lcr.defunct_gw(int defunct_period);

KSR.lcr.from_any_gw()Link

int KSR.lcr.from_any_gw();

KSR.lcr.from_any_gw_addr()Link

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

KSR.lcr.from_any_gw_addr_port()Link

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

KSR.lcr.from_gw()Link

int KSR.lcr.from_gw(int lcr_id);

KSR.lcr.from_gw_addr()Link

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

KSR.lcr.from_gw_addr_port()Link

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

KSR.lcr.inactivate_gw()Link

int KSR.lcr.inactivate_gw();

KSR.lcr.load_gws()Link

int KSR.lcr.load_gws(int lcr_id);

KSR.lcr.load_gws_furi()Link

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

KSR.lcr.load_gws_ruser()Link

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

KSR.lcr.next_gw()Link

int KSR.lcr.next_gw();

KSR.lcr.to_any_gw()Link

int KSR.lcr.to_any_gw();

KSR.lcr.to_any_gw_addr()Link

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

KSR.lcr.to_gw()Link

int KSR.lcr.to_gw(int lcr_id);

KSR.lcr.to_gw_addr()Link

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

ldapLink

Exported functions:

KSR.ldap.result_next()Link

int KSR.ldap.result_next();

KSR.ldap.search()Link

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

log_customLink

Exported functions:

KSR.log_custom.log_udp()Link

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

log_systemdLink

Exported functions:

KSR.log_systemd.sd_journal_print()Link

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

KSR.log_systemd.sd_journal_send_xvap()Link

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

lwscLink

Exported functions:

KSR.lwsc.lwsc_notify()Link

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

KSR.lwsc.lwsc_notify_proto()Link

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

KSR.lwsc.lwsc_request()Link

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

KSR.lwsc.lwsc_request_proto()Link

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

maxfwdLink

Exported functions:

KSR.maxfwd.is_maxfwd_lt()Link

int KSR.maxfwd.is_maxfwd_lt(int limit);

KSR.maxfwd.process_maxfwd()Link

int KSR.maxfwd.process_maxfwd(int limit);

mediaproxyLink

Exported functions:

KSR.mediaproxy.end_media_session()Link

int KSR.mediaproxy.end_media_session();

KSR.mediaproxy.engage_media_proxy()Link

int KSR.mediaproxy.engage_media_proxy();

KSR.mediaproxy.use_media_proxy()Link

int KSR.mediaproxy.use_media_proxy();

misc_radiusLink

Exported functions:

KSR.misc_radius.does_uri_exist()Link

int KSR.misc_radius.does_uri_exist();

KSR.misc_radius.does_uri_exist_uval()Link

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

KSR.misc_radius.does_uri_user_exist()Link

int KSR.misc_radius.does_uri_user_exist();

KSR.misc_radius.does_uri_user_exist_uval()Link

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

KSR.misc_radius.is_user_in()Link

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

KSR.misc_radius.load_callee_avps()Link

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

KSR.misc_radius.load_caller_avps()Link

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

mqttLink

Exported functions:

KSR.mqtt.publish()Link

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

KSR.mqtt.subscribe()Link

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

KSR.mqtt.unsubscribe()Link

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

mqueueLink

Exported functions:

KSR.mqueue.mq_add()Link

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

KSR.mqueue.mq_fetch()Link

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

KSR.mqueue.mq_pv_free()Link

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

KSR.mqueue.mq_size()Link

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

KSR.mqueue.mqk_get()Link

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

KSR.mqueue.mqk_gete()Link

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

KSR.mqueue.mqk_getw()Link

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

KSR.mqueue.mqv_get()Link

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

KSR.mqueue.mqv_gete()Link

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

KSR.mqueue.mqv_getw()Link

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

msiloLink

Exported functions:

KSR.msilo.mdump()Link

int KSR.msilo.mdump();

KSR.msilo.mdump_uri()Link

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

KSR.msilo.mstore()Link

int KSR.msilo.mstore();

KSR.msilo.mstore_uri()Link

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

msrpLink

Exported functions:

KSR.msrp.cmap_lookup()Link

int KSR.msrp.cmap_lookup();

KSR.msrp.cmap_save()Link

int KSR.msrp.cmap_save();

KSR.msrp.is_reply()Link

int KSR.msrp.is_reply();

KSR.msrp.is_request()Link

int KSR.msrp.is_request();

KSR.msrp.relay()Link

int KSR.msrp.relay();

KSR.msrp.relay_flags()Link

int KSR.msrp.relay_flags(int rtflags);

KSR.msrp.reply()Link

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

KSR.msrp.reply_flags()Link

int KSR.msrp.reply_flags(int rtflags);

KSR.msrp.set_dst()Link

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

mtreeLink

Exported functions:

KSR.mtree.mt_match()Link

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

nat_traversalLink

Exported functions:

KSR.nat_traversal.client_nat_test()Link

int KSR.nat_traversal.client_nat_test(int tests);

KSR.nat_traversal.fix_contact()Link

int KSR.nat_traversal.fix_contact();

KSR.nat_traversal.nat_keepalive()Link

int KSR.nat_traversal.nat_keepalive();

nathelperLink

Exported functions:

KSR.nathelper.add_contact_alias()Link

int KSR.nathelper.add_contact_alias();

KSR.nathelper.add_contact_alias_addr()Link

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

KSR.nathelper.add_rcv_param()Link

int KSR.nathelper.add_rcv_param(int upos);

KSR.nathelper.fix_nated_contact()Link

int KSR.nathelper.fix_nated_contact();

KSR.nathelper.fix_nated_register()Link

int KSR.nathelper.fix_nated_register();

KSR.nathelper.fix_nated_sdp()Link

int KSR.nathelper.fix_nated_sdp(int level);

KSR.nathelper.fix_nated_sdp_ip()Link

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

KSR.nathelper.handle_ruri_alias()Link

int KSR.nathelper.handle_ruri_alias();

KSR.nathelper.handle_ruri_alias_mode()Link

int KSR.nathelper.handle_ruri_alias_mode(int mode);

KSR.nathelper.is_rfc1918()Link

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

KSR.nathelper.nat_uac_test()Link

int KSR.nathelper.nat_uac_test(int tests);

KSR.nathelper.set_alias_to_pv()Link

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

KSR.nathelper.set_contact_alias()Link

int KSR.nathelper.set_contact_alias();

KSR.nathelper.set_contact_alias_trim()Link

int KSR.nathelper.set_contact_alias_trim();

natsLink

Exported functions:

KSR.nats.publish()Link

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

KSR.nats.publish_request()Link

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

ndb_mongodbLink

Exported functions:

KSR.ndb_mongodb.exec()Link

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

KSR.ndb_mongodb.exec_simple()Link

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

KSR.ndb_mongodb.execx()Link

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

KSR.ndb_mongodb.find()Link

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

KSR.ndb_mongodb.find_one()Link

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

KSR.ndb_mongodb.free_reply()Link

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

KSR.ndb_mongodb.next_reply()Link

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

ndb_redisLink

Exported functions:

KSR.ndb_redis.redis_cmd()Link

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

KSR.ndb_redis.redis_cmd_p1()Link

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

KSR.ndb_redis.redis_cmd_p2()Link

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

KSR.ndb_redis.redis_cmd_p3()Link

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

KSR.ndb_redis.redis_free()Link

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

pathLink

Exported functions:

KSR.path.add_path()Link

int KSR.path.add_path();

KSR.path.add_path_received()Link

int KSR.path.add_path_received();

KSR.path.add_path_received_user()Link

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

KSR.path.add_path_received_user_params()Link

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

KSR.path.add_path_user()Link

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

KSR.path.add_path_user_params()Link

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

pdtLink

Exported functions:

KSR.pdt.pd_translate()Link

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

KSR.pdt.pprefix2domain()Link

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

permissionsLink

Exported functions:

KSR.permissions.allow_address()Link

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

KSR.permissions.allow_address_group()Link

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

KSR.permissions.allow_source_address()Link

int KSR.permissions.allow_source_address(int addr_group);

KSR.permissions.allow_source_address_group()Link

int KSR.permissions.allow_source_address_group();

KSR.permissions.allow_trusted()Link

int KSR.permissions.allow_trusted();

phonenumLink

Exported functions:

KSR.phonenum.match()Link

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

pikeLink

Exported functions:

KSR.pike.pike_check_ip()Link

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

KSR.pike.pike_check_req()Link

int KSR.pike.pike_check_req();

pipelimitLink

Exported functions:

KSR.pipelimit.pl_active()Link

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

KSR.pipelimit.pl_check()Link

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

KSR.pipelimit.pl_check_limit()Link

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

KSR.pipelimit.pl_drop()Link

int KSR.pipelimit.pl_drop();

KSR.pipelimit.pl_drop_range()Link

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

KSR.pipelimit.pl_drop_retry()Link

int KSR.pipelimit.pl_drop_retry(int rafter);

posopsLink

Exported functions:

KSR.posops.pos_append()Link

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

KSR.posops.pos_body_end()Link

int KSR.posops.pos_body_end();

KSR.posops.pos_body_start()Link

int KSR.posops.pos_body_start();

KSR.posops.pos_find_str()Link

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

KSR.posops.pos_findi_str()Link

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

KSR.posops.pos_headers_end()Link

int KSR.posops.pos_headers_end();

KSR.posops.pos_headers_start()Link

int KSR.posops.pos_headers_start();

KSR.posops.pos_insert()Link

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

KSR.posops.pos_rfind_str()Link

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

KSR.posops.pos_rfindi_str()Link

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

KSR.posops.pos_rm()Link

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

KSR.posops.pos_rsearch()Link

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

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

KSR.posops.pos_set_char()Link

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

prefix_routeLink

Exported functions:

KSR.prefix_route.prefix_route()Link

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

KSR.prefix_route.prefix_route_uri()Link

int KSR.prefix_route.prefix_route_uri();

presenceLink

Exported functions:

KSR.presence.handle_publish()Link

int KSR.presence.handle_publish();

KSR.presence.handle_publish_uri()Link

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

KSR.presence.handle_subscribe()Link

int KSR.presence.handle_subscribe();

KSR.presence.handle_subscribe_uri()Link

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

KSR.presence.pres_auth_status()Link

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

KSR.presence.pres_has_subscribers()Link

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

KSR.presence.pres_refresh_watchers()Link

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

KSR.presence.pres_refresh_watchers_file()Link

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

KSR.presence.pres_update_watchers()Link

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

presence_xmlLink

Exported functions:

KSR.presence_xml.pres_check_activities()Link

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

KSR.presence_xml.pres_check_basic()Link

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

puaLink

Exported functions:

KSR.pua.pua_set_publish()Link

int KSR.pua.pua_set_publish();

KSR.pua.pua_update_contact()Link

int KSR.pua.pua_update_contact();

pua_jsonLink

Exported functions:

KSR.pua_json.publish()Link

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

pv_headersLink

Exported functions:

KSR.pv_headers.pvh_append_header()Link

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

KSR.pv_headers.pvh_apply_headers()Link

int KSR.pv_headers.pvh_apply_headers();

KSR.pv_headers.pvh_check_header()Link

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

KSR.pv_headers.pvh_collect_headers()Link

int KSR.pv_headers.pvh_collect_headers();

KSR.pv_headers.pvh_header_param_exists()Link

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

KSR.pv_headers.pvh_modify_header()Link

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

KSR.pv_headers.pvh_remove_header()Link

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

KSR.pv_headers.pvh_remove_header_param()Link

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

KSR.pv_headers.pvh_reset_headers()Link

int KSR.pv_headers.pvh_reset_headers();

pvxLink

Exported functions:

KSR.pvx.avp_get()Link

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

KSR.pvx.avp_gete()Link

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

KSR.pvx.avp_getw()Link

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

KSR.pvx.avp_is_null()Link

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

KSR.pvx.avp_rm()Link

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

KSR.pvx.avp_seti()Link

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

KSR.pvx.avp_sets()Link

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

KSR.pvx.evalx()Link

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

KSR.pvx.pv_var_to_xavp()Link

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

KSR.pvx.pv_xavi_print()Link

int KSR.pvx.pv_xavi_print();

KSR.pvx.pv_xavp_print()Link

int KSR.pvx.pv_xavp_print();

KSR.pvx.pv_xavp_to_var()Link

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

KSR.pvx.pv_xavu_print()Link

int KSR.pvx.pv_xavu_print();

KSR.pvx.sbranch_append()Link

int KSR.pvx.sbranch_append();

KSR.pvx.sbranch_reset()Link

int KSR.pvx.sbranch_reset();

KSR.pvx.sbranch_set_ruri()Link

int KSR.pvx.sbranch_set_ruri();

KSR.pvx.shv_get()Link

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

KSR.pvx.shv_seti()Link

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

KSR.pvx.shv_sets()Link

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

KSR.pvx.shvinc_get()Link

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

KSR.pvx.var_get()Link

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

KSR.pvx.var_seti()Link

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

KSR.pvx.var_sets()Link

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

KSR.pvx.xavi_child_get()Link

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

KSR.pvx.xavi_child_gete()Link

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

KSR.pvx.xavi_child_getw()Link

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

KSR.pvx.xavi_child_is_null()Link

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

KSR.pvx.xavi_child_rm()Link

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

KSR.pvx.xavi_child_seti()Link

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

KSR.pvx.xavi_child_sets()Link

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

KSR.pvx.xavi_get()Link

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

KSR.pvx.xavi_get_keys()Link

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

KSR.pvx.xavi_getd()Link

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

KSR.pvx.xavi_getd_p1()Link

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

KSR.pvx.xavi_gete()Link

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

KSR.pvx.xavi_getw()Link

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

KSR.pvx.xavi_is_null()Link

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

KSR.pvx.xavi_rm()Link

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

KSR.pvx.xavi_seti()Link

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

KSR.pvx.xavi_sets()Link

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

KSR.pvx.xavp_child_get()Link

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

KSR.pvx.xavp_child_gete()Link

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

KSR.pvx.xavp_child_getw()Link

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

KSR.pvx.xavp_child_is_null()Link

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

KSR.pvx.xavp_child_rm()Link

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

KSR.pvx.xavp_child_seti()Link

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

KSR.pvx.xavp_child_sets()Link

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

KSR.pvx.xavp_copy()Link

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

KSR.pvx.xavp_copy_dst()Link

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

KSR.pvx.xavp_get()Link

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

KSR.pvx.xavp_get_keys()Link

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

KSR.pvx.xavp_getd()Link

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

KSR.pvx.xavp_getd_p1()Link

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

KSR.pvx.xavp_gete()Link

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

KSR.pvx.xavp_getw()Link

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

KSR.pvx.xavp_is_null()Link

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

KSR.pvx.xavp_lshift()Link

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

KSR.pvx.xavp_params_explode()Link

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

KSR.pvx.xavp_params_implode()Link

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

KSR.pvx.xavp_push_dst()Link

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

KSR.pvx.xavp_rm()Link

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

KSR.pvx.xavp_seti()Link

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

KSR.pvx.xavp_sets()Link

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

KSR.pvx.xavp_slist_explode()Link

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

KSR.pvx.xavu_child_get()Link

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

KSR.pvx.xavu_child_gete()Link

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

KSR.pvx.xavu_child_getw()Link

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

KSR.pvx.xavu_child_is_null()Link

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

KSR.pvx.xavu_child_rm()Link

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

KSR.pvx.xavu_child_seti()Link

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

KSR.pvx.xavu_child_sets()Link

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

KSR.pvx.xavu_get()Link

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

KSR.pvx.xavu_gete()Link

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

KSR.pvx.xavu_getw()Link

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

KSR.pvx.xavu_is_null()Link

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

KSR.pvx.xavu_params_explode()Link

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

KSR.pvx.xavu_params_implode()Link

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

KSR.pvx.xavu_rm()Link

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

KSR.pvx.xavu_seti()Link

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

KSR.pvx.xavu_sets()Link

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

rabbitmqLink

Exported functions:

KSR.rabbitmq.publish()Link

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

KSR.rabbitmq.publish_consume()Link

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

ratelimitLink

Exported functions:

KSR.ratelimit.rl_check()Link

int KSR.ratelimit.rl_check();

KSR.ratelimit.rl_check_pipe()Link

int KSR.ratelimit.rl_check_pipe(int pipe);

regexLink

Exported functions:

KSR.regex.pcre_match()Link

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

KSR.regex.pcre_match_group()Link

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

registrarLink

Exported functions:

KSR.registrar.add_sock_hdr()Link

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

KSR.registrar.lookup()Link

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

KSR.registrar.lookup_branches()Link

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

KSR.registrar.lookup_to_dset()Link

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

KSR.registrar.lookup_uri()Link

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

KSR.registrar.lookup_xavp()Link

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

KSR.registrar.reg_fetch_contacts()Link

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

KSR.registrar.reg_free_contacts()Link

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

KSR.registrar.reg_from_user()Link

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

KSR.registrar.reg_send_reply()Link

int KSR.registrar.reg_send_reply();

KSR.registrar.registered()Link

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

KSR.registrar.registered_action()Link

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

KSR.registrar.registered_flags()Link

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

KSR.registrar.registered_uri()Link

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

KSR.registrar.save()Link

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

KSR.registrar.save_uri()Link

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

KSR.registrar.set_q_override()Link

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

KSR.registrar.ulc_cget()Link

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

KSR.registrar.ulc_rget()Link

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

KSR.registrar.unregister()Link

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

KSR.registrar.unregister_ruid()Link

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

rlsLink

Exported functions:

KSR.rls.handle_notify()Link

int KSR.rls.handle_notify();

KSR.rls.handle_subscribe()Link

int KSR.rls.handle_subscribe();

KSR.rls.handle_subscribe_uri()Link

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

KSR.rls.update_subs()Link

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

rrLink

Exported functions:

KSR.rr.add_rr_param()Link

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

KSR.rr.check_route_param()Link

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

KSR.rr.is_direction()Link

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

KSR.rr.loose_route()Link

int KSR.rr.loose_route();

KSR.rr.loose_route_mode()Link

int KSR.rr.loose_route_mode(int vmode);

KSR.rr.loose_route_preloaded()Link

int KSR.rr.loose_route_preloaded();

KSR.rr.next_hop_route()Link

int KSR.rr.next_hop_route();

KSR.rr.record_route()Link

int KSR.rr.record_route();

KSR.rr.record_route_advertised_address()Link

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

KSR.rr.record_route_params()Link

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

KSR.rr.record_route_preset()Link

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

KSR.rr.record_route_preset_one()Link

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

KSR.rr.remove_record_route()Link

int KSR.rr.remove_record_route();

rtjsonLink

Exported functions:

KSR.rtjson.init_routes()Link

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

KSR.rtjson.next_route()Link

int KSR.rtjson.next_route();

KSR.rtjson.push_routes()Link

int KSR.rtjson.push_routes();

KSR.rtjson.update_branch()Link

int KSR.rtjson.update_branch();

rtpengineLink

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

Exported functions:

KSR.rtpengine.block_dtmf()Link

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

KSR.rtpengine.block_dtmf0()Link

int KSR.rtpengine.block_dtmf0();

KSR.rtpengine.block_media()Link

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

KSR.rtpengine.block_media0()Link

int KSR.rtpengine.block_media0();

KSR.rtpengine.play_media()Link

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

KSR.rtpengine.rtpengine_answer()Link

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

KSR.rtpengine.rtpengine_answer0()Link

int KSR.rtpengine.rtpengine_answer0();

KSR.rtpengine.rtpengine_delete()Link

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

KSR.rtpengine.rtpengine_delete0()Link

int KSR.rtpengine.rtpengine_delete0();

KSR.rtpengine.rtpengine_manage()Link

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

KSR.rtpengine.rtpengine_manage0()Link

int KSR.rtpengine.rtpengine_manage0();

KSR.rtpengine.rtpengine_offer()Link

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

KSR.rtpengine.rtpengine_offer0()Link

int KSR.rtpengine.rtpengine_offer0();

KSR.rtpengine.rtpengine_query()Link

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

KSR.rtpengine.rtpengine_query0()Link

int KSR.rtpengine.rtpengine_query0();

KSR.rtpengine.rtpengine_query_v()Link

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

KSR.rtpengine.set_rtpengine_set()Link

int KSR.rtpengine.set_rtpengine_set(int r1);

KSR.rtpengine.set_rtpengine_set2()Link

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()Link

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

KSR.rtpengine.silence_media0()Link

int KSR.rtpengine.silence_media0();

KSR.rtpengine.start_recording()Link

int KSR.rtpengine.start_recording();

KSR.rtpengine.stop_media()Link

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

KSR.rtpengine.stop_media0()Link

int KSR.rtpengine.stop_media0();

KSR.rtpengine.stop_recording()Link

int KSR.rtpengine.stop_recording();

KSR.rtpengine.unblock_dtmf()Link

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

KSR.rtpengine.unblock_dtmf0()Link

int KSR.rtpengine.unblock_dtmf0();

KSR.rtpengine.unblock_media()Link

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

KSR.rtpengine.unblock_media0()Link

int KSR.rtpengine.unblock_media0();

KSR.rtpengine.unsilence_media()Link

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

KSR.rtpengine.unsilence_media0()Link

int KSR.rtpengine.unsilence_media0();

rtpproxyLink

Exported functions:

KSR.rtpproxy.rtpproxy_answer()Link

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

KSR.rtpproxy.rtpproxy_answer0()Link

int KSR.rtpproxy.rtpproxy_answer0();

KSR.rtpproxy.rtpproxy_answer_ip()Link

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

KSR.rtpproxy.rtpproxy_destroy()Link

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

KSR.rtpproxy.rtpproxy_destroy0()Link

int KSR.rtpproxy.rtpproxy_destroy0();

KSR.rtpproxy.rtpproxy_manage()Link

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

KSR.rtpproxy.rtpproxy_manage0()Link

int KSR.rtpproxy.rtpproxy_manage0();

KSR.rtpproxy.rtpproxy_manage_ip()Link

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

KSR.rtpproxy.rtpproxy_offer()Link

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

KSR.rtpproxy.rtpproxy_offer0()Link

int KSR.rtpproxy.rtpproxy_offer0();

KSR.rtpproxy.rtpproxy_offer_ip()Link

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

KSR.rtpproxy.rtpproxy_stop_stream2uac()Link

int KSR.rtpproxy.rtpproxy_stop_stream2uac();

KSR.rtpproxy.rtpproxy_stop_stream2uas()Link

int KSR.rtpproxy.rtpproxy_stop_stream2uas();

KSR.rtpproxy.rtpproxy_stream2uac()Link

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

KSR.rtpproxy.rtpproxy_stream2uas()Link

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

KSR.rtpproxy.set_rtpproxy_set()Link

int KSR.rtpproxy.set_rtpproxy_set(int rset);

KSR.rtpproxy.start_recording()Link

int KSR.rtpproxy.start_recording();

ruxcLink

Exported functions:

KSR.ruxc.http_delete()Link

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

KSR.ruxc.http_get()Link

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

KSR.ruxc.http_post()Link

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

sanityLink

Exported functions:

KSR.sanity.sanity_check()Link

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

KSR.sanity.sanity_check_defaults()Link

int KSR.sanity.sanity_check_defaults();

KSR.sanity.sanity_reply()Link

int KSR.sanity.sanity_reply();

scaLink

Exported functions:

KSR.sca.call_info_update()Link

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

KSR.sca.call_info_update_default()Link

int KSR.sca.call_info_update_default();

KSR.sca.call_info_update_mask()Link

int KSR.sca.call_info_update_mask(int umask);

KSR.sca.call_info_update_turi()Link

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

KSR.sca.handle_subscribe()Link

int KSR.sca.handle_subscribe();

sdpopsLink

Exported functions:

KSR.sdpops.keep_codecs_by_id()Link

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

KSR.sdpops.keep_codecs_by_name()Link

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

KSR.sdpops.remove_codecs_by_id()Link

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

KSR.sdpops.remove_codecs_by_name()Link

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

KSR.sdpops.remove_line_by_prefix()Link

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

KSR.sdpops.remove_media()Link

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

KSR.sdpops.sdp_content()Link

int KSR.sdpops.sdp_content();

KSR.sdpops.sdp_content_flags()Link

int KSR.sdpops.sdp_content_flags(int flags);

KSR.sdpops.sdp_get()Link

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

KSR.sdpops.sdp_get_line_startswith()Link

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

KSR.sdpops.sdp_print()Link

int KSR.sdpops.sdp_print(int llevel);

KSR.sdpops.sdp_transport()Link

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

KSR.sdpops.sdp_with_active_media()Link

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

KSR.sdpops.sdp_with_codecs_by_id()Link

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

KSR.sdpops.sdp_with_codecs_by_name()Link

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

KSR.sdpops.sdp_with_ice()Link

int KSR.sdpops.sdp_with_ice();

KSR.sdpops.sdp_with_media()Link

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

KSR.sdpops.sdp_with_transport()Link

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

KSR.sdpops.sdp_with_transport_like()Link

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

secsipidLink

Exported functions:

KSR.secsipid.result_str()Link

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

KSR.secsipid.secsipid_add_identity()Link

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

KSR.secsipid.secsipid_build_identity()Link

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

KSR.secsipid.secsipid_build_identity_prvkey()Link

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

KSR.secsipid.secsipid_check()Link

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

KSR.secsipid.secsipid_check_identity()Link

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

KSR.secsipid.secsipid_check_identity_pubkey()Link

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

KSR.secsipid.secsipid_get_url()Link

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

KSR.secsipid.secsipid_get_val()Link

xval KSR.secsipid.secsipid_get_val();

sipcaptureLink

Exported functions:

KSR.sipcapture.float2int()Link

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

KSR.sipcapture.report_capture()Link

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

KSR.sipcapture.report_capture_cid()Link

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

KSR.sipcapture.report_capture_data()Link

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

KSR.sipcapture.sip_capture()Link

int KSR.sipcapture.sip_capture();

KSR.sipcapture.sip_capture_forward()Link

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

KSR.sipcapture.sip_capture_mode()Link

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

KSR.sipcapture.sip_capture_table()Link

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

sipdumpLink

Exported functions:

KSR.sipdump.get_buf()Link

xval KSR.sipdump.get_buf();

KSR.sipdump.get_dst_ip()Link

xval KSR.sipdump.get_dst_ip();

KSR.sipdump.get_src_ip()Link

xval KSR.sipdump.get_src_ip();

KSR.sipdump.get_tag()Link

xval KSR.sipdump.get_tag();

KSR.sipdump.send()Link

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

sipjsonLink

Exported functions:

KSR.sipjson.sj_serialize()Link

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

siprepoLink

Exported functions:

KSR.siprepo.sr_msg_async_pull()Link

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

KSR.siprepo.sr_msg_check()Link

int KSR.siprepo.sr_msg_check();

KSR.siprepo.sr_msg_pull()Link

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

KSR.siprepo.sr_msg_push()Link

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

KSR.siprepo.sr_msg_rm()Link

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

siptraceLink

Exported functions:

KSR.siptrace.hlog()Link

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

KSR.siptrace.hlog_cid()Link

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

KSR.siptrace.sip_trace()Link

int KSR.siptrace.sip_trace();

KSR.siptrace.sip_trace_dst()Link

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

KSR.siptrace.sip_trace_dst_cid()Link

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

KSR.siptrace.sip_trace_dst_cid_type()Link

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

KSR.siptrace.sip_trace_mode()Link

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

siputilsLink

Exported functions:

KSR.siputils.add_uri_param()Link

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

KSR.siputils.cmp_aor()Link

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

KSR.siputils.cmp_hdr_name()Link

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

KSR.siputils.cmp_uri()Link

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

KSR.siputils.contact_param_decode()Link

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

KSR.siputils.contact_param_decode_ruri()Link

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

KSR.siputils.contact_param_encode()Link

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

KSR.siputils.contact_param_rm()Link

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

KSR.siputils.decode_contact()Link

int KSR.siputils.decode_contact();

KSR.siputils.decode_contact_header()Link

int KSR.siputils.decode_contact_header();

KSR.siputils.encode_contact()Link

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

KSR.siputils.has_totag()Link

int KSR.siputils.has_totag();

KSR.siputils.hdr_date_check()Link

int KSR.siputils.hdr_date_check(int tdiff);

KSR.siputils.is_alphanum()Link

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

KSR.siputils.is_alphanumex()Link

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

KSR.siputils.is_first_hop()Link

int KSR.siputils.is_first_hop();

KSR.siputils.is_first_hop_mode()Link

int KSR.siputils.is_first_hop_mode(int mode);

KSR.siputils.is_gruu()Link

int KSR.siputils.is_gruu();

KSR.siputils.is_numeric()Link

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

KSR.siputils.is_reply()Link

int KSR.siputils.is_reply();

KSR.siputils.is_request()Link

int KSR.siputils.is_request();

KSR.siputils.is_tel_number()Link

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

KSR.siputils.is_uri()Link

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

KSR.siputils.is_user()Link

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

KSR.siputils.options_reply()Link

int KSR.siputils.options_reply();

KSR.siputils.uri_param()Link

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

KSR.siputils.uri_param_any()Link

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

KSR.siputils.uri_param_rm()Link

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

KSR.siputils.uri_param_value()Link

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

slLink

Exported functions:

KSR.sl.send_reply()Link

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

KSR.sl.send_reply_mode()Link

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

KSR.sl.sl_forward_reply()Link

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

KSR.sl.sl_reply_error()Link

int KSR.sl.sl_reply_error();

KSR.sl.sl_send_reply()Link

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

slackLink

Exported functions:

KSR.slack.slack_send()Link

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

speeddialLink

Exported functions:

KSR.speeddial.lookup()Link

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

KSR.speeddial.lookup_owner()Link

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

sqlopsLink

Exported functions:

KSR.sqlops.sql_is_null()Link

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

KSR.sqlops.sql_num_columns()Link

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

KSR.sqlops.sql_num_rows()Link

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

KSR.sqlops.sql_pvquery()Link

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

KSR.sqlops.sql_query()Link

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

KSR.sqlops.sql_query_async()Link

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

KSR.sqlops.sql_result_free()Link

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

KSR.sqlops.sql_result_get()Link

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

KSR.sqlops.sql_result_gete()Link

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

KSR.sqlops.sql_result_getz()Link

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

KSR.sqlops.sql_xquery()Link

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

ss7opsLink

Exported functions:

KSR.ss7ops.isup_to_json()Link

int KSR.ss7ops.isup_to_json(int proto);

sstLink

Exported functions:

KSR.sst.sst_check_min()Link

int KSR.sst.sst_check_min(int flag);

statisticsLink

Exported functions:

KSR.statistics.reset_stat()Link

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

KSR.statistics.update_stat()Link

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

statscLink

Exported functions:

KSR.statsc.statsc_reset()Link

int KSR.statsc.statsc_reset();

statsdLink

Exported functions:

KSR.statsd.statsd_decr()Link

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

KSR.statsd.statsd_gauge()Link

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

KSR.statsd.statsd_histogram()Link

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

KSR.statsd.statsd_incr()Link

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

KSR.statsd.statsd_set()Link

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

KSR.statsd.statsd_start()Link

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

KSR.statsd.statsd_stop()Link

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

stirshakenLink

Exported functions:

KSR.stirshaken.stirshaken_add_identity()Link

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()Link

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()Link

int KSR.stirshaken.stirshaken_check_identity();

KSR.stirshaken.stirshaken_check_identity_with_cert()Link

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

KSR.stirshaken.stirshaken_check_identity_with_key()Link

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

sworkerLink

Exported functions:

KSR.sworker.active()Link

int KSR.sworker.active();

KSR.sworker.task()Link

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

tcpopsLink

Exported functions:

KSR.tcpops.tcp_close_connection()Link

int KSR.tcpops.tcp_close_connection();

KSR.tcpops.tcp_close_connection_id()Link

int KSR.tcpops.tcp_close_connection_id(int conid);

KSR.tcpops.tcp_conid_alive()Link

int KSR.tcpops.tcp_conid_alive(int i_conid);

KSR.tcpops.tcp_conid_state()Link

int KSR.tcpops.tcp_conid_state(int i_conid);

KSR.tcpops.tcp_enable_closed_event()Link

int KSR.tcpops.tcp_enable_closed_event();

KSR.tcpops.tcp_enable_closed_event_cid()Link

int KSR.tcpops.tcp_enable_closed_event_cid(int i_conid);

KSR.tcpops.tcp_get_conid()Link

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

KSR.tcpops.tcp_keepalive_disable()Link

int KSR.tcpops.tcp_keepalive_disable();

KSR.tcpops.tcp_keepalive_disable_cid()Link

int KSR.tcpops.tcp_keepalive_disable_cid(int i_con);

KSR.tcpops.tcp_keepalive_enable()Link

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

KSR.tcpops.tcp_keepalive_enable_cid()Link

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()Link

int KSR.tcpops.tcp_set_connection_lifetime(int i_time);

KSR.tcpops.tcp_set_connection_lifetime_cid()Link

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

KSR.tcpops.tcp_set_otcpid()Link

int KSR.tcpops.tcp_set_otcpid(int vconid);

KSR.tcpops.tcp_set_otcpid_flag()Link

int KSR.tcpops.tcp_set_otcpid_flag(int vmode);

textopsLink

Exported functions:

KSR.textops.append_body_part()Link

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

KSR.textops.append_body_part_cd()Link

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

KSR.textops.append_body_part_hex()Link

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

KSR.textops.append_body_part_hex_cd()Link

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

KSR.textops.cmp_istr()Link

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

KSR.textops.cmp_str()Link

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

KSR.textops.ends_with()Link

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

KSR.textops.filter_body()Link

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

KSR.textops.get_body_part()Link

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

KSR.textops.get_body_part_raw()Link

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

KSR.textops.has_body()Link

int KSR.textops.has_body();

KSR.textops.has_body_type()Link

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

KSR.textops.in_list()Link

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

KSR.textops.in_list_prefix()Link

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

KSR.textops.is_audio_on_hold()Link

int KSR.textops.is_audio_on_hold();

KSR.textops.is_present_hf()Link

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

KSR.textops.is_present_hf_re()Link

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

KSR.textops.is_privacy()Link

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

KSR.textops.regex_substring()Link

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

KSR.textops.remove_body_part()Link

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

KSR.textops.remove_hf()Link

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

KSR.textops.remove_hf_exp()Link

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

KSR.textops.remove_hf_idx()Link

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

KSR.textops.remove_hf_match()Link

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

KSR.textops.remove_hf_re()Link

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

KSR.textops.replace()Link

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

KSR.textops.replace_all()Link

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

KSR.textops.replace_body()Link

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

KSR.textops.replace_body_all()Link

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

KSR.textops.replace_body_atonce()Link

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

KSR.textops.replace_body_str()Link

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

KSR.textops.replace_hdrs()Link

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

KSR.textops.replace_hdrs_str()Link

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

KSR.textops.replace_str()Link

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

KSR.textops.search()Link

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

KSR.textops.search_append()Link

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

KSR.textops.search_append_body()Link

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

KSR.textops.search_body()Link

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

KSR.textops.search_hf()Link

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

KSR.textops.search_str()Link

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

KSR.textops.set_body()Link

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

KSR.textops.set_body_multipart()Link

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

KSR.textops.set_body_multipart_boundary()Link

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

KSR.textops.set_body_multipart_content()Link

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

KSR.textops.set_body_multipart_mode()Link

int KSR.textops.set_body_multipart_mode();

KSR.textops.set_reply_body()Link

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

KSR.textops.starts_with()Link

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

KSR.textops.str_any_in()Link

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

KSR.textops.str_find()Link

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

KSR.textops.str_ifind()Link

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

KSR.textops.subst()Link

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

KSR.textops.subst_body()Link

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

KSR.textops.subst_hf()Link

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

KSR.textops.subst_uri()Link

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

KSR.textops.subst_user()Link

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

textopsxLink

Exported functions:

KSR.textopsx.append_hf_value()Link

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

KSR.textopsx.assign_hf_value()Link

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

KSR.textopsx.assign_hf_value2()Link

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

KSR.textopsx.bl_iterator_append()Link

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

KSR.textopsx.bl_iterator_end()Link

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

KSR.textopsx.bl_iterator_insert()Link

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

KSR.textopsx.bl_iterator_next()Link

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

KSR.textopsx.bl_iterator_rm()Link

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

KSR.textopsx.bl_iterator_start()Link

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

KSR.textopsx.bl_iterator_value()Link

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()Link

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

KSR.textopsx.change_reply_status_code()Link

int KSR.textopsx.change_reply_status_code(int code);

KSR.textopsx.exclude_hf_value()Link

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

KSR.textopsx.fnmatch()Link

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

KSR.textopsx.fnmatch_ex()Link

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

KSR.textopsx.hf_iterator_append()Link

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

KSR.textopsx.hf_iterator_end()Link

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

KSR.textopsx.hf_iterator_hbody()Link

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

KSR.textopsx.hf_iterator_hname()Link

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

KSR.textopsx.hf_iterator_insert()Link

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

KSR.textopsx.hf_iterator_next()Link

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

KSR.textopsx.hf_iterator_prev()Link

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

KSR.textopsx.hf_iterator_rm()Link

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

KSR.textopsx.hf_iterator_start()Link

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

KSR.textopsx.hf_value_exists()Link

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

KSR.textopsx.include_hf_value()Link

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

KSR.textopsx.insert_hf_value()Link

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

KSR.textopsx.keep_hf()Link

int KSR.textopsx.keep_hf();

KSR.textopsx.keep_hf_re()Link

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

KSR.textopsx.msg_apply_changes()Link

int KSR.textopsx.msg_apply_changes();

KSR.textopsx.msg_set_buffer()Link

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

KSR.textopsx.remove_body()Link

int KSR.textopsx.remove_body();

KSR.textopsx.remove_hf_value()Link

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

KSR.textopsx.remove_hf_value2()Link

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

tlsLink

Exported functions:

KSR.tls.cget()Link

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()Link

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()Link

int KSR.tls.is_peer_verified();

KSR.tls.is_peer_verified()Link

int KSR.tls.is_peer_verified();

KSR.tls.set_connect_server_id()Link

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

KSR.tls.set_connect_server_id()Link

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

tmLink

Exported functions:

KSR.tm.ki_t_load_contacts_mode()Link

int KSR.tm.ki_t_load_contacts_mode(int mode);

KSR.tm.t_any_replied()Link

int KSR.tm.t_any_replied();

KSR.tm.t_any_timeout()Link

int KSR.tm.t_any_timeout();

KSR.tm.t_branch_replied()Link

int KSR.tm.t_branch_replied();

KSR.tm.t_branch_timeout()Link

int KSR.tm.t_branch_timeout();

KSR.tm.t_check_status()Link

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

KSR.tm.t_check_trans()Link

int KSR.tm.t_check_trans();

KSR.tm.t_clean()Link

int KSR.tm.t_clean();

KSR.tm.t_drop_replies()Link

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

KSR.tm.t_drop_replies_all()Link

int KSR.tm.t_drop_replies_all();

KSR.tm.t_exists()Link

int KSR.tm.t_exists();

KSR.tm.t_get_branch_index()Link

int KSR.tm.t_get_branch_index();

KSR.tm.t_get_status_code()Link

int KSR.tm.t_get_status_code();

KSR.tm.t_grep_status()Link

int KSR.tm.t_grep_status(int code);

KSR.tm.t_is_canceled()Link

int KSR.tm.t_is_canceled();

KSR.tm.t_is_expired()Link

int KSR.tm.t_is_expired();

KSR.tm.t_is_retr_async_reply()Link

int KSR.tm.t_is_retr_async_reply();

KSR.tm.t_is_set()Link

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

KSR.tm.t_load_contacts()Link

int KSR.tm.t_load_contacts();

KSR.tm.t_lookup_cancel()Link

int KSR.tm.t_lookup_cancel();

KSR.tm.t_lookup_cancel_flags()Link

int KSR.tm.t_lookup_cancel_flags(int flags);

KSR.tm.t_lookup_request()Link

int KSR.tm.t_lookup_request();

KSR.tm.t_newtran()Link

int KSR.tm.t_newtran();

KSR.tm.t_next_contact_flow()Link

int KSR.tm.t_next_contact_flow();

KSR.tm.t_next_contacts()Link

int KSR.tm.t_next_contacts();

KSR.tm.t_on_branch()Link

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

KSR.tm.t_on_branch_failure()Link

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

KSR.tm.t_on_failure()Link

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

KSR.tm.t_on_reply()Link

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

KSR.tm.t_relay()Link

int KSR.tm.t_relay();

KSR.tm.t_relay_to_flags()Link

int KSR.tm.t_relay_to_flags(int rflags);

KSR.tm.t_relay_to_proto()Link

int KSR.tm.t_relay_to_proto(str "sproto");

KSR.tm.t_relay_to_proto_addr()Link

int KSR.tm.t_relay_to_proto_addr(str "sproto", str "host", int port);

KSR.tm.t_relay_to_proxy()Link

int KSR.tm.t_relay_to_proxy(str "sproxy");

KSR.tm.t_relay_to_proxy_flags()Link

int KSR.tm.t_relay_to_proxy_flags(str "sproxy", int rflags);

KSR.tm.t_release()Link

int KSR.tm.t_release();

KSR.tm.t_replicate()Link

int KSR.tm.t_replicate(str "suri");

KSR.tm.t_reply()Link

int KSR.tm.t_reply(int code, str "reason");

KSR.tm.t_reset_fr()Link

int KSR.tm.t_reset_fr();

KSR.tm.t_reset_max_lifetime()Link

int KSR.tm.t_reset_max_lifetime();

KSR.tm.t_reset_retr()Link

int KSR.tm.t_reset_retr();

KSR.tm.t_retransmit_reply()Link

int KSR.tm.t_retransmit_reply();

KSR.tm.t_save_lumps()Link

int KSR.tm.t_save_lumps();

KSR.tm.t_send_reply()Link

int KSR.tm.t_send_reply(int code, str "reason");

KSR.tm.t_set_auto_inv_100()Link

int KSR.tm.t_set_auto_inv_100(int state);

KSR.tm.t_set_disable_6xx()Link

int KSR.tm.t_set_disable_6xx(int state);

KSR.tm.t_set_disable_failover()Link

int KSR.tm.t_set_disable_failover(int state);

KSR.tm.t_set_disable_internal_reply()Link

int KSR.tm.t_set_disable_internal_reply(int state);

KSR.tm.t_set_fr()Link

int KSR.tm.t_set_fr(int fr_inv, int fr);

KSR.tm.t_set_fr_inv()Link

int KSR.tm.t_set_fr_inv(int fr_inv);

KSR.tm.t_set_max_lifetime()Link

int KSR.tm.t_set_max_lifetime(int t1, int t2);

KSR.tm.t_set_no_e2e_cancel_reason()Link

int KSR.tm.t_set_no_e2e_cancel_reason(int state);

KSR.tm.t_set_retr()Link

int KSR.tm.t_set_retr(int t1, int t2);

KSR.tm.t_uac_send()Link

int KSR.tm.t_uac_send(str "method", str "ruri", str "nexthop", str "ssock", str "hdrs", str "body");

KSR.tm.t_use_uac_headers()Link

int KSR.tm.t_use_uac_headers();

tmrecLink

Exported functions:

KSR.tmrec.is_leap_year()Link

int KSR.tmrec.is_leap_year(int y);

KSR.tmrec.is_leap_year_now()Link

int KSR.tmrec.is_leap_year_now();

KSR.tmrec.match()Link

int KSR.tmrec.match(str "rv");

KSR.tmrec.match_timestamp()Link

int KSR.tmrec.match_timestamp(str "rv", int ti);

KSR.tmrec.time_period_match()Link

int KSR.tmrec.time_period_match(str "period");

KSR.tmrec.time_period_match_timestamp()Link

int KSR.tmrec.time_period_match_timestamp(str "period", int ti);

tmxLink

Exported functions:

KSR.tmx.t_cancel_branches()Link

int KSR.tmx.t_cancel_branches(str "mode");

KSR.tmx.t_cancel_callid()Link

int KSR.tmx.t_cancel_callid(str "callid_s", str "cseq_s", int fl);

KSR.tmx.t_cancel_callid_reason()Link

int KSR.tmx.t_cancel_callid_reason(str "callid_s", str "cseq_s", int fl, int rcode);

KSR.tmx.t_continue()Link

int KSR.tmx.t_continue(int tindex, int tlabel, str "cbname");

KSR.tmx.t_drop()Link

int KSR.tmx.t_drop();

KSR.tmx.t_drop_rcode()Link

int KSR.tmx.t_drop_rcode(int rcode);

KSR.tmx.t_flush_flags()Link

int KSR.tmx.t_flush_flags();

KSR.tmx.t_flush_xflags()Link

int KSR.tmx.t_flush_xflags();

KSR.tmx.t_is_branch_route()Link

int KSR.tmx.t_is_branch_route();

KSR.tmx.t_is_failure_route()Link

int KSR.tmx.t_is_failure_route();

KSR.tmx.t_is_reply_route()Link

int KSR.tmx.t_is_reply_route();

KSR.tmx.t_is_request_route()Link

int KSR.tmx.t_is_request_route();

KSR.tmx.t_precheck_trans()Link

int KSR.tmx.t_precheck_trans();

KSR.tmx.t_reply_callid()Link

int KSR.tmx.t_reply_callid(str "callid_s", str "cseq_s", int code, str "status_s");

KSR.tmx.t_reuse_branch()Link

int KSR.tmx.t_reuse_branch();

KSR.tmx.t_suspend()Link

int KSR.tmx.t_suspend();

toposLink

Exported functions:

KSR.topos.tps_set_context()Link

int KSR.topos.tps_set_context(str "ctx");

tsiloLink

Exported functions:

KSR.tsilo.ts_append()Link

int KSR.tsilo.ts_append(str "_table", str "_ruri");

KSR.tsilo.ts_append_by_contact()Link

int KSR.tsilo.ts_append_by_contact(str "_table", str "_ruri");

KSR.tsilo.ts_append_by_contact_uri()Link

int KSR.tsilo.ts_append_by_contact_uri(str "_table", str "_ruri", str "_contact");

KSR.tsilo.ts_append_to()Link

int KSR.tsilo.ts_append_to(int tindex, int tlabel, str "_table");

KSR.tsilo.ts_append_to_uri()Link

int KSR.tsilo.ts_append_to_uri(int tindex, int tlabel, str "_table", str "_uri");

KSR.tsilo.ts_store()Link

int KSR.tsilo.ts_store();

KSR.tsilo.ts_store_uri()Link

int KSR.tsilo.ts_store_uri(str "puri");

uacLink

Exported functions:

KSR.uac.uac_auth()Link

int KSR.uac.uac_auth();

KSR.uac.uac_auth_mode()Link

int KSR.uac.uac_auth_mode(int mode);

KSR.uac.uac_reg_disable()Link

int KSR.uac.uac_reg_disable(str "attr", str "val");

KSR.uac.uac_reg_enable()Link

int KSR.uac.uac_reg_enable(str "attr", str "val");

KSR.uac.uac_reg_lookup()Link

int KSR.uac.uac_reg_lookup(str "userid", str "sdst");

KSR.uac.uac_reg_lookup_uri()Link

int KSR.uac.uac_reg_lookup_uri(str "suri", str "sdst");

KSR.uac.uac_reg_refresh()Link

int KSR.uac.uac_reg_refresh(str "l_uuid");

KSR.uac.uac_reg_request_to()Link

int KSR.uac.uac_reg_request_to(str "userid", int imode);

KSR.uac.uac_reg_status()Link

int KSR.uac.uac_reg_status(str "sruuid");

KSR.uac.uac_replace_from()Link

int KSR.uac.uac_replace_from(str "pdsp", str "puri");

KSR.uac.uac_replace_from_uri()Link

int KSR.uac.uac_replace_from_uri(str "puri");

KSR.uac.uac_replace_to()Link

int KSR.uac.uac_replace_to(str "pdsp", str "puri");

KSR.uac.uac_replace_to_uri()Link

int KSR.uac.uac_replace_to_uri(str "puri");

KSR.uac.uac_req_send()Link

int KSR.uac.uac_req_send();

KSR.uac.uac_restore_from()Link

int KSR.uac.uac_restore_from();

KSR.uac.uac_restore_to()Link

int KSR.uac.uac_restore_to();

uac_redirectLink

Exported functions:

KSR.uac_redirect.get_redirects()Link

int KSR.uac_redirect.get_redirects(int max_c, int max_b);

KSR.uac_redirect.get_redirects_acc()Link

int KSR.uac_redirect.get_redirects_acc(int max_c, int max_b, str "reason");

KSR.uac_redirect.get_redirects_all()Link

int KSR.uac_redirect.get_redirects_all();

uri_dbLink

Exported functions:

KSR.uri_db.check_from()Link

int KSR.uri_db.check_from();

KSR.uri_db.check_to()Link

int KSR.uri_db.check_to();

KSR.uri_db.check_uri()Link

int KSR.uri_db.check_uri(str "suri");

KSR.uri_db.check_uri_realm()Link

int KSR.uri_db.check_uri_realm(str "suri", str "susername", str "srealm");

KSR.uri_db.does_uri_exist()Link

int KSR.uri_db.does_uri_exist();

userblocklistLink

Exported functions:

KSR.userblocklist.check_allowlist()Link

int KSR.userblocklist.check_allowlist(str "stable");

KSR.userblocklist.check_blocklist()Link

int KSR.userblocklist.check_blocklist(str "stable");

KSR.userblocklist.check_global_blocklist()Link

int KSR.userblocklist.check_global_blocklist();

KSR.userblocklist.check_user_allowlist()Link

int KSR.userblocklist.check_user_allowlist(str "suser", str "sdomain");

KSR.userblocklist.check_user_allowlist_number()Link

int KSR.userblocklist.check_user_allowlist_number(str "suser", str "sdomain", str "snumber");

KSR.userblocklist.check_user_allowlist_table()Link

int KSR.userblocklist.check_user_allowlist_table(str "suser", str "sdomain", str "snumber", str "stable");

KSR.userblocklist.check_user_blocklist()Link

int KSR.userblocklist.check_user_blocklist(str "suser", str "sdomain");

KSR.userblocklist.check_user_blocklist_number()Link

int KSR.userblocklist.check_user_blocklist_number(str "suser", str "sdomain", str "snumber");

KSR.userblocklist.check_user_blocklist_table()Link

int KSR.userblocklist.check_user_blocklist_table(str "suser", str "sdomain", str "snumber", str "stable");

utilsLink

Exported functions:

KSR.utils.xcap_auth_status()Link

int KSR.utils.xcap_auth_status(str "watcher_uri", str "presentity_uri");

uuidLink

Exported functions:

KSR.uuid.get()Link

xval KSR.uuid.get();

KSR.uuid.rget()Link

xval KSR.uuid.rget();

KSR.uuid.tget()Link

xval KSR.uuid.tget();

websocketLink

Exported functions:

KSR.websocket.close()Link

int KSR.websocket.close();

KSR.websocket.close_conid()Link

int KSR.websocket.close_conid(int status, str "reason", int con);

KSR.websocket.close_reason()Link

int KSR.websocket.close_reason(int status, str "reason");

KSR.websocket.handle_handshake()Link

int KSR.websocket.handle_handshake();

xcap_serverLink

Exported functions:

KSR.xcap_server.xcaps_del()Link

int KSR.xcap_server.xcaps_del(str "uri", str "path");

KSR.xcap_server.xcaps_get()Link

int KSR.xcap_server.xcaps_get(str "uri", str "path");

KSR.xcap_server.xcaps_put()Link

int KSR.xcap_server.xcaps_put(str "uri", str "path", str "pbody");

xhttpLink

Exported functions:

KSR.xhttp.get_hu()Link

xval KSR.xhttp.get_hu();

KSR.xhttp.xhttp_reply()Link

int KSR.xhttp.xhttp_reply(int code, str "reason", str "ctype", str "body");

xhttp_piLink

Exported functions:

KSR.xhttp_pi.dispatch()Link

int KSR.xhttp_pi.dispatch();

xhttp_promLink

Exported functions:

KSR.xhttp_prom.check_uri()Link

int KSR.xhttp_prom.check_uri();

KSR.xhttp_prom.counter_inc_l0()Link

int KSR.xhttp_prom.counter_inc_l0(str "s_name", int number);

KSR.xhttp_prom.counter_inc_l1()Link

int KSR.xhttp_prom.counter_inc_l1(str "s_name", int number, str "l1");

KSR.xhttp_prom.counter_inc_l2()Link

int KSR.xhttp_prom.counter_inc_l2(str "s_name", int number, str "l1", str "l2");

KSR.xhttp_prom.counter_inc_l3()Link

int KSR.xhttp_prom.counter_inc_l3(str "s_name", int number, str "l1", str "l2", str "l3");

KSR.xhttp_prom.counter_reset_l0()Link

int KSR.xhttp_prom.counter_reset_l0(str "s_name");

KSR.xhttp_prom.counter_reset_l1()Link

int KSR.xhttp_prom.counter_reset_l1(str "s_name", str "l1");

KSR.xhttp_prom.counter_reset_l2()Link

int KSR.xhttp_prom.counter_reset_l2(str "s_name", str "l1", str "l2");

KSR.xhttp_prom.counter_reset_l3()Link

int KSR.xhttp_prom.counter_reset_l3(str "s_name", str "l1", str "l2", str "l3");

KSR.xhttp_prom.dispatch()Link

int KSR.xhttp_prom.dispatch();

KSR.xhttp_prom.gauge_reset_l0()Link

int KSR.xhttp_prom.gauge_reset_l0(str "s_name");

KSR.xhttp_prom.gauge_reset_l1()Link

int KSR.xhttp_prom.gauge_reset_l1(str "s_name", str "l1");

KSR.xhttp_prom.gauge_reset_l2()Link

int KSR.xhttp_prom.gauge_reset_l2(str "s_name", str "l1", str "l2");

KSR.xhttp_prom.gauge_reset_l3()Link

int KSR.xhttp_prom.gauge_reset_l3(str "s_name", str "l1", str "l2", str "l3");

KSR.xhttp_prom.gauge_set_l0()Link

int KSR.xhttp_prom.gauge_set_l0(str "s_name", str "s_number");

KSR.xhttp_prom.gauge_set_l1()Link

int KSR.xhttp_prom.gauge_set_l1(str "s_name", str "s_number", str "l1");

KSR.xhttp_prom.gauge_set_l2()Link

int KSR.xhttp_prom.gauge_set_l2(str "s_name", str "s_number", str "l1", str "l2");

KSR.xhttp_prom.gauge_set_l3()Link

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()Link

int KSR.xhttp_prom.histogram_observe_l0(str "s_name", str "s_number");

KSR.xhttp_prom.histogram_observe_l1()Link

int KSR.xhttp_prom.histogram_observe_l1(str "s_name", str "s_number", str "l1");

KSR.xhttp_prom.histogram_observe_l2()Link

int KSR.xhttp_prom.histogram_observe_l2(str "s_name", str "s_number", str "l1", str "l2");

KSR.xhttp_prom.histogram_observe_l3()Link

int KSR.xhttp_prom.histogram_observe_l3(str "s_name", str "s_number", str "l1", str "l2", str "l3");

xhttp_rpcLink

Exported functions:

KSR.xhttp_rpc.dispatch()Link

int KSR.xhttp_rpc.dispatch();

xlogLink

Exported functions:

KSR.xlog.xalert()Link

int KSR.xlog.xalert(str "lmsg");

KSR.xlog.xcrit()Link

int KSR.xlog.xcrit(str "lmsg");

KSR.xlog.xdbg()Link

int KSR.xlog.xdbg(str "lmsg");

KSR.xlog.xerr()Link

int KSR.xlog.xerr(str "lmsg");

KSR.xlog.xinfo()Link

int KSR.xlog.xinfo(str "lmsg");

KSR.xlog.xlog()Link

int KSR.xlog.xlog(str "slevel", str "lmsg");

KSR.xlog.xnotice()Link

int KSR.xlog.xnotice(str "lmsg");

KSR.xlog.xwarn()Link

int KSR.xlog.xwarn(str "lmsg");

xmlrpcLink

Exported functions:

KSR.xmlrpc.dispatch_rpc()Link

int KSR.xmlrpc.dispatch_rpc();

KSR.xmlrpc.xmlrpc_reply()Link

int KSR.xmlrpc.xmlrpc_reply(int rcode, str "reason");