int kernel_setup_table(unsigned int id) {
if (kernel.is_wanted)
abort();
kernel.is_wanted = 1;
if (kernel_delete_table(id) && errno != ENOENT) {
ilog(LOG_ERR, "FAILED TO DELETE KERNEL TABLE %i (%s), KERNEL FORWARDING DISABLED",
id, strerror(errno));
return -1;
}
if (kernel_create_table(id)) {
ilog(LOG_ERR, "FAILED TO CREATE KERNEL TABLE %i (%s), KERNEL FORWARDING DISABLED",
id, strerror(errno));
return -1;
}
int fd = kernel_open_table(id);
if (fd == -1) {
ilog(LOG_ERR, "FAILED TO OPEN KERNEL TABLE %i (%s), KERNEL FORWARDING DISABLED",
id, strerror(errno));
return -1;
}
kernel.fd = fd;
kernel.table = id;
kernel.is_open = 1;
return 0;
}
void create_everything(struct main_context *ctx) {
struct callmaster_config mc;
struct control_tcp *ct;
struct control_udp *cu;
struct control_ng *cn;
int kfd = -1;
void *dlh;
const char **strp;
if (table < 0)
goto no_kernel;
if (kernel_create_table(table)) {
fprintf(stderr, "FAILED TO CREATE KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
ilog(LOG_CRIT, "FAILED TO CREATE KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
if (no_fallback)
exit(-1);
goto no_kernel;
}
kfd = kernel_open_table(table);
if (kfd == -1) {
fprintf(stderr, "FAILED TO OPEN KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
ilog(LOG_CRIT, "FAILED TO OPEN KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
if (no_fallback)
exit(-1);
goto no_kernel;
}
no_kernel:
ctx->p = poller_new();
if (!ctx->p)
die("poller creation failed");
ctx->m = callmaster_new(ctx->p);
if (!ctx->m)
die("callmaster creation failed");
dtls_timer(ctx->p);
ZERO(mc);
mc.kernelfd = kfd;
mc.kernelid = table;
mc.interfaces = &interfaces;
mc.port_min = port_min;
mc.port_max = port_max;
mc.timeout = timeout;
mc.silent_timeout = silent_timeout;
mc.default_tos = tos;
mc.b2b_url = b2b_url;
mc.fmt = xmlrpc_fmt;
ct = NULL;
if (listenport) {
ct = control_tcp_new(ctx->p, listenp, listenport, ctx->m);
if (!ct)
die("Failed to open TCP control connection port");
}
cu = NULL;
if (udp_listenport) {
callmaster_exclude_port(ctx->m, udp_listenport);
cu = control_udp_new(ctx->p, udp_listenp, udp_listenport, ctx->m);
if (!cu)
die("Failed to open UDP control connection port");
}
cn = NULL;
if (ng_listenport) {
callmaster_exclude_port(ctx->m, ng_listenport);
cn = control_ng_new(ctx->p, ng_listenp, ng_listenport, ctx->m);
if (!cn)
die("Failed to open UDP control connection port");
}
if (redis_ip) {
dlh = dlopen(MP_PLUGIN_DIR "/rtpengine-redis.so", RTLD_NOW | RTLD_GLOBAL);
if (!dlh && !g_file_test(MP_PLUGIN_DIR "/rtpengine-redis.so", G_FILE_TEST_IS_REGULAR)
&& g_file_test("../../rtpengine-redis/redis.so", G_FILE_TEST_IS_REGULAR))
dlh = dlopen("../../rtpengine-redis/redis.so", RTLD_NOW | RTLD_GLOBAL);
if (!dlh)
die("Failed to open redis plugin, aborting (%s)", dlerror());
strp = dlsym(dlh, "__module_version");
if (!strp || !*strp || strcmp(*strp, REDIS_MODULE_VERSION))
die("Incorrect redis module version: %s", *strp);
redis_mod_verify(dlh);
mc.redis = redis_new_mod(redis_ip, redis_port, redis_db);
if (!mc.redis)
die("Cannot start up without Redis database");
}
ctx->m->conf = mc;
callmaster_config_init(ctx->m);
if (!foreground)
daemonize();
wpidfile();
if (redis_restore(ctx->m, mc.redis))
die("Refusing to continue without working Redis database");
}
void create_everything(struct main_context *ctx) {
struct callmaster_config mc;
struct control_tcp *ct;
struct control_udp *cu;
struct control_ng *cn;
struct cli *cl;
int kfd = -1;
struct timeval tmp_tv;
struct timeval redis_start, redis_stop;
double redis_diff = 0;
if (table < 0)
goto no_kernel;
if (kernel_create_table(table)) {
fprintf(stderr, "FAILED TO CREATE KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
ilog(LOG_CRIT, "FAILED TO CREATE KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
if (no_fallback)
exit(-1);
goto no_kernel;
}
kfd = kernel_open_table(table);
if (kfd == -1) {
fprintf(stderr, "FAILED TO OPEN KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
ilog(LOG_CRIT, "FAILED TO OPEN KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
if (no_fallback)
exit(-1);
goto no_kernel;
}
no_kernel:
ctx->p = poller_new();
if (!ctx->p)
die("poller creation failed");
ctx->m = callmaster_new(ctx->p);
if (!ctx->m)
die("callmaster creation failed");
dtls_timer(ctx->p);
ZERO(mc);
mc.kernelfd = kfd;
mc.kernelid = table;
mc.interfaces = &interfaces;
mc.port_min = port_min;
mc.port_max = port_max;
mc.max_sessions = max_sessions;
mc.timeout = timeout;
mc.silent_timeout = silent_timeout;
mc.delete_delay = delete_delay;
mc.default_tos = tos;
mc.b2b_url = b2b_url;
mc.fmt = xmlrpc_fmt;
mc.graphite_port = graphite_port;
mc.graphite_ip = graphite_ip;
mc.graphite_interval = graphite_interval;
ct = NULL;
if (listenport) {
ct = control_tcp_new(ctx->p, listenp, listenport, ctx->m);
if (!ct)
die("Failed to open TCP control connection port");
}
cu = NULL;
if (udp_listenport) {
callmaster_exclude_port(ctx->m, udp_listenport);
cu = control_udp_new(ctx->p, udp_listenp, udp_listenport, ctx->m);
if (!cu)
die("Failed to open UDP control connection port");
}
cn = NULL;
if (ng_listenport) {
callmaster_exclude_port(ctx->m, ng_listenport);
cn = control_ng_new(ctx->p, ng_listenp, ng_listenport, ctx->m);
if (!cn)
die("Failed to open UDP control connection port");
}
cl = NULL;
if (cli_listenport) {
callmaster_exclude_port(ctx->m, cli_listenport);
cl = cli_new(ctx->p, cli_listenp, cli_listenport, ctx->m);
if (!cl)
die("Failed to open UDP CLI connection port");
}
if (redis_ip) {
mc.redis = redis_new(redis_ip, redis_port, redis_db, MASTER_REDIS_ROLE);
if (!mc.redis)
die("Cannot start up without Redis database");
}
if (redis_read_ip) {
mc.redis_read = redis_new(redis_read_ip, redis_read_port, redis_read_db, ANY_REDIS_ROLE);
if (!mc.redis_read)
die("Cannot start up without Redis read database");
}
if (redis_write_ip) {
mc.redis_write = redis_new(redis_write_ip, redis_write_port, redis_write_db, ANY_REDIS_ROLE);
if (!mc.redis_write)
die("Cannot start up without Redis write database");
}
ctx->m->conf = mc;
callmaster_config_init(ctx->m);
if (!foreground)
daemonize();
wpidfile();
// start redis restore timer
gettimeofday(&redis_start, NULL);
if (mc.redis_read) {
if (redis_restore(ctx->m, mc.redis_read, ANY_REDIS_ROLE))
die("Refusing to continue without working Redis read database");
} else if (mc.redis) {
if (redis_restore(ctx->m, mc.redis, MASTER_REDIS_ROLE))
die("Refusing to continue without working Redis database");
}
// stop redis restore timer
gettimeofday(&redis_stop, NULL);
// print redis restore duration
redis_diff += time_diff_ms(redis_start, redis_stop);
ilog(LOG_INFO, "Redis restore time = %.0lf ms", redis_diff);
gettimeofday(&ctx->m->latest_graphite_interval_start, NULL);
timeval_from_ms(&tmp_tv, graphite_interval*1000000);
set_graphite_interval_tv(&tmp_tv);
}
static void create_everything(struct main_context *ctx) {
struct callmaster_config mc;
struct control_tcp *ct;
struct control_udp *cu;
struct control_ng *cn;
struct cli *cl;
int kfd = -1;
struct timeval tmp_tv;
struct timeval redis_start, redis_stop;
double redis_diff = 0;
if (table < 0)
goto no_kernel;
if (kernel_create_table(table)) {
fprintf(stderr, "FAILED TO CREATE KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
ilog(LOG_CRIT, "FAILED TO CREATE KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
if (no_fallback)
exit(-1);
goto no_kernel;
}
kfd = kernel_open_table(table);
if (kfd == -1) {
fprintf(stderr, "FAILED TO OPEN KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
ilog(LOG_CRIT, "FAILED TO OPEN KERNEL TABLE %i, KERNEL FORWARDING DISABLED\n", table);
if (no_fallback)
exit(-1);
goto no_kernel;
}
no_kernel:
ctx->p = poller_new();
if (!ctx->p)
die("poller creation failed");
ctx->m = callmaster_new(ctx->p);
if (!ctx->m)
die("callmaster creation failed");
dtls_timer(ctx->p);
ZERO(mc);
rwlock_init(&mc.config_lock);
mc.kernelfd = kfd;
mc.kernelid = table;
if (max_sessions < -1) {
max_sessions = -1;
}
mc.max_sessions = max_sessions;
mc.timeout = timeout;
mc.silent_timeout = silent_timeout;
mc.final_timeout = final_timeout;
mc.delete_delay = delete_delay;
mc.default_tos = tos;
mc.b2b_url = b2b_url;
mc.fmt = xmlrpc_fmt;
mc.graphite_ep = graphite_ep;
mc.graphite_interval = graphite_interval;
mc.redis_subscribed_keyspaces = g_queue_copy(&keyspaces);
if (redis_num_threads < 1) {
#ifdef _SC_NPROCESSORS_ONLN
redis_num_threads = sysconf( _SC_NPROCESSORS_ONLN );
#endif
if (redis_num_threads < 1) {
redis_num_threads = REDIS_RESTORE_NUM_THREADS;
}
}
mc.redis_num_threads = redis_num_threads;
ct = NULL;
if (tcp_listen_ep.port) {
ct = control_tcp_new(ctx->p, &tcp_listen_ep, ctx->m);
if (!ct)
die("Failed to open TCP control connection port");
}
cu = NULL;
if (udp_listen_ep.port) {
interfaces_exclude_port(udp_listen_ep.port);
cu = control_udp_new(ctx->p, &udp_listen_ep, ctx->m);
if (!cu)
die("Failed to open UDP control connection port");
}
cn = NULL;
if (ng_listen_ep.port) {
interfaces_exclude_port(ng_listen_ep.port);
cn = control_ng_new(ctx->p, &ng_listen_ep, ctx->m);
if (!cn)
die("Failed to open UDP control connection port");
}
cl = NULL;
if (cli_listen_ep.port) {
interfaces_exclude_port(cli_listen_ep.port);
cl = cli_new(ctx->p, &cli_listen_ep, ctx->m);
if (!cl)
die("Failed to open UDP CLI connection port");
}
if (!is_addr_unspecified(&redis_write_ep.address)) {
mc.redis_write = redis_new(&redis_write_ep, redis_write_db, redis_write_auth, ANY_REDIS_ROLE, no_redis_required);
if (!mc.redis_write)
die("Cannot start up without running Redis %s write database! See also NO_REDIS_REQUIRED paramter.",
endpoint_print_buf(&redis_write_ep));
}
if (!is_addr_unspecified(&redis_ep.address)) {
mc.redis = redis_new(&redis_ep, redis_db, redis_auth, mc.redis_write ? ANY_REDIS_ROLE : MASTER_REDIS_ROLE, no_redis_required);
mc.redis_notify = redis_new(&redis_ep, redis_db, redis_auth, mc.redis_write ? ANY_REDIS_ROLE : MASTER_REDIS_ROLE, no_redis_required);
if (!mc.redis || !mc.redis_notify)
die("Cannot start up without running Redis %s database! See also NO_REDIS_REQUIRED paramter.",
endpoint_print_buf(&redis_ep));
if (!mc.redis_write)
mc.redis_write = mc.redis;
}
mc.redis_expires_secs = redis_expires;
ctx->m->conf = mc;
if (!foreground)
daemonize();
wpidfile();
ctx->m->homer = homer_sender_new(&homer_ep, homer_protocol, homer_id);
if (mc.redis) {
// start redis restore timer
gettimeofday(&redis_start, NULL);
// restore
if (redis_restore(ctx->m, mc.redis))
die("Refusing to continue without working Redis database");
// stop redis restore timer
gettimeofday(&redis_stop, NULL);
// print redis restore duration
redis_diff += timeval_diff(&redis_stop, &redis_start) / 1000.0;
ilog(LOG_INFO, "Redis restore time = %.0lf ms", redis_diff);
}
gettimeofday(&ctx->m->latest_graphite_interval_start, NULL);
timeval_from_us(&tmp_tv, graphite_interval*1000000);
set_graphite_interval_tv(&tmp_tv);
}