/**
* \brief update internal counters for running new basic sec. timers
* @param timers number of basic timer processes
* @return 0 on success; -1 on error
*/
int register_basic_timers(int timers)
{
if(register_procs(timers)<0)
return -1;
cfg_register_child(timers);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
evrexec_task_t *it;
if(rpc_register_array(evr_rpc_methods)!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
if(_evrexec_list==NULL)
return 0;
/* init faked sip msg */
if(faked_msg_init()<0) {
LM_ERR("failed to init evrexec local sip msg\n");
return -1;
}
/* register additional processes */
it = _evrexec_list;
while(it) {
register_procs(it->workers);
it = it->next;
}
return 0;
}
static int mod_init(void)
{
struct id_list* l;
if (listen_lst==0) {
add_binrpc_socket(PARAM_STRING, DEFAULT_CTL_SOCKET);
}
DBG("listening on:\n");
for (l=listen_lst; l; l=l->next){
fd_no++;
switch(l->proto){
case UNIXD_SOCK:
DBG(" [%s:unix dgram] %s\n",
payload_proto_name(l->data_proto), l->name);
break;
case UNIXS_SOCK:
DBG(" [%s:unix stream] %s\n",
payload_proto_name(l->data_proto), l->name);
break;
case UDP_SOCK:
DBG(" [%s:udp] %s:%d\n",
payload_proto_name(l->data_proto), l->name,
l->port?l->port:DEFAULT_CTL_PORT);
break;
case TCP_SOCK:
DBG(" [%s:tcp] %s:%d\n",
payload_proto_name(l->data_proto), l->name,
l->port?l->port:DEFAULT_CTL_PORT);
break;
case FIFO_SOCK:
DBG(" [%s:fifo] %s\n",
payload_proto_name(l->data_proto), l->name);
fd_no++; /* fifos use 2 fds */
break;
default:
LOG(L_CRIT, "BUG: ctrl: listen protocol %d not supported\n",
l->proto);
goto error;
}
}
/* open socket now, before suid */
if (init_ctrl_sockets(&ctrl_sock_lst, listen_lst, DEFAULT_CTL_PORT,
usock_mode, usock_uid, usock_gid)<0){
LOG(L_ERR, "ERROR: ctl: mod_init: init ctrl. sockets failed\n");
goto error;
}
if (ctrl_sock_lst){
/* we will fork */
register_procs(1); /* we will be creating an extra process */
register_fds(fd_no);
/* The child process will keep updating its local configuration */
cfg_register_child(1);
}
#ifdef USE_FIFO
fifo_rpc_init();
#endif
return 0;
error:
return -1;
}
static int mod_init(void) {
load_tm_f load_tm;
/* load the tm functions */
if ( !(load_tm=(load_tm_f)find_export("load_tm", NO_SCRIPT, 0)))
{
LOG(L_ERR, "ERROR:jsonrpc:mod_init: cannot import load_tm\n");
return -1;
}
/* let the auto-loading function load all TM stuff */
if (load_tm( &tmb )==-1)
return -1;
if (servers_param == NULL) {
LM_ERR("servers parameter missing.\n");
return -1;
}
register_procs(1);
if (pipe(pipe_fds) < 0) {
LM_ERR("pipe() failed\n");
return -1;
}
return(0);
}
void inner_main(int argc, char **argv)
{
register_procs();
read_config_file();
/* now get on with the main business of the program ... */
gh_repl(argc, argv);
}
void inner_main(int argc, char **argv)
{
register_procs();
read_config_file();
/* now get on with the main business of the program ... */
gh_eval_str("(tortoise-turn 30)"); /* example: call C-defined procedure */
gh_eval_str("(polygon 3)"); /* example: call Scheme-defined procedure */
gh_repl(argc, argv);
}
static int mod_init(void)
{
if (init_fifo_server() < 0) return -1;
/* Signal to the core that we will be creating one
* additional process
*/
if (fifo) register_procs(1);
return 0;
}
static int mod_init(void)
{
if (init_unixsock_socket() < 0) return -1;
/* Signal to the core that we will be
* creating additional processes
*/
if (unixsock_name) register_procs(unixsock_children);
return 0;
}
int async_task_init(void)
{
LM_DBG("start initializing asynk task framework\n");
if(_async_task_workers<=0)
return 0;
/* advertise new processes to core */
register_procs(_async_task_workers);
/* advertise new processes to cfg framework */
cfg_register_child(_async_task_workers);
return 0;
}
/*! This is the first function to be called by Kamailio, to initialize the module.
* This call must always return a value as soon as possible. If it were not to
* return, then Kamailio would not be able to initialize any of the other
* modules. */
static int mod_init(void)
{
if (register_message_code_statistics() < 0)
{
return -1;
}
/* Initialize shared memory used to buffer communication between the
* usrloc module and the snmpstats module. */
initInterprocessBuffers();
/* We need to register for callbacks with usrloc module, for whenever a
* contact is added or removed from the system. We need to do it now
* before Kamailio's functions get a chance to load up old user data from
* the database. That load will happen if a lookup() function is come
* across in kamailio.cfg. */
if (snmp_export_registrar!=0)
{
if(!registerForUSRLOCCallbacks())
{
/* Originally there were descriptive error messages here to help
* the operator debug problems. Turns out this may instead
* alarm them about problems they don't need to worry about. So
* the messages are commented out for now */
/*
LM_ERR("snmpstats module was unable to register callbacks"
" with the usrloc module\n");
LM_ERR("Are you sure that the usrloc module was loaded"
" before the snmpstats module in ");
LM_ERR("kamailio.cfg? kamailioSIPRegUserTable will not be "
"updated.");
*/
}
}
/* Register the alarm checking function to run periodically */
register_timer(run_alarm_check, 0, ALARM_AGENT_FREQUENCY_IN_SECONDS);
/* add space for one extra process */
register_procs(1);
/* add child to update local config framework structures */
cfg_register_child(1);
/* Initialize config framework in utilities.c */
config_context_init();
return 0;
}
/*
* initialize module
*/
static int mod_init(void) {
if (load_tm_api(&tmb)) {
LM_ERR("failed to load tm API\n");
return -1;
}
if (strcmp(backend, "component") && strcmp(backend, "server")) {
LM_ERR("invalid backend '%s'\n", backend);
return -1;
}
if (!xmpp_port) {
if (!strcmp(backend, "component"))
xmpp_port = DEFAULT_COMPONENT_PORT;
else if (!strcmp(backend, "server"))
xmpp_port = DEFAULT_SERVER_PORT;
}
/* fix up the domain separator -- we only need 1 char */
if (domain_sep_str && *domain_sep_str)
domain_separator = *domain_sep_str;
if(outbound_proxy.s)
outbound_proxy.len= strlen(outbound_proxy.s);
if(init_xmpp_cb_list()<0){
LM_ERR("failed to init callback list\n");
return -1;
}
if (pipe(pipe_fds) < 0) {
LM_ERR("pipe() failed\n");
return -1;
}
/* add space for one extra process */
register_procs(1);
/* add child to update local config framework structures */
cfg_register_child(1);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
char *p;
/* init faked sip msg */
if(faked_msg_init()<0) {
LM_ERR("failed to init faked sip message\n");
return -1;
}
if(load_tm_api( &tmb ) < 0) {
LM_INFO("cannot load the TM module functions - async relay disabled\n");
memset(&tmb, 0, sizeof(tm_api_t));
}
if(_evapi_bind_param!=NULL) {
p = strchr(_evapi_bind_param, ':');
if(p!=NULL) {
*p++ = '\0';
_evapi_bind_port = (short)atoi(p);
if (_evapi_bind_port <= 0) {
LM_ERR("invalid port: %d\n", _evapi_bind_port);
return -1;
}
}
_evapi_bind_addr = _evapi_bind_param;
}
/* add space for one extra process */
register_procs(1 + _evapi_workers);
/* add child to update local config framework structures */
cfg_register_child(1 + _evapi_workers);
evapi_init_environment(_evapi_netstring_format_param);
return 0;
}
/** Initializes seas module. It first parses the listen_sockets parameter
* which has the form "ip_address[:port]", creates the pipe to
* communicate with the dispatcher.
*/
static int seas_init(void)
{
char *p,*port;
struct hostent *he;
struct socket_info *si;
int c_pipe[2],mierr,i;
/** Populate seas_functions*/
if (load_tm_api(&seas_f.tmb)!=0) {
LM_ERR( "can't load TM API\n");
return -1;
}
if(!(seas_f.t_check_orig_trans = find_export("t_check_trans", 0, 0))){
LM_ERR( "Seas requires transaction module (t_check_trans not found)\n");
return -1;
}
/** Populate seas_functions*/
c_pipe[0]=c_pipe[1]=-1;
p=seas_listen_socket;
port=(char *)0;
seas_listen_port=5080;
/*if the seas_listen_socket configuration string is empty, use default values*/
if(p==NULL || *p==0){
si=get_first_socket();
seas_listen_ip=&si->address;
} else {/*if config string is not empty, then try to find host first, and maybe port..*/
while(*p){
if(*p == ':'){
*p=0;
port=p+1;
break;
}
p++;
}
if(!(he=resolvehost(seas_listen_socket)))
goto error;
if(!(seas_listen_ip=pkg_malloc(sizeof(struct ip_addr))))
goto error;
hostent2ip_addr(seas_listen_ip, he, 0);
if(port!=(char *)0 && (seas_listen_port=str2s(port,strlen(port),&mierr))==0){
LM_ERR("invalid port %s \n",port);
goto error;
}
}
memset(unc_as_t,0,2*MAX_UNC_AS_NR*sizeof(struct unc_as));//useless because unc_as_t is in bss?
if (pipe(c_pipe)==-1) {
LM_ERR("cannot create pipe!\n");
goto error;
}
read_pipe=c_pipe[0];
write_pipe=c_pipe[1];
seas_init_tags();
if(0>start_stats_server(seas_stats_socket))
goto error;
if(0>prepare_ha())
goto error;
if(0>parse_cluster_cfg())
goto error;
register_procs(1);
/* add child to update local config framework structures */
cfg_register_child(1);
return 0;
error:
for(i=0;i<2;i++)
if(c_pipe[i]!=-1)
close(c_pipe[i]);
if(seas_listen_ip!=0)
pkg_free(seas_listen_ip);
if(use_stats)
stop_stats_server();
return -1;
}
static int mod_init(void)
{
struct id_list* l;
char ctl_socket_path[CTL_SOCKET_PATH_SIZE];
binrpc_callbacks_init();
if(binrpc_max_body_size<=0)
binrpc_max_body_size = 4;
if(binrpc_struct_max_body_size<=0)
binrpc_struct_max_body_size = 1;
binrpc_max_body_size *= 1024;
binrpc_struct_max_body_size *= 1024;
if (listen_lst==0) {
if(strcmp(runtime_dir, RUN_DIR)==0) {
add_binrpc_socket(PARAM_STRING, DEFAULT_CTL_SOCKET);
} else {
if(sizeof(DEFAULT_CTL_SOCKET_PROTO)
+ sizeof(DEFAULT_CTL_SOCKET_NAME)
+ strlen(runtime_dir) + 4 > CTL_SOCKET_PATH_SIZE) {
LM_ERR("ctl socket path is too big\n");
return -1;
}
strcpy(ctl_socket_path, DEFAULT_CTL_SOCKET_PROTO);
strcat(ctl_socket_path, runtime_dir);
strcat(ctl_socket_path, "/");
strcat(ctl_socket_path, DEFAULT_CTL_SOCKET_NAME);
add_binrpc_socket(PARAM_STRING, ctl_socket_path);
}
}
DBG("listening on:\n");
for (l=listen_lst; l; l=l->next){
fd_no++;
switch(l->proto){
case UNIXD_SOCK:
DBG(" [%s:unix dgram] %s\n",
payload_proto_name(l->data_proto), l->name);
break;
case UNIXS_SOCK:
DBG(" [%s:unix stream] %s\n",
payload_proto_name(l->data_proto), l->name);
break;
case UDP_SOCK:
DBG(" [%s:udp] %s:%d\n",
payload_proto_name(l->data_proto), l->name,
l->port?l->port:DEFAULT_CTL_PORT);
break;
case TCP_SOCK:
DBG(" [%s:tcp] %s:%d\n",
payload_proto_name(l->data_proto), l->name,
l->port?l->port:DEFAULT_CTL_PORT);
break;
#ifdef USE_FIFO
case FIFO_SOCK:
DBG(" [%s:fifo] %s\n",
payload_proto_name(l->data_proto), l->name);
fd_no++; /* fifos use 2 fds */
break;
#endif
default:
LOG(L_CRIT, "BUG: ctrl: listen protocol %d not supported\n",
l->proto);
goto error;
}
}
/* get the uid/gid from core if not set for the module */
if(usock_uid==-1 && sock_uid!=-1) usock_uid = sock_uid;
if(usock_gid==-1 && sock_gid!=-1) usock_gid = sock_gid;
/* open socket now, before suid */
if (init_ctrl_sockets(&ctrl_sock_lst, listen_lst, DEFAULT_CTL_PORT,
usock_mode, usock_uid, usock_gid)<0){
LOG(L_ERR, "ERROR: ctl: mod_init: init ctrl. sockets failed\n");
goto error;
}
if (ctrl_sock_lst){
/* we will fork */
register_procs(1); /* we will be creating an extra process */
register_fds(fd_no);
/* The child process will keep updating its local configuration */
cfg_register_child(1);
}
#ifdef USE_FIFO
fifo_rpc_init();
#endif
return 0;
error:
return -1;
}
/**
* init module function
*/
static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0) {
LM_ERR("failed to register MI commands\n");
return -1;
}
/* bind the SL API */
if (sl_load_api(&slb)!=0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* load all TM stuff */
if(load_tm_api(&tmb)==-1) {
LM_ERR("can't load tm functions. TM module probably not loaded\n");
return -1;
}
/* load peer list - the list containing the module callbacks for dmq */
peer_list = init_peer_list();
if(peer_list==NULL) {
LM_ERR("cannot initialize peer list\n");
return -1;
}
/* load the dmq node list - the list containing the dmq servers */
node_list = init_dmq_node_list();
if(node_list==NULL) {
LM_ERR("cannot initialize node list\n");
return -1;
}
if (rpc_register_array(rpc_methods)!=0) {
LM_ERR("failed to register RPC commands\n");
return -1;
}
/* register worker processes - add one because of the ping process */
register_procs(num_workers);
/* check server_address and notification_address are not empty and correct */
if(parse_uri(dmq_server_address.s, dmq_server_address.len, &dmq_server_uri) < 0) {
LM_ERR("server address invalid\n");
return -1;
}
if(parse_uri(dmq_notification_address.s, dmq_notification_address.len, &dmq_notification_uri) < 0) {
LM_ERR("notification address invalid\n");
return -1;
}
/* create socket string out of the server_uri */
if(make_socket_str_from_uri(&dmq_server_uri, &dmq_server_socket) < 0) {
LM_ERR("failed to create socket out of server_uri\n");
return -1;
}
if (lookup_local_socket(&dmq_server_socket) == NULL) {
LM_ERR("server_uri is not a socket the proxy is listening on\n");
return -1;
}
/* allocate workers array */
workers = shm_malloc(num_workers * sizeof(*workers));
if(workers == NULL) {
LM_ERR("error in shm_malloc\n");
return -1;
}
dmq_init_callback_done = shm_malloc(sizeof(int));
if (!dmq_init_callback_done) {
LM_ERR("no more shm\n");
return -1;
}
*dmq_init_callback_done = 0;
/**
* add the dmq notification peer.
* the dmq is a peer itself so that it can receive node notifications
*/
if(add_notification_peer()<0) {
LM_ERR("cannot add notification peer\n");
return -1;
}
startup_time = (int) time(NULL);
/**
* add the ping timer
* it pings the servers once in a while so that we know which failed
*/
if(ping_interval < MIN_PING_INTERVAL) {
ping_interval = MIN_PING_INTERVAL;
}
if(register_timer(ping_servers, 0, ping_interval)<0) {
LM_ERR("cannot register timer callback\n");
return -1;
}
return 0;
}
static int mod_init(void) {
int i;
startup_time = (int) time(NULL);
kz_json_escape_char = kz_json_escape_str.s[0];
if (dbk_node_hostname.s == NULL) {
LM_ERR("You must set the node_hostname parameter\n");
return -1;
}
dbk_node_hostname.len = strlen(dbk_node_hostname.s);
dbk_consumer_event_key.len = strlen(dbk_consumer_event_key.s);
dbk_consumer_event_subkey.len = strlen(dbk_consumer_event_subkey.s);
if(kz_init_avp()) {
LM_ERR("Error in avp params\n");
return -1;
}
if(!kz_amqp_init()) {
return -1;
}
if(kz_timer_ms > 0) {
kz_timer_tv.tv_usec = (kz_timer_ms % 1000) * 1000;
kz_timer_tv.tv_sec = kz_timer_ms / 1000;
}
if(dbk_pua_mode == 1) {
kz_db_url.len = kz_db_url.s ? strlen(kz_db_url.s) : 0;
LM_DBG("db_url=%s/%d/%p\n", ZSW(kz_db_url.s), kz_db_url.len,kz_db_url.s);
kz_presentity_table.len = strlen(kz_presentity_table.s);
if(kz_db_url.len > 0) {
/* binding to database module */
if (db_bind_mod(&kz_db_url, &kz_pa_dbf))
{
LM_ERR("Database module not found\n");
return -1;
}
if (!DB_CAPABILITY(kz_pa_dbf, DB_CAP_ALL))
{
LM_ERR("Database module does not implement all functions"
" needed by kazoo module\n");
return -1;
}
kz_pa_db = kz_pa_dbf.init(&kz_db_url);
if (!kz_pa_db)
{
LM_ERR("Connection to database failed\n");
return -1;
}
kz_pa_dbf.close(kz_pa_db);
kz_pa_db = NULL;
}
}
int total_workers = dbk_consumer_workers + (dbk_consumer_processes * kz_server_counter) + 2;
register_procs(total_workers);
cfg_register_child(total_workers);
if (pipe(kz_cmd_pipe_fds) < 0) {
LM_ERR("cmd pipe() failed\n");
return -1;
}
kz_worker_pipes_fds = (int*) shm_malloc(sizeof(int) * (dbk_consumer_workers) * 2 );
kz_worker_pipes = (int*) shm_malloc(sizeof(int) * dbk_consumer_workers);
for(i=0; i < dbk_consumer_workers; i++) {
kz_worker_pipes_fds[i*2] = kz_worker_pipes_fds[i*2+1] = -1;
if (pipe(&kz_worker_pipes_fds[i*2]) < 0) {
LM_ERR("worker pipe(%d) failed\n", i);
return -1;
}
}
kz_cmd_pipe = kz_cmd_pipe_fds[1];
for(i=0; i < dbk_consumer_workers; i++) {
kz_worker_pipes[i] = kz_worker_pipes_fds[i*2+1];
}
return 0;
}
int jsonrpc_dgram_mod_init(void)
{
unsigned int port_no;
int n;
struct stat filestat;
struct hostent *host;
char *p, *host_s;
str port_str;
int len;
int sep;
/* checking the mi_socket module param */
LM_DBG("testing socket existance...\n");
if( jsonrpc_dgram_socket==NULL || *jsonrpc_dgram_socket == 0) {
LM_ERR("no DATAGRAM_ socket configured\n");
return -1;
}
LM_DBG("the socket's name/address is %s\n", jsonrpc_dgram_socket);
memset( &jsonrpc_dgram_addr, 0, sizeof(jsonrpc_dgram_sockaddr_t) );
if(strlen(jsonrpc_dgram_socket)<6) {
LM_ERR("lenght of socket address is too short: %s\n",
jsonrpc_dgram_socket);
return -1;
}
if(strncmp(jsonrpc_dgram_socket, "udp:", 4) == 0) {
/*for an UDP socket*/
LM_DBG("udp socket provided\n");
/*separate proto and host */
p = jsonrpc_dgram_socket+4;
if( (*(p)) == '\0') {
LM_ERR("malformed ip address\n");
return -1;
}
host_s=p;
LM_DBG("remaining address after separating the protocol is %s\n", p);
if( (p = strrchr(p+1, ':')) == 0 ) {
LM_ERR("no port specified\n");
return -1;
}
/*the address contains a port number*/
*p = '\0';
p++;
port_str.s = p;
port_str.len = strlen(p);
LM_DBG("the port string is %s\n", p);
if(str2int(&port_str, &port_no) != 0 ) {
LM_ERR("there is not a valid number port\n");
return -1;
}
*p = '\0';
if (port_no<1024 || port_no>65535)
{
LM_ERR("invalid port number; must be in [1024,65535]\n");
return -1;
}
if(! (host = resolvehost(host_s)) ) {
LM_ERR("failed to resolve %s\n", host_s);
return -1;
}
LM_DBG("the ip is %s\n",host_s);
if(hostent2su( &(jsonrpc_dgram_addr.udp_addr), host, 0, port_no ) !=0) {
LM_ERR("failed to resolve %s\n", jsonrpc_dgram_socket);
return -1;
}
jsonrpc_dgram_socket_domain = host->h_addrtype;
goto done;
}
/* in case of a Unix socket*/
LM_DBG("UNIX socket provided\n");
if(*jsonrpc_dgram_socket != '/') {
if(runtime_dir!=NULL && *runtime_dir!=0) {
len = strlen(runtime_dir);
sep = 0;
if(runtime_dir[len-1]!='/') {
sep = 1;
}
len += sep + strlen(jsonrpc_dgram_socket);
p = pkg_malloc(len + 1);
if(p==NULL) {
LM_ERR("no more pkg\n");
return -1;
}
strcpy(p, runtime_dir);
if(sep) strcat(p, "/");
strcat(p, jsonrpc_dgram_socket);
jsonrpc_dgram_socket = p;
LM_DBG("unix socket path is [%s]\n", jsonrpc_dgram_socket);
}
}
n=stat(jsonrpc_dgram_socket, &filestat);
if( n==0) {
LM_INFO("the socket %s already exists, trying to delete it...\n",
jsonrpc_dgram_socket);
if(config_check==0) {
if (unlink(jsonrpc_dgram_socket)<0) {
LM_ERR("cannot delete old socket: %s\n", strerror(errno));
return -1;
}
}
} else if (n<0 && errno!=ENOENT) {
LM_ERR("socket stat failed:%s\n", strerror(errno));
return -1;
}
/* check mi_unix_socket_mode */
if(!jsonrpc_dgram_unix_socket_mode) {
LM_WARN("cannot specify jsonrpc_dgram_unix_socket_mode = 0,"
" forcing it to rw-------\n");
jsonrpc_dgram_unix_socket_mode = S_IRUSR| S_IWUSR;
}
if (jsonrpc_dgram_unix_socket_uid_s) {
if (user2uid(&jsonrpc_dgram_unix_socket_uid,
&jsonrpc_dgram_unix_socket_gid,
jsonrpc_dgram_unix_socket_uid_s)<0) {
LM_ERR("bad user name %s\n", jsonrpc_dgram_unix_socket_uid_s);
return -1;
}
}
if (jsonrpc_dgram_unix_socket_gid_s) {
if (group2gid(&jsonrpc_dgram_unix_socket_gid,
jsonrpc_dgram_unix_socket_gid_s)<0) {
LM_ERR("bad group name %s\n", jsonrpc_dgram_unix_socket_gid_s);
return -1;
}
}
/*create the unix socket address*/
jsonrpc_dgram_addr.unix_addr.sun_family = AF_LOCAL;
if(strlen(jsonrpc_dgram_socket)
>= sizeof(jsonrpc_dgram_addr.unix_addr.sun_path)-1) {
LM_ERR("socket path is too long\n");
return -1;
}
memcpy(jsonrpc_dgram_addr.unix_addr.sun_path,
jsonrpc_dgram_socket, strlen(jsonrpc_dgram_socket));
done:
/* add space for extra processes */
register_procs(jsonrpc_dgram_workers);
/* add child to update local config framework structures */
cfg_register_child(jsonrpc_dgram_workers);
return 0;
}
/*! \brief Initialize sipcapture module */
static int mod_init(void) {
struct ip_addr *ip = NULL;
#ifdef STATISTICS
/* register statistics */
if (register_module_stats(exports.name, sipcapture_stats)!=0)
{
LM_ERR("failed to register core statistics\n");
return -1;
}
#endif
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(sipcapture_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
db_url.len = strlen(db_url.s);
table_name.len = strlen(table_name.s);
hash_source.len = strlen (hash_source.s);
mt_mode.len = strlen(mt_mode.s);
date_column.len = strlen(date_column.s);
micro_ts_column.len = strlen(micro_ts_column.s);
method_column.len = strlen(method_column.s);
reply_reason_column.len = strlen(reply_reason_column.s);
ruri_column.len = strlen(ruri_column.s);
ruri_user_column.len = strlen(ruri_user_column.s);
from_user_column.len = strlen(from_user_column.s);
from_tag_column.len = strlen(from_tag_column.s);
to_user_column.len = strlen(to_user_column.s);
pid_user_column.len = strlen(pid_user_column.s);
contact_user_column.len = strlen(contact_user_column.s);
auth_user_column.len = strlen(auth_user_column.s);
callid_column.len = strlen(callid_column.s);
via_1_column.len = strlen(via_1_column.s);
via_1_branch_column.len = strlen(via_1_branch_column.s);
cseq_column.len = strlen(cseq_column.s);
diversion_column.len = strlen(diversion_column.s);
reason_column.len = strlen(reason_column.s);
content_type_column.len = strlen(content_type_column.s);
authorization_column.len = strlen(authorization_column.s);
user_agent_column.len = strlen(user_agent_column.s);
source_ip_column.len = strlen(source_ip_column.s);
source_port_column.len = strlen(source_port_column.s);
dest_ip_column.len = strlen(dest_ip_column.s);
dest_port_column.len = strlen(dest_port_column.s);
contact_ip_column.len = strlen(contact_ip_column.s);
contact_port_column.len = strlen(contact_port_column.s);
orig_ip_column.len = strlen(orig_ip_column.s);
orig_port_column.len = strlen(orig_port_column.s);
proto_column.len = strlen(proto_column.s);
family_column.len = strlen(family_column.s);
type_column.len = strlen(type_column.s);
rtp_stat_column.len = strlen(rtp_stat_column.s);
node_column.len = strlen(node_column.s);
msg_column.len = strlen(msg_column.s);
capture_node.len = strlen(capture_node.s);
if(raw_socket_listen.s)
raw_socket_listen.len = strlen(raw_socket_listen.s);
if(raw_interface.s)
raw_interface.len = strlen(raw_interface.s);
/* Find a database module */
if (db_bind_mod(&db_url, &db_funcs))
{
LM_ERR("unable to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(db_funcs, DB_CAP_INSERT))
{
LM_ERR("database modules does not provide all functions needed"
" by module\n");
return -1;
}
/*Check the table name*/
if(!table_name.len) {
LM_ERR("ERROR: sipcapture: mod_init: table_name is not defined or empty\n");
return -1;
}
if (mt_init () <0)
{
return -1;
}
if(db_insert_mode) {
LM_INFO("INFO: sipcapture: mod_init: you have enabled INSERT DELAYED \
Make sure your DB can support it\n");
}
capture_on_flag = (int*)shm_malloc(sizeof(int));
if(capture_on_flag==NULL) {
LM_ERR("no more shm memory left\n");
return -1;
}
*capture_on_flag = capture_on;
/* register DGRAM event */
if(sr_event_register_cb(SREV_NET_DGRAM_IN, hep_msg_received) < 0) {
LM_ERR("failed to register SREV_NET_DGRAM_IN event\n");
return -1;
}
if(ipip_capture_on && moni_capture_on) {
LM_ERR("only one RAW mode is supported. Please disable ipip_capture_on or moni_capture_on\n");
return -1;
}
/* raw processes for IPIP encapsulation */
if (ipip_capture_on || moni_capture_on) {
register_procs(raw_sock_children);
if(extract_host_port() && (((ip=str2ip(&raw_socket_listen)) == NULL)
#ifdef USE_IPV6
&& ((ip=str2ip6(&raw_socket_listen)) == NULL)
#endif
))
{
LM_ERR("sipcapture mod_init: bad RAW IP: %.*s\n", raw_socket_listen.len, raw_socket_listen.s);
return -1;
}
if(moni_capture_on && !moni_port_start) {
LM_ERR("ERROR:sipcapture:mod_init: Please define port/portrange in 'raw_socket_listen', before \
activate monitoring capture\n");
return -1;
}
static int mod_init(void)
{
pv_spec_t avp_spec;
if (restore_mode_str && *restore_mode_str) {
if (strcasecmp(restore_mode_str,"none")==0) {
restore_mode = UAC_NO_RESTORE;
} else if (strcasecmp(restore_mode_str,"manual")==0) {
restore_mode = UAC_MANUAL_RESTORE;
} else if (strcasecmp(restore_mode_str,"auto")==0) {
restore_mode = UAC_AUTO_RESTORE;
} else {
LM_ERR("unsupported value '%s' for restore_mode\n", restore_mode_str);
goto error;
}
}
if ( (rr_from_param.len==0 || rr_to_param.len==0) && restore_mode!=UAC_NO_RESTORE)
{
LM_ERR("rr_store_param cannot be empty if FROM is restoreable\n");
goto error;
}
/* parse the auth AVP spesc, if any */
if ( auth_username_avp || auth_password_avp || auth_realm_avp) {
if (!auth_username_avp || !auth_password_avp || !auth_realm_avp) {
LM_ERR("partial definition of auth AVP!");
goto error;
}
if ( parse_auth_avp(auth_realm_avp, &auth_realm_spec, "realm")<0
|| parse_auth_avp(auth_username_avp, &auth_username_spec, "username")<0
|| parse_auth_avp(auth_password_avp, &auth_password_spec, "password")<0
) {
goto error;
}
} else {
memset( &auth_realm_spec, 0, sizeof(pv_spec_t));
memset( &auth_password_spec, 0, sizeof(pv_spec_t));
memset( &auth_username_spec, 0, sizeof(pv_spec_t));
}
/* load the TM API - FIXME it should be loaded only
* if NO_RESTORE and AUTH */
if (load_tm_api(&uac_tmb)!=0) {
LM_ERR("can't load TM API\n");
goto error;
}
if (restore_mode!=UAC_NO_RESTORE) {
/* load the RR API */
if (load_rr_api(&uac_rrb)!=0) {
LM_ERR("can't load RR API\n");
goto error;
}
if(restore_from_avp.s) {
if (pv_parse_spec(&restore_from_avp, &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n", restore_from_avp.len, restore_from_avp.s);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &restore_from_avp_name, &restore_from_avp_type)!=0) {
LM_ERR("[%.*s]- invalid AVP definition\n", restore_from_avp.len, restore_from_avp.s);
return -1;
}
restore_from_avp_type |= AVP_VAL_STR;
}
if(restore_to_avp.s) {
if (pv_parse_spec(&restore_to_avp, &avp_spec)==0 || avp_spec.type!=PVT_AVP) {
LM_ERR("malformed or non AVP %.*s AVP definition\n", restore_to_avp.len, restore_to_avp.s);
return -1;
}
if(pv_get_avp_name(0, &avp_spec.pvp, &restore_to_avp_name, &restore_to_avp_type)!=0) {
LM_ERR("[%.*s]- invalid AVP definition\n", restore_to_avp.len, restore_to_avp.s);
return -1;
}
restore_to_avp_type |= AVP_VAL_STR;
}
if (restore_mode==UAC_AUTO_RESTORE) {
/* we need the append_fromtag on in RR */
memset(&dlg_api, 0, sizeof(struct dlg_binds));
if (uac_restore_dlg==0 || load_dlg_api(&dlg_api)!=0) {
if (!uac_rrb.append_fromtag) {
LM_ERR("'append_fromtag' RR param is not enabled!"
" - required by AUTO restore mode\n");
goto error;
}
if (uac_restore_dlg!=0)
LM_DBG("failed to find dialog API - is dialog module loaded?\n");
}
/* get all requests doing loose route */
if (uac_rrb.register_rrcb( rr_checker, 0)!=0) {
LM_ERR("failed to install RR callback\n");
goto error;
}
}
}
if(reg_db_url.s && reg_db_url.len>=0)
{
if(!reg_contact_addr.s || reg_contact_addr.len<=0)
{
LM_ERR("contact address parameter not set\n");
goto error;
}
if(reg_htable_size>14)
reg_htable_size = 14;
if(reg_htable_size<2)
reg_htable_size = 2;
reg_htable_size = 1<<reg_htable_size;
if(uac_reg_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
goto error;
}
if(uac_reg_init_ht(reg_htable_size)<0)
{
LM_ERR("failed to init reg htable\n");
goto error;
}
register_procs(1);
/* add child to update local config framework structures */
cfg_register_child(1);
}
init_from_replacer();
uac_req_init();
return 0;
error:
return -1;
}
void inner_main(int argc, char **argv)
{
register_procs();
gh_repl(argc, argv);
}
/*! \brief
* Initialize parent
*/
static int mod_init(void) {
bind_usrloc_t bind_usrloc;
bind_pua_t bind_pua;
/*register space for event processor*/
register_procs(1);
if (!fix_parameters()) goto error;
/* bind the SL API */
if (sl_load_api(&slb) != 0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
LM_DBG("Successfully bound to SL module\n");
/* load the TM API */
if (load_tm_api(&tmb) != 0) {
LM_ERR("can't load TM API\n");
return -1;
}
LM_DBG("Successfully bound to TM module\n");
bind_usrloc = (bind_usrloc_t) find_export("ul_bind_ims_usrloc_pcscf", 1, 0);
if (!bind_usrloc) {
LM_ERR("can't bind ims_usrloc_pcscf\n");
return -1;
}
if (bind_usrloc(&ul) < 0) {
return -1;
}
LM_DBG("Successfully bound to PCSCF Usrloc module\n");
if(subscribe_to_reginfo == 1){
/* Bind to PUA: */
bind_pua = (bind_pua_t) find_export("bind_pua", 1, 0);
if (!bind_pua) {
LM_ERR("Can't bind pua\n");
return -1;
}
if (bind_pua(&pua) < 0) {
LM_ERR("Can't bind pua\n");
return -1;
}
/* Check for Publish/Subscribe methods */
if (pua.send_publish == NULL) {
LM_ERR("Could not import send_publish\n");
return -1;
}
if (pua.send_subscribe == NULL) {
LM_ERR("Could not import send_subscribe\n");
return -1;
}
if (pua.get_subs_list == NULL) {
LM_ERR("Could not import get_subs_list\n");
return -1;
}
LM_DBG("Successfully bound to PUA module\n");
/*init cdb cb event list*/
if (!init_reginfo_event_list()) {
LM_ERR("unable to initialise reginfo_event_list\n");
return -1;
}
LM_DBG("Successfully initialised reginfo_event_list\n");
}
return 0;
error:
return -1;
}
/**
* init module function
*/
static int mod_init(void) {
/* fix the parameters */
if (!fix_parameters())
goto error;
#ifdef STATISTICS
/* register statistics */
if (register_module_stats(exports.name, mod_stats) != 0) {
LM_ERR("failed to register core statistics\n");
goto error;
}
if (!register_stats()) {
LM_ERR("Unable to register statistics\n");
goto error;
}
#endif
callback_singleton = shm_malloc(sizeof (int));
*callback_singleton = 0;
/*register space for event processor*/
register_procs(1);
cdp_avp = 0;
/* load the TM API */
if (load_tm_api(&tmb) != 0) {
LM_ERR("can't load TM API\n");
goto error;
}
/* load the CDP API */
if (load_cdp_api(&cdpb) != 0) {
LM_ERR("can't load CDP API\n");
goto error;
}
/* load the dialog API */
if (load_dlg_api(&dlgb) != 0) {
LM_ERR("can't load Dialog API\n");
goto error;
}
cdp_avp = load_cdp_avp();
if (!cdp_avp) {
LM_ERR("can't load CDP_AVP API\n");
goto error;
}
/* load the usrloc API */
bind_usrloc = (bind_usrloc_t) find_export("ul_bind_ims_usrloc_pcscf", 1, 0);
if (!bind_usrloc) {
LM_ERR("can't bind usrloc_pcscf\n");
return CSCF_RETURN_FALSE;
}
if (bind_usrloc(&ul) < 0) {
LM_ERR("can't bind to usrloc pcscf\n");
return CSCF_RETURN_FALSE;
}
LM_DBG("Successfully bound to PCSCF Usrloc module\n");
LM_DBG("Diameter RX interface successfully bound to TM, Dialog, Usrloc and CDP modules\n");
/*init cdb cb event list*/
if (!init_cdp_cb_event_list()) {
LM_ERR("unable to initialise cdp callback event list\n");
return -1;
}
return 0;
error:
LM_ERR("Failed to initialise ims_qos module\n");
return CSCF_RETURN_FALSE;
}
static int mod_init(void) {
pv_spec_t avp_spec;
str s;
bind_usrloc_t bind_usrloc;
qvalue_t dq;
callback_singleton = shm_malloc(sizeof (int));
*callback_singleton = 0;
/*build the required strings */
scscf_serviceroute_uri_str.s =
(char*) pkg_malloc(orig_prefix.len + scscf_name_str.len);
if (!scscf_serviceroute_uri_str.s) {
LM_ERR("Unable to allocate memory for service route uri\n");
return -1;
}
if (contact_expires_buffer_percentage < 0 || contact_expires_buffer_percentage > 90) {
LM_ERR("contact expires percentage not valid, must be >0 and <=90");
return -1;
}
memcpy(scscf_serviceroute_uri_str.s, orig_prefix.s, orig_prefix.len);
scscf_serviceroute_uri_str.len = orig_prefix.len;
if (scscf_name_str.len > 4
&& strncasecmp(scscf_name_str.s, "sip:", 4) == 0) {
memcpy(scscf_serviceroute_uri_str.s + scscf_serviceroute_uri_str.len,
scscf_name_str.s + 4, scscf_name_str.len - 4);
scscf_serviceroute_uri_str.len += scscf_name_str.len - 4;
} else {
memcpy(scscf_serviceroute_uri_str.s + scscf_serviceroute_uri_str.len,
scscf_name_str.s, scscf_name_str.len);
scscf_serviceroute_uri_str.len += scscf_name_str.len;
}
pv_tmx_data_init();
/* </build required strings> */
#ifdef STATISTICS
/* register statistics */
if (register_module_stats(exports.name, mod_stats) != 0) {
LM_ERR("failed to register core statistics\n");
return -1;
}
if (!register_stats()) {
LM_ERR("Unable to register statistics\n");
return -1;
}
#endif
/*register space for notification processors*/
register_procs(notification_processes);
cfg_register_child(notification_processes);
/* bind the SL API */
if (sl_load_api(&slb) != 0) {
LM_ERR("cannot bind to SL API\n");
return -1;
}
/* load the TM API */
if (load_tm_api(&tmb) != 0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* load the CDP API */
if (load_cdp_api(&cdpb) != 0) {
LM_ERR("can't load CDP API\n");
return -1;
}
cdp_avp = load_cdp_avp();
if (!cdp_avp) {
LM_ERR("can't load CDP_AVP API\n");
return -1;
}
if (cfg_declare("registrar", registrar_cfg_def, &default_registrar_cfg,
cfg_sizeof(registrar), ®istrar_cfg)) {
LM_ERR("Fail to declare the configuration\n");
return -1;
}
if (rcv_avp_param && *rcv_avp_param) {
s.s = rcv_avp_param;
s.len = strlen(s.s);
if (pv_parse_spec(&s, &avp_spec) == 0 || avp_spec.type != PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n", rcv_avp_param);
return -1;
}
if (pv_get_avp_name(0, &avp_spec.pvp, &rcv_avp_name, &rcv_avp_type)
!= 0) {
LM_ERR("[%s]- invalid AVP definition\n", rcv_avp_param);
return -1;
}
} else {
rcv_avp_name.n = 0;
rcv_avp_type = 0;
}
if (aor_avp_param && *aor_avp_param) {
s.s = aor_avp_param;
s.len = strlen(s.s);
if (pv_parse_spec(&s, &avp_spec) == 0 || avp_spec.type != PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n", aor_avp_param);
return -1;
}
if (pv_get_avp_name(0, &avp_spec.pvp, &aor_avp_name, &aor_avp_type)
!= 0) {
LM_ERR("[%s]- invalid AVP definition\n", aor_avp_param);
return -1;
}
} else {
aor_avp_name.n = 0;
aor_avp_type = 0;
}
if (reg_callid_avp_param && *reg_callid_avp_param) {
s.s = reg_callid_avp_param;
s.len = strlen(s.s);
if (pv_parse_spec(&s, &avp_spec) == 0 || avp_spec.type != PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n", reg_callid_avp_param);
return -1;
}
if (pv_get_avp_name(0, &avp_spec.pvp, ®_callid_avp_name,
®_callid_avp_type) != 0) {
LM_ERR("[%s]- invalid AVP definition\n", reg_callid_avp_param);
return -1;
}
} else {
reg_callid_avp_name.n = 0;
reg_callid_avp_type = 0;
}
bind_usrloc = (bind_usrloc_t) find_export("ul_bind_usrloc", 1, 0);
if (!bind_usrloc) {
LM_ERR("can't bind usrloc\n");
return -1;
}
/* Normalize default_q parameter */
dq = cfg_get(registrar, registrar_cfg, default_q);
if (dq != Q_UNSPECIFIED) {
if (dq > MAX_Q) {
LM_DBG("default_q = %d, lowering to MAX_Q: %d\n", dq, MAX_Q);
dq = MAX_Q;
} else if (dq < MIN_Q) {
LM_DBG("default_q = %d, raising to MIN_Q: %d\n", dq, MIN_Q);
dq = MIN_Q;
}
}
cfg_get(registrar, registrar_cfg, default_q) = dq;
if (bind_usrloc(&ul) < 0) {
return -1;
}
/*Register for callback of URECORD being deleted - so we can send a SAR*/
if (ul.register_ulcb == NULL) {
LM_ERR("Could not import ul_register_ulcb\n");
return -1;
}
if (ul.register_ulcb(0, 0, UL_IMPU_INSERT, ul_impu_inserted, 0) < 0) {
LM_ERR("can not register callback for insert\n");
return -1;
}
if (sock_hdr_name.s) {
if (sock_hdr_name.len == 0 || sock_flag == -1) {
LM_WARN("empty sock_hdr_name or sock_flag no set -> reseting\n");
sock_hdr_name.len = 0;
sock_flag = -1;
}
} else if (sock_flag != -1) {
LM_WARN("sock_flag defined but no sock_hdr_name -> reseting flag\n");
sock_flag = -1;
}
/* fix the flags */
sock_flag = (sock_flag != -1) ? (1 << sock_flag) : 0;
tcp_persistent_flag =
(tcp_persistent_flag != -1) ? (1 << tcp_persistent_flag) : 0;
/* init the registrar notifications */
if (!notify_init()) return -1;
/* register the registrar notifications timer */
//Currently we do not use this - we send notifies immediately
//if (register_timer(notification_timer, notification_list, 5) < 0) return -1;
return 0;
}
/*! \brief Initialize fifo transport */
int jsonrpc_init_fifo_file(void)
{
int n;
struct stat filestat;
/* checking the jsonrpc_fifo module param */
if (jsonrpc_fifo==NULL || *jsonrpc_fifo == 0) {
jsonrpc_fifo=NULL;
LM_DBG("No fifo configured\n");
return 0;
}
LM_DBG("testing if fifo file exists ...\n");
n=stat(jsonrpc_fifo, &filestat);
if (n==0) {
/* FIFO exist, delete it (safer) if no config check */
if(config_check==0) {
if (unlink(jsonrpc_fifo)<0){
LM_ERR("Cannot delete old fifo (%s): %s\n",
jsonrpc_fifo, strerror(errno));
return -1;
}
}
} else if (n<0 && errno!=ENOENT){
LM_ERR("MI FIFO stat failed: %s\n", strerror(errno));
return -1;
}
/* checking the fifo_reply_dir param */
if(!jsonrpc_fifo_reply_dir || *jsonrpc_fifo_reply_dir == 0) {
LM_ERR("fifo_reply_dir parameter is empty\n");
return -1;
}
/* Check if the directory for the reply fifo exists */
n = stat(jsonrpc_fifo_reply_dir, &filestat);
if(n < 0){
LM_ERR("Directory stat for MI Fifo reply failed: %s\n", strerror(errno));
return -1;
}
if(S_ISDIR(filestat.st_mode) == 0){
LM_ERR("fifo_reply_dir parameter is not a directory\n");
return -1;
}
/* check fifo_mode */
if(!jsonrpc_fifo_mode){
LM_WARN("cannot specify fifo_mode = 0, forcing it to rw-------\n");
jsonrpc_fifo_mode = S_IRUSR | S_IWUSR;
}
if (jsonrpc_fifo_uid_s){
if (user2uid(&jsonrpc_fifo_uid, &jsonrpc_fifo_gid, jsonrpc_fifo_uid_s)<0){
LM_ERR("Bad user name %s\n", jsonrpc_fifo_uid_s);
return -1;
}
}
if (jsonrpc_fifo_gid_s){
if (group2gid(&jsonrpc_fifo_gid, jsonrpc_fifo_gid_s)<0){
LM_ERR("Bad group name %s\n", jsonrpc_fifo_gid_s);
return -1;
}
}
/* add space for one extra process */
register_procs(1);
/* add child to update local config framework structures */
cfg_register_child(1);
return 0;
}
static void inner_main(void * closure, int argc, char ** argv)
{
register_procs();
scm_c_eval_string("(define (rule a b) (* a b))");
printf("Probability: %f\n",scm_to_double(scm_c_eval_string("(context (list (rule (ambient-light-range .6 1.0) 0.7) (rule (usb-device \"Microsoft Wireless Optical Mouse® 1.00\") 0.9)))")));
}
static int mi_mod_init(void)
{
unsigned int port_no;
int n;
struct stat filestat;
struct hostent * host;
char *p, *host_s;
str port_str;
/* checking the mi_socket module param */
LM_DBG("testing socket existance...\n");
if( mi_socket==NULL || *mi_socket == 0) {
LM_ERR("no DATAGRAM_ socket configured\n");
return -1;
}
LM_DBG("the socket's name/address is %s\n", mi_socket);
memset( &mi_dtgram_addr, 0, sizeof(mi_dtgram_addr) );
if(strncmp(mi_socket, "udp:",4) == 0)
{
/*for an UDP socket*/
LM_DBG("we have an udp socket\n");
/*separate proto and host */
p = mi_socket+4;
if( (*(p)) == '\0') {
LM_ERR("malformed ip address\n");
return -1;
}
host_s=p;
LM_DBG("the remaining address after separating the protocol is %s\n",p);
if( (p = strrchr(p+1, ':')) == 0 ) {
LM_ERR("no port specified\n");
return -1;
}
/*the address contains a port number*/
*p = '\0';
p++;
port_str.s = p;
port_str.len = strlen(p);
LM_DBG("the port string is %s\n", p);
if(str2int(&port_str, &port_no) != 0 ) {
LM_ERR("there is not a valid number port\n");
return -1;
}
*p = '\0';
if (port_no<1024 || port_no>MAX_NB_PORT)
{
LM_ERR("invalid port number; must be in [1024,%d]\n",MAX_NB_PORT);
return -1;
}
if(! (host = resolvehost(host_s)) ) {
LM_ERR("failed to resolve %s\n", host_s);
return -1;
}
LM_DBG("the ip is %s\n",host_s);
if(hostent2su( &(mi_dtgram_addr.udp_addr), host, 0, port_no ) !=0){
LM_ERR("failed to resolve %s\n", mi_socket);
return -1;
}
mi_socket_domain = host->h_addrtype;
goto done;
}
/* in case of a Unix socket*/
LM_DBG("we have an UNIX socket\n");
n=stat(mi_socket, &filestat);
if( n==0) {
LM_INFO("the socket %s already exists, trying to delete it...\n", mi_socket);
if(config_check==0) {
if (unlink(mi_socket)<0) {
LM_ERR("cannot delete old socket: %s\n", strerror(errno));
return -1;
}
}
} else if (n<0 && errno!=ENOENT) {
LM_ERR("socket stat failed:%s\n", strerror(errno));
return -1;
}
/* check mi_unix_socket_mode */
if(!mi_unix_socket_mode) {
LM_WARN("cannot specify mi_unix_socket_mode = 0, forcing it to rw-------\n");
mi_unix_socket_mode = S_IRUSR| S_IWUSR;
}
if (mi_unix_socket_uid_s) {
if (user2uid(&mi_unix_socket_uid, &mi_unix_socket_gid, mi_unix_socket_uid_s)<0) {
LM_ERR("bad user name %s\n", mi_unix_socket_uid_s);
return -1;
}
}
if (mi_unix_socket_gid_s) {
if (group2gid(&mi_unix_socket_gid, mi_unix_socket_gid_s)<0) {
LM_ERR("bad group name %s\n", mi_unix_socket_gid_s);
return -1;
}
}
/*create the unix socket address*/
mi_dtgram_addr.unix_addr.sun_family = AF_LOCAL;
memcpy( mi_dtgram_addr.unix_addr.sun_path, mi_socket, strlen(mi_socket));
done:
/* add space for extra processes */
register_procs(mi_procs[0].no);
/* add child to update local config framework structures */
cfg_register_child(mi_procs[0].no);
return 0;
}
/**
* init module function
*/
static int mod_init(void)
{
unsigned int n;
LM_INFO("Initializing Http Async module\n");
#ifdef STATISTICS
/* register statistics */
if (register_module_stats( exports.name, mod_stats)!=0 ) {
LM_ERR("failed to register core statistics\n");
return -1;
}
#endif
/* sanitize hash_size */
if (hash_size < 1){
LM_WARN("hash_size is smaller "
"than 1 -> rounding from %d to 1\n",
hash_size);
hash_size = 1;
}
/* check that the hash table size is a power of 2 */
for( n=0 ; n<(8*sizeof(n)) ; n++) {
if (hash_size==(1<<n))
break;
if (n && hash_size<(1<<n)) {
LM_WARN("hash_size is not a power "
"of 2 as it should be -> rounding from %d to %d (n=%d)\n",
hash_size, 1<<(n-1), n);
hash_size = 1<<(n-1);
break;
}
}
/* check 'workers' param */
if (num_workers < 1) {
LM_ERR("the 'workers' parameter must be >= 1\n");
return -1;
}
tls_verify_host = tls_verify_host?1:0;
tls_verify_peer = tls_verify_peer?1:0;
/* init http parameters list */
init_query_params(&ah_params);
if (strncmp("shm", memory_manager, 3) == 0) {
curl_memory_manager = 0;
} else if (strncmp("sys", memory_manager, 3) == 0) {
curl_memory_manager = 1;
} else {
LM_ERR("invalid memory_manager parameter: '%s'\n", memory_manager);
return -1;
}
if (strncmp("shm", memory_manager, 3) == 0) {
curl_memory_manager = 0;
} else if (strncmp("sys", memory_manager, 3) == 0) {
curl_memory_manager = 1;
} else {
LM_ERR("invalid memory_manager parameter: '%s'\n", memory_manager);
return -1;
}
/* init faked sip msg */
if(faked_msg_init()<0) {
LM_ERR("failed to init faked sip msg\n");
return -1;
}
if(load_tm_api( &tmb ) < 0) {
LM_INFO("cannot load the TM-functions - async relay disabled\n");
memset(&tmb, 0, sizeof(tm_api_t));
}
/* allocate workers array */
workers = shm_malloc(num_workers * sizeof(*workers));
if(workers == NULL) {
LM_ERR("error in shm_malloc\n");
return -1;
}
memset(workers, 0, num_workers * sizeof(*workers));
register_procs(num_workers);
/* add child to update local config framework structures */
cfg_register_child(num_workers);
return 0;
}
