/** * init module function */ static int mod_init(void) { /* load the TM API */ if (load_tm_api(&_tmx_tmb)!=0) { LM_ERR("can't load TM API\n"); return -1; } if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } #ifdef STATISTICS /* register statistics */ if (register_module_stats( exports.name, mod_stats)!=0 ) { LM_ERR("failed to register statistics\n"); return -1; } #endif pv_tmx_data_init(); if (register_script_cb(tmx_cfg_callback, POST_SCRIPT_CB|REQUEST_CB,0)<0) { LM_ERR("cannot register post-script callback\n"); return -1; } return 0; }
static int mod_init(void) { if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(dialplan_init_rpc()!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } LM_DBG("db_url=%s/%d/%p\n", ZSW(dp_db_url.s), dp_db_url.len,dp_db_url.s); if(attr_pvar_s.s && attr_pvar_s.len>0) { attr_pvar = pv_cache_get(&attr_pvar_s); if( (attr_pvar==NULL) || ((attr_pvar->type != PVT_AVP) && (attr_pvar->type != PVT_XAVP) && (attr_pvar->type!=PVT_SCRIPTVAR))) { LM_ERR("invalid pvar name\n"); return -1; } } default_par2 = (dp_param_p)shm_malloc(sizeof(dp_param_t)); if(default_par2 == NULL){ LM_ERR("no shm more memory\n"); return -1; } memset(default_par2, 0, sizeof(dp_param_t)); /* emulate "$rU/$rU" as second parameter for dp_translate() */ default_param_s.len = strlen(default_param_s.s); default_par2->v.sp[0] = pv_cache_get(&default_param_s); if (default_par2->v.sp[0]==NULL) { LM_ERR("input pv is invalid\n"); return -1; } default_param_s.len = strlen(default_param_s.s); default_par2->v.sp[1] = pv_cache_get(&default_param_s); if (default_par2->v.sp[1]==NULL) { LM_ERR("output pv is invalid\n"); return -1; } if(dp_fetch_rows<=0) dp_fetch_rows = 1000; if(init_data() != 0) { LM_ERR("could not initialize data\n"); return -1; } return 0; }
int init_mi_core(void) { if (register_mi_mod( "core", mi_core_cmds)<0) { LM_ERR("unable to register core MI cmds\n"); return -1; } return 0; }
int register_mi_stats(void) { /* register MI commands */ if (register_mi_mod("core", mi_stat_cmds)<0) { LM_ERR("unable to register MI cmds\n"); return -1; } return 0; }
/** * mi init function */ int pdt_init_mi(char *mod) { if(register_mi_mod(mod, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } return 0; }
static int mod_init(void) { if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } return 0; }
/** * 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; } if(htable_init_rpc()!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } if(ht_init_tables()!=0) return -1; ht_db_init_params(); if(ht_db_url.len>0) { if(ht_db_init_con()!=0) return -1; if(ht_db_open_con()!=0) return -1; if(ht_db_load_tables()!=0) { ht_db_close_con(); return -1; } ht_db_close_con(); } if(ht_has_autoexpire()) { LM_DBG("starting auto-expire timer\n"); if(ht_timer_interval<=0) ht_timer_interval = 20; if(ht_timer_procs<=0) { if(register_timer(ht_timer, 0, ht_timer_interval)<0) { LM_ERR("failed to register timer function\n"); return -1; } } else { register_sync_timers(ht_timer_procs); } } if (ht_enable_dmq>0 && ht_dmq_initialize()!=0) { LM_ERR("failed to initialize dmq integration\n"); return -1; } ht_iterator_init(); return 0; }
/* * module initialization 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; } if(permissions_init_rpc()!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } allow[0].filename = get_pathname(default_allow_file); allow[0].rules = parse_config_file(allow[0].filename); if (allow[0].rules) { LM_DBG("default allow file (%s) parsed\n", allow[0].filename); } else { LM_INFO("default allow file (%s) not found => empty rule set\n", allow[0].filename); } deny[0].filename = get_pathname(default_deny_file); deny[0].rules = parse_config_file(deny[0].filename); if (deny[0].rules) { LM_DBG("default deny file (%s) parsed\n", deny[0].filename); } else { LM_INFO("default deny file (%s) not found => empty rule set\n", deny[0].filename); } if (init_trusted() != 0) { LM_ERR("failed to initialize the allow_trusted function\n"); return -1; } if (init_tag_avp(&tag_avp_param) < 0) { LM_ERR("failed to process peer_tag_avp AVP param\n"); return -1; } if (init_addresses() != 0) { LM_ERR("failed to initialize the allow_address function\n"); return -1; } if ((db_mode != DISABLE_CACHE) && (db_mode != ENABLE_CACHE)) { LM_ERR("invalid db_mode value: %d\n", db_mode); return -1; } rules_num = 1; return 0; }
/** * init module function */ static int mod_init(void) { if(!mq_head_defined()) LM_WARN("no mqueue defined\n"); if(register_mi_mod(exports.name, mi_cmds) != 0) { LM_ERR("failed to register MI commands\n"); return 1; } return 0; }
static int mod_init(void) { bind_auth_s_t bind_auth; if (register_mi_mod(exports.name, mi_cmds) != 0) { LM_ERR("registering MI commands\n"); return -1; } if (secret_list == NULL) { LM_ERR("secret modparam not set\n"); return -1; } switch(autheph_username_format) { case AUTHEPH_USERNAME_NON_IETF: LM_WARN("the %d value for the username_format modparam is " "deprecated. You should update the web-service that " "generates credentials to use the format specified in " "draft-uberti-rtcweb-turn-rest.\n", autheph_username_format); /* Fall-thru */ case AUTHEPH_USERNAME_IETF: break; default: LM_ERR("bad value for username_format modparam: %d\n", autheph_username_format); return -1; } bind_auth = (bind_auth_s_t) find_export("bind_auth_s", 0, 0); if (bind_auth) { if (bind_auth(&eph_auth_api) < 0) { LM_ERR("unable to bind to auth module\n"); return -1; } } else { memset(&eph_auth_api, 0, sizeof(auth_api_s_t)); LM_INFO("auth module not loaded - digest authentication and " "check functions will not be available\n"); } return 0; }
/* * mod_init * Called by Kamailio at init time */ static int mod_init(void) { if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } bm_mycfg = (bm_cfg_t*)shm_malloc(sizeof(bm_cfg_t)); memset(bm_mycfg, 0, sizeof(bm_cfg_t)); bm_mycfg->enable_global = bm_enable_global; bm_mycfg->granularity = bm_granularity; bm_mycfg->loglevel = bm_loglevel; return 0; }
static int mod_init(void) { if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(pv_init_rpc()!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } pv_init_sbranch(); return 0; }
int init_stats_collector(void) { /* init the collector */ collector = (stats_collector*)shm_malloc(sizeof(stats_collector)); if (collector==0) { LM_ERR("no more shm mem\n"); goto error; } memset( collector, 0 , sizeof(stats_collector)); #ifdef NO_ATOMIC_OPS /* init BIG (really BIG) lock */ stat_lock = lock_alloc(); if (stat_lock==0 || lock_init( stat_lock )==0 ) { LM_ERR("failed to init the really BIG lock\n"); goto error; } #endif /* register MI commands */ if (register_mi_mod( "statistics", mi_stat_cmds)<0) { LM_ERR("unable to register MI cmds\n"); goto error; } /* register core statistics */ if (register_module_stats( "core", core_stats)!=0 ) { LM_ERR("failed to register core statistics\n"); goto error; } /* register sh_mem statistics */ if (register_module_stats( "shmem", shm_stats)!=0 ) { LM_ERR("failed to register sh_mem statistics\n"); goto error; } /* register sh_mem statistics */ if (register_module_stats( "net", net_stats)!=0 ) { LM_ERR("failed to register network statistics\n"); goto error; } LM_DBG("statistics manager successfully initialized\n"); return 0; error: return -1; }
static int mod_init(void) { if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(matrix_rpc_init()<0) { LM_ERR("failed to init RPC commands"); return -1; } if (init_shmlock() != 0) return -1; if (matrix_db_init() != 0) return -1; if (matrix_db_open() != 0) return -1; if (init_matrix() != 0) return -1; matrix_db_close(); return 0; }
int init_mi_core(void) { if (cfg_register_ctx(&_kex_cfg_ctx, NULL)) { LM_ERR("failed to register cfg context\n"); return -1; } if (register_mi_mod( "core", mi_core_cmds)<0) { LM_ERR("unable to register core MI cmds\n"); return -1; } if(init_mi_uptime()<0) { return -1; } return 0; }
static int init_mod( struct sr_module* m ) { if (m) { /* iterate through the list; if error occurs, propagate it up the stack */ if (init_mod(m->next)!=0) return -1; if (m->exports==0) return 0; if (m->exports->init_f) { LM_DBG("initializing module %s\n", m->exports->name); if (m->exports->init_f()!=0) { LM_ERR("failed to initialize" " module %s\n", m->exports->name); return -1; } } /* no init function -- proceed further */ #ifdef STATISTICS if (m->exports->stats) { LM_DBG("registering stats for %s\n", m->exports->name); if (register_module_stats(m->exports->name,m->exports->stats)!=0) { LM_ERR("failed to registering " "statistics for module %s\n", m->exports->name); return -1; } } #endif /* register MI functions */ if (m->exports->mi_cmds) { LM_DBG("register MI for %s\n", m->exports->name); if (register_mi_mod(m->exports->name,m->exports->mi_cmds)!=0) { LM_ERR("failed to register MI functions for module %s\n", m->exports->name); } } /* proceed with success */ return 0; } else { /* end of list */ return 0; } }
int init_black_lists(void) { bl_ctx_idx = context_register_int(CONTEXT_GLOBAL, NULL); if (bl_ctx_idx < 0) return -1; /* register timer routine */ if (register_timer("blcore-expire", delete_expired_routine, 0, 1, TIMER_FLAG_SKIP_ON_DELAY) < 0) { LM_ERR("failed to register timer\n"); return -1; } /* register MI commands */ if (register_mi_mod("blacklists", mi_bl_cmds) < 0) { LM_ERR("unable to register MI cmds\n"); return -1; } return 0; }
int init_mi_core(void) { int i; if (register_mi_mod( "core", mi_core_cmds)<0) { LM_ERR("unable to register core MI cmds\n"); return -1; } /* FIXME - init should't be done here * do MI commands init with all exported MI commands from modules */ for (i=0;mi_core_cmds[i].name;i++) { if (mi_core_cmds[i].init_f && mi_core_cmds[i].init_f() != 0) { LM_ERR("failed to init command %s\n",mi_core_cmds[i].name); } } return 0; }
static int mod_init(void) { if (sl_load_api(&ws_slb) != 0) { LM_ERR("binding to SL\n"); goto error; } if (sr_event_register_cb(SREV_TCP_WS_FRAME_IN, ws_frame_receive) != 0) { LM_ERR("registering WebSocket receive call-back\n"); goto error; } if (sr_event_register_cb(SREV_TCP_WS_FRAME_OUT, ws_frame_transmit) != 0) { LM_ERR("registering WebSocket transmit call-back\n"); goto error; } if (register_module_stats(exports.name, stats) != 0) { LM_ERR("registering core statistics\n"); goto error; } if (register_mi_mod(exports.name, mi_cmds) != 0) { LM_ERR("registering MI commands\n"); goto error; } if (wsconn_init() < 0) { LM_ERR("initialising WebSocket connections table\n"); goto error; } if (ws_ping_application_data.len < 1 || ws_ping_application_data.len > 125) { ws_ping_application_data.s = DEFAULT_PING_APPLICATION_DATA + 8; ws_ping_application_data.len = DEFAULT_PING_APPLICATION_DATA_LEN - 8; } if (ws_keepalive_mechanism != KEEPALIVE_MECHANISM_NONE) { if (ws_keepalive_timeout < 1 || ws_keepalive_timeout > 3600) ws_keepalive_timeout = DEFAULT_KEEPALIVE_TIMEOUT; switch(ws_keepalive_mechanism) { case KEEPALIVE_MECHANISM_PING: case KEEPALIVE_MECHANISM_PONG: break; default: ws_keepalive_mechanism = DEFAULT_KEEPALIVE_MECHANISM; break; } if (ws_keepalive_interval < 1 || ws_keepalive_interval > 60) ws_keepalive_interval = DEFAULT_KEEPALIVE_INTERVAL; if (ws_keepalive_processes < 1 || ws_keepalive_processes > 16) ws_keepalive_processes = DEFAULT_KEEPALIVE_PROCESSES; /* Add extra process/timer for the keepalive process */ register_sync_timers(ws_keepalive_processes); } if (ws_sub_protocols & SUB_PROTOCOL_MSRP && !sr_event_enabled(SREV_TCP_MSRP_FRAME)) ws_sub_protocols &= ~SUB_PROTOCOL_MSRP; if ((ws_sub_protocols & SUB_PROTOCOL_ALL) == 0) { LM_ERR("no sub-protocols enabled\n"); goto error; } if ((ws_sub_protocols | SUB_PROTOCOL_ALL) != SUB_PROTOCOL_ALL) { LM_ERR("unrecognised sub-protocols enabled\n"); goto error; } if (ws_cors_mode < 0 || ws_cors_mode > 2) { LM_ERR("bad value for cors_mode\n"); goto error; } if (cfg_declare("websocket", ws_cfg_def, &default_ws_cfg, cfg_sizeof(websocket), &ws_cfg)) { LM_ERR("declaring configuration\n"); return -1; } cfg_get(websocket, ws_cfg, keepalive_timeout) = ws_keepalive_timeout; if (!module_loaded("xhttp")) { LM_ERR("\"xhttp\" must be loaded to use WebSocket.\n"); return -1; } if (((ws_sub_protocols & SUB_PROTOCOL_SIP) == SUB_PROTOCOL_SIP) && !module_loaded("nathelper") && !module_loaded("outbound")) { LM_WARN("neither \"nathelper\" nor \"outbound\" modules are" " loaded. At least one of these is required for correct" " routing of SIP over WebSocket.\n"); } return 0; error: wsconn_destroy(); return -1; }
static int mod_init(void) { /* Register RPC commands */ if (rpc_register_array(rpc_cmds)!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if (!hash_file) { LM_INFO("no hash_file given, disable hash functionality\n"); } else { if (MD5File(config_hash, hash_file) != 0) { LM_ERR("could not hash the config file"); return -1; } LM_DBG("config file hash is %.*s", MD5_LEN, config_hash); } if (initial_prob > 100) { LM_ERR("invalid probability <%d>\n", initial_prob); return -1; } LM_DBG("initial probability %d percent\n", initial_prob); probability=(int *) shm_malloc(sizeof(int)); if (!probability) { LM_ERR("no shmem available\n"); return -1; } *probability = initial_prob; gflags=(unsigned int *) shm_malloc(sizeof(unsigned int)); if (!gflags) { LM_ERR(" no shmem available\n"); return -1; } *gflags=initial_gflags; gflags_lock = lock_alloc(); if (gflags_lock==0) { LM_ERR("cannot allocate gflgas lock\n"); return -1; } if (lock_init(gflags_lock)==NULL) { LM_ERR("cannot initiate gflags lock\n"); lock_dealloc(gflags_lock); return -1; } if(_cfg_lock_size>0 && _cfg_lock_size<=10) { _cfg_lock_size = 1<<_cfg_lock_size; _cfg_lock_set = lock_set_alloc(_cfg_lock_size); if(_cfg_lock_set==NULL || lock_set_init(_cfg_lock_set)==NULL) { LM_ERR("cannot initiate lock set\n"); return -1; } } return 0; }
/** * 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; }
/* initialize ratelimit module */ static int mod_init(void) { if(rpc_register_array(rpc_methods)!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(pl_hash_size<=0) { LM_ERR("invalid hash size parameter: %d\n", pl_hash_size); return -1; } if(pl_init_htable(1<<pl_hash_size)<0) { LM_ERR("could not allocate pipes htable\n"); return -1; } if(pl_init_db()<0) { LM_ERR("could not load pipes description\n"); return -1; } /* register timer to reset counters */ if ((pl_timer = timer_alloc()) == NULL) { LM_ERR("could not allocate timer\n"); return -1; } timer_init(pl_timer, pl_timer_handle, 0, F_TIMER_FAST); timer_add(pl_timer, MS_TO_TICKS(1000)); /* Start it after 1000ms */ /* bind the SL API */ if (sl_load_api(&slb)!=0) { LM_ERR("cannot bind to SL API\n"); return -1; } network_load_value = shm_malloc(sizeof(int)); if (network_load_value==NULL) { LM_ERR("oom for network_load_value\n"); return -1; } load_value = shm_malloc(sizeof(double)); if (load_value==NULL) { LM_ERR("oom for load_value\n"); return -1; } load_source = shm_malloc(sizeof(int)); if (load_source==NULL) { LM_ERR("oom for load_source\n"); return -1; } pid_kp = shm_malloc(sizeof(double)); if (pid_kp==NULL) { LM_ERR("oom for pid_kp\n"); return -1; } pid_ki = shm_malloc(sizeof(double)); if (pid_ki==NULL) { LM_ERR("oom for pid_ki\n"); return -1; } pid_kd = shm_malloc(sizeof(double)); if (pid_kd==NULL) { LM_ERR("oom for pid_kd\n"); return -1; } _pl_pid_setpoint = shm_malloc(sizeof(double)); if (_pl_pid_setpoint==NULL) { LM_ERR("oom for pid_setpoint\n"); return -1; } drop_rate = shm_malloc(sizeof(int)); if (drop_rate==NULL) { LM_ERR("oom for drop_rate\n"); return -1; } *network_load_value = 0; *load_value = 0.0; *load_source = load_source_mp; *pid_kp = 0.0; *pid_ki = -25.0; *pid_kd = 0.0; *_pl_pid_setpoint = 0.01 * (double)_pl_cfg_setpoint; *drop_rate = 0; return 0; }
/** * init module function */ static int mod_init(void) { LM_DBG("...\n"); if (register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(min_expires< 0) min_expires= 0; if(default_expires< 600) default_expires= 3600; /* load TM API */ if(load_tm_api(&tmb)==-1) { LM_ERR("can't load tm functions\n"); return -1; } db_url.len = db_url.s ? strlen(db_url.s) : 0; LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.s); db_table.len = db_table.s ? strlen(db_table.s) : 0; /* binding to database module */ if (db_bind_mod(&db_url, &pua_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (!DB_CAPABILITY(pua_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions needed" " by the module\n"); return -1; } pua_db = pua_dbf.init(&db_url); if (!pua_db) { LM_ERR("while connecting database\n"); return -1; } /* verify table version */ if(db_check_table_version(&pua_dbf, pua_db, &db_table, PUA_TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); return -1; } if (dbmode != PUA_DB_ONLY) { if(HASH_SIZE<=1) HASH_SIZE= 512; else HASH_SIZE = 1<<HASH_SIZE; HashT= new_htable(); if(HashT== NULL) { LM_ERR("while creating new hash table\n"); return -1; } if(db_restore()< 0) { LM_ERR("while restoring hash_table\n"); return -1; } } if (dbmode != PUA_DB_DEFAULT && dbmode != PUA_DB_ONLY) { dbmode = PUA_DB_DEFAULT; LM_ERR( "Invalid dbmode-using default mode\n" ); } if(update_period<0) { LM_ERR("wrong clean_period\n"); return -1; } if ( init_puacb_list() < 0) { LM_ERR("callbacks initialization failed\n"); return -1; } pua_evlist= init_pua_evlist(); if(pua_evlist==0) { LM_ERR("when initializing pua_evlist\n"); return -1; } if(pua_add_events()< 0) { LM_ERR("while adding events\n"); return -1; } if(check_remote_contact<0 || check_remote_contact>1) { LM_ERR("bad value for check_remote_contact\n"); return -1; } startup_time = (int) time(NULL); if (update_period > 0) /* probably should check > 5 here!! -croc */ register_timer(hashT_clean, 0, update_period- 5); if (dbmode != PUA_DB_ONLY) { if (update_period > 0) register_timer(db_update, 0, update_period); } if(pua_db) pua_dbf.close(pua_db); pua_db = NULL; outbound_proxy.len = outbound_proxy.s ? strlen(outbound_proxy.s) : 0; 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; }
/** * init module function */ static int mod_init(void) { bind_presence_t bind_presence; presence_api_t pres; if(passive_mode==1) return 0; if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } LM_DBG("db_url=%s/%d/%p\n",ZSW(db_url.s),db_url.len, db_url.s); /* bind the SL API */ if (sl_load_api(&slb)!=0) { LM_ERR("cannot bind to SL API\n"); return -1; } bind_presence= (bind_presence_t)find_export("bind_presence", 1,0); if (!bind_presence) { LM_ERR("Can't bind presence\n"); return -1; } if (bind_presence(&pres) < 0) { LM_ERR("Can't bind to presence module\n"); return -1; } pres_get_sphere= pres.get_sphere; pres_add_event= pres.add_event; pres_update_watchers= pres.update_watchers_status; pres_contains_event= pres.contains_event; pres_get_presentity= pres.get_presentity; pres_free_presentity= pres.free_presentity; if (pres_add_event == NULL || pres_update_watchers== NULL) { LM_ERR("Can't import add_event\n"); return -1; } if(xml_add_events()< 0) { LM_ERR("adding xml events\n"); return -1; } if(force_active== 0) { /* binding to mysql module */ if (db_bind_mod(&db_url, &pxml_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (!DB_CAPABILITY(pxml_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions" " needed by the module\n"); return -1; } pxml_db = pxml_dbf.init(&db_url); if (!pxml_db) { LM_ERR("while connecting to database\n"); return -1; } if(db_check_table_version(&pxml_dbf, pxml_db, &xcap_table, S_TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); return -1; } if(!integrated_xcap_server ) { xcap_api_t xcap_api; bind_xcap_t bind_xcap; /* bind xcap */ bind_xcap= (bind_xcap_t)find_export("bind_xcap", 1, 0); if (!bind_xcap) { LM_ERR("Can't bind xcap_client\n"); return -1; } if (bind_xcap(&xcap_api) < 0) { LM_ERR("Can't bind xcap_api\n"); return -1; } xcap_GetNewDoc= xcap_api.getNewDoc; if(xcap_GetNewDoc== NULL) { LM_ERR("can't import get_elem from xcap_client module\n"); return -1; } if(xcap_api.register_xcb(PRES_RULES, xcap_doc_updated)< 0) { LM_ERR("registering xcap callback function\n"); return -1; } } } if(shm_copy_xcap_list()< 0) { LM_ERR("copying xcap server list in share memory\n"); return -1; } if(pxml_db) pxml_dbf.close(pxml_db); pxml_db = NULL; return 0; }
/** * init module function */ static int mod_init(void) { pv_spec_t avp_spec; if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(ds_init_rpc()<0) { LM_ERR("failed to register RPC commands\n"); return -1; } if (dst_avp_param.s) dst_avp_param.len = strlen(dst_avp_param.s); if (grp_avp_param.s) grp_avp_param.len = strlen(grp_avp_param.s); if (cnt_avp_param.s) cnt_avp_param.len = strlen(cnt_avp_param.s); if (dstid_avp_param.s) dstid_avp_param.len = strlen(dstid_avp_param.s); if (attrs_avp_param.s) attrs_avp_param.len = strlen(attrs_avp_param.s); if (hash_pvar_param.s) hash_pvar_param.len = strlen(hash_pvar_param.s); if (ds_setid_pvname.s) ds_setid_pvname.len = strlen(ds_setid_pvname.s); if (ds_attrs_pvname.s) ds_attrs_pvname.len = strlen(ds_attrs_pvname.s); if (ds_ping_from.s) ds_ping_from.len = strlen(ds_ping_from.s); if (ds_ping_method.s) ds_ping_method.len = strlen(ds_ping_method.s); if (ds_outbound_proxy.s) ds_outbound_proxy.len = strlen(ds_outbound_proxy.s); if(cfg_declare("dispatcher", dispatcher_cfg_def, &default_dispatcher_cfg, cfg_sizeof(dispatcher), &dispatcher_cfg)){ LM_ERR("Fail to declare the configuration\n"); return -1; } /* Initialize the counter */ ds_ping_reply_codes = (int**)shm_malloc(sizeof(unsigned int*)); *ds_ping_reply_codes = 0; ds_ping_reply_codes_cnt = (int*)shm_malloc(sizeof(int)); *ds_ping_reply_codes_cnt = 0; if(ds_ping_reply_codes_str.s) { ds_ping_reply_codes_str.len = strlen(ds_ping_reply_codes_str.s); cfg_get(dispatcher, dispatcher_cfg, ds_ping_reply_codes_str) = ds_ping_reply_codes_str; if(ds_parse_reply_codes()< 0) { return -1; } } /* Copy Threshhold to Config */ cfg_get(dispatcher, dispatcher_cfg, probing_threshhold) = probing_threshhold; if(init_data()!= 0) return -1; if(ds_db_url.s) { ds_db_url.len = strlen(ds_db_url.s); ds_table_name.len = strlen(ds_table_name.s); ds_set_id_col.len = strlen(ds_set_id_col.s); ds_dest_uri_col.len = strlen(ds_dest_uri_col.s); ds_dest_flags_col.len = strlen(ds_dest_flags_col.s); ds_dest_priority_col.len = strlen(ds_dest_priority_col.s); ds_dest_attrs_col.len = strlen(ds_dest_attrs_col.s); if(init_ds_db()!= 0) { LM_ERR("could not initiate a connect to the database\n"); return -1; } } else { if(ds_load_list(dslistfile)!=0) { LM_ERR("no dispatching list loaded from file\n"); return -1; } else { LM_DBG("loaded dispatching list\n"); } } if (dst_avp_param.s && dst_avp_param.len > 0) { if (pv_parse_spec(&dst_avp_param, &avp_spec)==0 || avp_spec.type!=PVT_AVP) { LM_ERR("malformed or non AVP %.*s AVP definition\n", dst_avp_param.len, dst_avp_param.s); return -1; } if(pv_get_avp_name(0, &(avp_spec.pvp), &dst_avp_name, &dst_avp_type)!=0) { LM_ERR("[%.*s]- invalid AVP definition\n", dst_avp_param.len, dst_avp_param.s); return -1; } } else { dst_avp_name.n = 0; dst_avp_type = 0; } if (grp_avp_param.s && grp_avp_param.len > 0) { if (pv_parse_spec(&grp_avp_param, &avp_spec)==0 || avp_spec.type!=PVT_AVP) { LM_ERR("malformed or non AVP %.*s AVP definition\n", grp_avp_param.len, grp_avp_param.s); return -1; } if(pv_get_avp_name(0, &(avp_spec.pvp), &grp_avp_name, &grp_avp_type)!=0) { LM_ERR("[%.*s]- invalid AVP definition\n", grp_avp_param.len, grp_avp_param.s); return -1; } } else { grp_avp_name.n = 0; grp_avp_type = 0; } if (cnt_avp_param.s && cnt_avp_param.len > 0) { if (pv_parse_spec(&cnt_avp_param, &avp_spec)==0 || avp_spec.type!=PVT_AVP) { LM_ERR("malformed or non AVP %.*s AVP definition\n", cnt_avp_param.len, cnt_avp_param.s); return -1; } if(pv_get_avp_name(0, &(avp_spec.pvp), &cnt_avp_name, &cnt_avp_type)!=0) { LM_ERR("[%.*s]- invalid AVP definition\n", cnt_avp_param.len, cnt_avp_param.s); return -1; } } else { cnt_avp_name.n = 0; cnt_avp_type = 0; } if (dstid_avp_param.s && dstid_avp_param.len > 0) { if (pv_parse_spec(&dstid_avp_param, &avp_spec)==0 || avp_spec.type!=PVT_AVP) { LM_ERR("malformed or non AVP %.*s AVP definition\n", dstid_avp_param.len, dstid_avp_param.s); return -1; } if(pv_get_avp_name(0, &(avp_spec.pvp), &dstid_avp_name, &dstid_avp_type)!=0) { LM_ERR("[%.*s]- invalid AVP definition\n", dstid_avp_param.len, dstid_avp_param.s); return -1; } } else { dstid_avp_name.n = 0; dstid_avp_type = 0; } if (attrs_avp_param.s && attrs_avp_param.len > 0) { if (pv_parse_spec(&attrs_avp_param, &avp_spec)==0 || avp_spec.type!=PVT_AVP) { LM_ERR("malformed or non AVP %.*s AVP definition\n", attrs_avp_param.len, attrs_avp_param.s); return -1; } if(pv_get_avp_name(0, &(avp_spec.pvp), &attrs_avp_name, &attrs_avp_type)!=0) { LM_ERR("[%.*s]- invalid AVP definition\n", attrs_avp_param.len, attrs_avp_param.s); return -1; } } else { attrs_avp_name.n = 0; attrs_avp_type = 0; } if (hash_pvar_param.s && *hash_pvar_param.s) { if(pv_parse_format(&hash_pvar_param, &hash_param_model) < 0 || hash_param_model==NULL) { LM_ERR("malformed PV string: %s\n", hash_pvar_param.s); return -1; } } else { hash_param_model = NULL; } if(ds_setid_pvname.s!=0) { if(pv_parse_spec(&ds_setid_pvname, &ds_setid_pv)==NULL || !pv_is_w(&ds_setid_pv)) { LM_ERR("[%s]- invalid setid_pvname\n", ds_setid_pvname.s); return -1; } } if(ds_attrs_pvname.s!=0) { if(pv_parse_spec(&ds_attrs_pvname, &ds_attrs_pv)==NULL || !pv_is_w(&ds_attrs_pv)) { LM_ERR("[%s]- invalid attrs_pvname\n", ds_attrs_pvname.s); return -1; } } if (dstid_avp_param.s && dstid_avp_param.len > 0) { if(ds_hash_size>0) { if(ds_hash_load_init(1<<ds_hash_size, ds_hash_expire, ds_hash_initexpire)<0) return -1; register_timer(ds_ht_timer, NULL, ds_hash_check_interval); } else { LM_ERR("call load dispatching DSTID_AVP set but no size" " for hash table\n"); return -1; } } /* Only, if the Probing-Timer is enabled the TM-API needs to be loaded: */ if (ds_ping_interval > 0) { /***************************************************** * TM-Bindings *****************************************************/ if (load_tm_api( &tmb ) == -1) { LM_ERR("could not load the TM-functions - disable DS ping\n"); return -1; } /***************************************************** * Register the PING-Timer *****************************************************/ register_timer(ds_check_timer, NULL, ds_ping_interval); } return 0; }
static int mod_init(void) { unsigned int n; if(dlg_ka_interval!=0 && dlg_ka_interval<30) { LM_ERR("ka interval too low (%d), has to be at least 30\n", dlg_ka_interval); return -1; } dlg_event_rt[DLG_EVENTRT_START] = route_lookup(&event_rt, "dialog:start"); dlg_event_rt[DLG_EVENTRT_END] = route_lookup(&event_rt, "dialog:end"); dlg_event_rt[DLG_EVENTRT_FAILED] = route_lookup(&event_rt, "dialog:failed"); #ifdef STATISTICS /* register statistics */ if (register_module_stats( exports.name, mod_stats)!=0 ) { LM_ERR("failed to register %s statistics\n", exports.name); return -1; } #endif if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if (rpc_register_array(rpc_methods)!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } if(faked_msg_init()<0) return -1; if(dlg_bridge_init_hdrs()<0) return -1; /* param checkings */ if (dlg_flag==-1) { LM_ERR("no dlg flag set!!\n"); return -1; } else if (dlg_flag>MAX_FLAG) { LM_ERR("invalid dlg flag %d!!\n",dlg_flag); return -1; } if (rr_param==0 || rr_param[0]==0) { LM_ERR("empty rr_param!!\n"); return -1; } else if (strlen(rr_param)>MAX_DLG_RR_PARAM_NAME) { LM_ERR("rr_param too long (max=%d)!!\n", MAX_DLG_RR_PARAM_NAME); return -1; } if (timeout_spec.s) { if ( pv_parse_spec(&timeout_spec, &timeout_avp)==0 && (timeout_avp.type!=PVT_AVP)){ LM_ERR("malformed or non AVP timeout " "AVP definition in '%.*s'\n", timeout_spec.len,timeout_spec.s); return -1; } } if (default_timeout<=0) { LM_ERR("0 default_timeout not accepted!!\n"); return -1; } if (ruri_pvar_param.s==NULL || ruri_pvar_param.len<=0) { LM_ERR("invalid r-uri PV string\n"); return -1; } if(pv_parse_format(&ruri_pvar_param, &ruri_param_model) < 0 || ruri_param_model==NULL) { LM_ERR("malformed r-uri PV string: %s\n", ruri_pvar_param.s); return -1; } if (initial_cbs_inscript != 0 && initial_cbs_inscript != 1) { LM_ERR("invalid parameter for running initial callbacks in-script" " (must be either 0 or 1)\n"); return -1; } if (seq_match_mode!=SEQ_MATCH_NO_ID && seq_match_mode!=SEQ_MATCH_FALLBACK && seq_match_mode!=SEQ_MATCH_STRICT_ID ) { LM_ERR("invalid value %d for seq_match_mode param!!\n",seq_match_mode); return -1; } if (detect_spirals != 0 && detect_spirals != 1) { LM_ERR("invalid value %d for detect_spirals param!!\n",detect_spirals); return -1; } if (dlg_timeout_noreset != 0 && dlg_timeout_noreset != 1) { LM_ERR("invalid value %d for timeout_noreset param!!\n", dlg_timeout_noreset); return -1; } /* if statistics are disabled, prevent their registration to core */ if (dlg_enable_stats==0) exports.stats = 0; /* create profile hashes */ if (add_profile_definitions( profiles_nv_s, 0)!=0 ) { LM_ERR("failed to add profiles without value\n"); return -1; } if (add_profile_definitions( profiles_wv_s, 1)!=0 ) { LM_ERR("failed to add profiles with value\n"); return -1; } /* load the TM API */ if (load_tm_api(&d_tmb)!=0) { LM_ERR("can't load TM API\n"); return -1; } /* load RR API also */ if (load_rr_api(&d_rrb)!=0) { LM_ERR("can't load RR API\n"); return -1; } /* register callbacks*/ /* listen for all incoming requests */ if ( d_tmb.register_tmcb( 0, 0, TMCB_REQUEST_IN, dlg_onreq, 0, 0 ) <=0 ) { LM_ERR("cannot register TMCB_REQUEST_IN callback\n"); return -1; } /* listen for all routed requests */ if ( d_rrb.register_rrcb( dlg_onroute, 0 ) <0 ) { LM_ERR("cannot register RR callback\n"); return -1; } if (register_script_cb( profile_cleanup, POST_SCRIPT_CB|REQUEST_CB,0)<0) { LM_ERR("cannot register script callback"); return -1; } if (register_script_cb(dlg_cfg_cb, PRE_SCRIPT_CB|REQUEST_CB,0)<0) { LM_ERR("cannot register pre-script ctx callback\n"); return -1; } if (register_script_cb(dlg_cfg_cb, POST_SCRIPT_CB|REQUEST_CB,0)<0) { LM_ERR("cannot register post-script ctx callback\n"); return -1; } if (register_script_cb( spiral_detect_reset, POST_SCRIPT_CB|REQUEST_CB,0)<0) { LM_ERR("cannot register req pre-script spiral detection reset callback\n"); return -1; } if(dlg_timer_procs<=0) { if ( register_timer( dlg_timer_routine, 0, 1)<0 ) { LM_ERR("failed to register timer \n"); return -1; } } else { register_sync_timers(1); } /* init handlers */ init_dlg_handlers( rr_param, dlg_flag, timeout_spec.s?&timeout_avp:0, default_timeout, seq_match_mode); /* init timer */ if (init_dlg_timer(dlg_ontimeout)!=0) { LM_ERR("cannot init timer list\n"); return -1; } /* sanitize dlg_hash_zie */ if (dlg_hash_size < 1){ LM_WARN("hash_size is smaller " "then 1 -> rounding from %d to 1\n", dlg_hash_size); dlg_hash_size = 1; } /* initialized the hash table */ for( n=0 ; n<(8*sizeof(n)) ; n++) { if (dlg_hash_size==(1<<n)) break; if (n && dlg_hash_size<(1<<n)) { LM_WARN("hash_size is not a power " "of 2 as it should be -> rounding from %d to %d\n", dlg_hash_size, 1<<(n-1)); dlg_hash_size = 1<<(n-1); } } if ( init_dlg_table(dlg_hash_size)<0 ) { LM_ERR("failed to create hash table\n"); return -1; } /* if a database should be used to store the dialogs' information */ dlg_db_mode = dlg_db_mode_param; if (dlg_db_mode==DB_MODE_NONE) { db_url.s = 0; db_url.len = 0; } else { if (dlg_db_mode!=DB_MODE_REALTIME && dlg_db_mode!=DB_MODE_DELAYED && dlg_db_mode!=DB_MODE_SHUTDOWN ) { LM_ERR("unsupported db_mode %d\n", dlg_db_mode); return -1; } if ( !db_url.s || db_url.len==0 ) { LM_ERR("db_url not configured for db_mode %d\n", dlg_db_mode); return -1; } if (init_dlg_db(&db_url, dlg_hash_size, db_update_period,db_fetch_rows)!=0) { LM_ERR("failed to initialize the DB support\n"); return -1; } run_load_callbacks(); } destroy_dlg_callbacks( DLGCB_LOADED ); /* timer process to send keep alive requests */ if(dlg_ka_timer>0 && dlg_ka_interval>0) register_sync_timers(1); /* timer process to clean old unconfirmed dialogs */ register_sync_timers(1); return 0; }
/* * mod_init * Called by kamailio at init time */ static int mod_init(void) { int argc = 1; char *argt[] = { MOD_NAME, NULL }; char **argv; struct timeval t1; struct timeval t2; if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if(ap_init_rpc()<0) { LM_ERR("failed to register RPC commands\n"); return -1; } if (!filename) { LM_ERR("insufficient module parameters. Module not loaded.\n"); return -1; } /* bind the SL API */ if (sl_load_api(&slb)!=0) { LM_ERR("cannot bind to SL API\n"); return -1; } _ap_reset_cycles = shm_malloc(sizeof(int)); if(_ap_reset_cycles == NULL) { LM_ERR("no more shared memory\n"); return -1; } *_ap_reset_cycles = _ap_reset_cycles_init; argv = argt; PERL_SYS_INIT3(&argc, &argv, &environ); gettimeofday(&t1, NULL); my_perl = parser_init(); gettimeofday(&t2, NULL); if (my_perl==NULL) goto error; LM_INFO("perl interpreter has been initialized (%d.%06d => %d.%06d)\n", (int)t1.tv_sec, (int)t1.tv_usec, (int)t2.tv_sec, (int)t2.tv_usec); #ifdef PERL_EXIT_DESTRUCT_END PL_exit_flags |= PERL_EXIT_DESTRUCT_END; #else PL_exit_flags |= PERL_EXIT_EXPECTED; #endif return 0; error: if(_ap_reset_cycles!=NULL) shm_free(_ap_reset_cycles); _ap_reset_cycles = NULL; return -1; }
static int mod_init(void) { LM_DBG("initializing\n"); if (register_mi_mod(exports.name, mi_cmds) != 0) { LM_ERR("failed to register MI commands\n"); return -1; } if (domain_init_rpc() != 0) { LM_ERR("failed to register RPC commands\n"); return -1; } if (domain_reg_myself !=0 ) { if (register_check_self_func(domain_check_self) <0 ) { LM_ERR("failed to register check self function\n"); return -1; } } /* Bind database */ if (domain_db_bind(&db_url)) { LM_DBG("Usign db_url [%.*s]\n", db_url.len, db_url.s); LM_ERR("no database module found. Have you configure thed \"db_url\" modparam properly?\n"); return -1; } /* Check table versions */ if (domain_db_init(&db_url) < 0) { LM_ERR("unable to open database connection\n"); return -1; } if (domain_db_ver(&domain_table, DOMAIN_TABLE_VERSION) < 0) { LM_ERR("error during check of domain table version\n"); domain_db_close(); goto error; } if (domain_db_ver(&domain_attrs_table, DOMAIN_ATTRS_TABLE_VERSION) < 0) { LM_ERR("error during check of domain_attrs table version\n"); domain_db_close(); goto error; } domain_db_close(); /* Initializing hash tables and hash table variable */ hash_table = (struct domain_list ***)shm_malloc (sizeof(struct domain_list *)); hash_table_1 = (struct domain_list **)shm_malloc (sizeof(struct domain_list *) * (DOM_HASH_SIZE + 1)); hash_table_2 = (struct domain_list **)shm_malloc (sizeof(struct domain_list *) * (DOM_HASH_SIZE + 1)); if ((hash_table == 0) || (hash_table_1 == 0) || (hash_table_2 == 0)) { LM_ERR("no memory for hash table\n"); goto error; } memset(hash_table_1, 0, sizeof(struct domain_list *) * (DOM_HASH_SIZE + 1)); memset(hash_table_2, 0, sizeof(struct domain_list *) * (DOM_HASH_SIZE + 1)); *hash_table = hash_table_1; /* Allocate and initialize locks */ reload_lock = lock_alloc(); if (reload_lock == NULL) { LM_ERR("cannot allocate reload_lock\n"); goto error; } if (lock_init(reload_lock) == NULL) { LM_ERR("cannot init reload_lock\n"); goto error; } /* First reload */ lock_get(reload_lock); if (reload_tables() == -1) { lock_release(reload_lock); LM_CRIT("domain reload failed\n"); goto error; } lock_release(reload_lock); return 0; error: destroy(); return -1; }
int init_black_lists(void) { struct bl_head *old_blst_heads; struct bl_rule *head; struct bl_rule *tail; struct bl_rule *it, *it1; unsigned int old_used_heads; unsigned int i; if (!no_shm) { LM_CRIT("called twice\n"); return -1; } no_shm = 0; old_blst_heads = blst_heads; blst_heads = (struct bl_head*)shm_malloc(max_heads*sizeof(struct bl_head)); if (blst_heads==NULL) { LM_ERR("no more shm memory!\n"); return -1; } memset( blst_heads, 0, max_heads * sizeof(struct bl_head)); old_used_heads = used_heads; used_heads = 0; bl_default_marker = 0; /*for lists already created, init locks and move them into shm */ for( i=0 ; i<old_used_heads ; i++ ) { /* duplicate in shm */ it = old_blst_heads[i].first; head = tail = 0; for( it1=it ; it ; it=it1 ) { if (add_rule_to_list( &head, &tail, &it->ip_net, &it->body, it->port, it->proto, it->flags)!=0) { LM_ERR("failed to clone rule!\n"); return -1; } it1 = it->next; pkg_free(it); } if (create_bl_head( old_blst_heads[i].owner, old_blst_heads[i].flags, head, tail, &old_blst_heads[i].name )==NULL ) { LM_ERR("failed to clone head!\n"); return -1; } pkg_free(old_blst_heads[i].name.s); } pkg_free(old_blst_heads); /* register timer routine */ if (register_timer( "blcore-expire", delete_expired_routine, 0, 1)<0) { LM_ERR("failed to register timer\n"); return -1; } /* register MI commands */ if (register_mi_mod( "blacklists", mi_bl_cmds)<0) { LM_ERR("unable to register MI cmds\n"); return -1; } return 0; }