void custom_reader() {
struct poller *p = poller_new(1000);
int counter = 13;
char buf[1000];
struct buf b = buf_wrap((void *)buf, 1000);
int pipefds[2];
if (pipe(pipefds) != 0) perrpanic("pipe");
if (fcntl(pipefds[0], F_SETFL, O_NONBLOCK) == -1) perrpanic("fcntl");
if (fcntl(pipefds[1], F_SETFL, O_NONBLOCK) == -1) perrpanic("fcntl");
if (write(pipefds[1], "z", 1) != 1) perrpanic("write asyn pipe"); /* make sure pipe never blocks */
copier_add(p, a_reader_make(&counter, pipefds[0]), buf_writer_make(&b, pipefds[1]), 1000);
while (poller_poll(p, -1));
ok(strcmp(buf, "aaaaaaaaaaaaa") == 0, "a_writer produced %s", buf);
poller_delete(p);
}
static void simple_copier_test() {
int src;
int sink;
struct poller *p = poller_new(1000);
system("echo bobo >/tmp/test_copier");
src = open("/tmp/test_copier", O_RDONLY);
if (src < 0) {
perrpanic("open src");
}
sink = open("/tmp/test_copier_out", O_CREAT|O_TRUNC|O_WRONLY, 0777);
if (sink < 0) {
perrpanic("open dst");
}
copier_add(p, reader_wrap(src), writer_wrap(sink), 1000);
while (poller_poll(p, -1));
ok1(system("[ \"`cat /tmp/test_copier_out`\" = 'bobo' ]") == 0);
system("rm /tmp/test_copier /tmp/test_copier_out");
close(src);
close(sink);
poller_delete(p);
}
static void emulate_full_buf() {
int src;
int sink;
struct poller *p = poller_new(1000);
system("echo 1234567890abcdefghijklmnopqrstuvwxyz >/tmp/test_copier_full_buf");
src = open("/tmp/test_copier_full_buf", O_RDONLY);
if (src < 0) {
perrpanic("open src");
}
sink = open("/tmp/test_copier_full_buf_out", O_CREAT|O_TRUNC|O_WRONLY, 0777);
if (sink < 0) {
perrpanic("open dst");
}
copier_add(p, reader_wrap(src), writer_wrap(sink), 1000);
while (poller_poll(p, -1));
ok1(system("A=\"`cat /tmp/test_copier_full_buf_out`\";"
" [ \"$A\" = '1234567890abcdefghijklmnopqrstuvwxyz' ] || (echo $A;false)") == 0);
system("rm /tmp/test_copier_full_buf /tmp/test_copier_full_buf_out");
close(src);
close(sink);
poller_delete(p);
}
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(void) {
struct control_tcp *ct;
struct control_udp *cu;
struct cli *cl;
struct timeval tmp_tv;
struct timeval redis_start, redis_stop;
double redis_diff = 0;
if (rtpe_config.kernel_table < 0)
goto no_kernel;
if (kernel_setup_table(rtpe_config.kernel_table)) {
if (rtpe_config.no_fallback) {
ilog(LOG_CRIT, "Userspace fallback disallowed - exiting");
exit(-1);
}
goto no_kernel;
}
no_kernel:
rtpe_poller = poller_new();
if (!rtpe_poller)
die("poller creation failed");
dtls_timer(rtpe_poller);
if (call_init())
abort();
rwlock_init(&rtpe_config.config_lock);
if (rtpe_config.max_sessions < -1) {
rtpe_config.max_sessions = -1;
}
if (rtpe_config.redis_num_threads < 1) {
#ifdef _SC_NPROCESSORS_ONLN
rtpe_config.redis_num_threads = sysconf( _SC_NPROCESSORS_ONLN );
#endif
if (rtpe_config.redis_num_threads < 1) {
rtpe_config.redis_num_threads = REDIS_RESTORE_NUM_THREADS;
}
}
ct = NULL;
if (rtpe_config.tcp_listen_ep.port) {
ct = control_tcp_new(rtpe_poller, &rtpe_config.tcp_listen_ep);
if (!ct)
die("Failed to open TCP control connection port");
}
cu = NULL;
if (rtpe_config.udp_listen_ep.port) {
interfaces_exclude_port(rtpe_config.udp_listen_ep.port);
cu = control_udp_new(rtpe_poller, &rtpe_config.udp_listen_ep);
if (!cu)
die("Failed to open UDP control connection port");
}
rtpe_control_ng = NULL;
if (rtpe_config.ng_listen_ep.port) {
interfaces_exclude_port(rtpe_config.ng_listen_ep.port);
rtpe_control_ng = control_ng_new(rtpe_poller, &rtpe_config.ng_listen_ep, rtpe_config.control_tos);
if (!rtpe_control_ng)
die("Failed to open UDP control connection port");
}
cl = NULL;
if (rtpe_config.cli_listen_ep.port) {
interfaces_exclude_port(rtpe_config.cli_listen_ep.port);
cl = cli_new(rtpe_poller, &rtpe_config.cli_listen_ep);
if (!cl)
die("Failed to open UDP CLI connection port");
}
if (!is_addr_unspecified(&rtpe_config.redis_write_ep.address)) {
rtpe_redis_write = redis_new(&rtpe_config.redis_write_ep,
rtpe_config.redis_write_db, rtpe_config.redis_write_auth,
ANY_REDIS_ROLE, rtpe_config.no_redis_required);
if (!rtpe_redis_write)
die("Cannot start up without running Redis %s write database! See also NO_REDIS_REQUIRED parameter.",
endpoint_print_buf(&rtpe_config.redis_write_ep));
}
if (!is_addr_unspecified(&rtpe_config.redis_ep.address)) {
rtpe_redis = redis_new(&rtpe_config.redis_ep, rtpe_config.redis_db, rtpe_config.redis_auth, rtpe_redis_write ? ANY_REDIS_ROLE : MASTER_REDIS_ROLE, rtpe_config.no_redis_required);
rtpe_redis_notify = redis_new(&rtpe_config.redis_ep, rtpe_config.redis_db, rtpe_config.redis_auth, rtpe_redis_write ? ANY_REDIS_ROLE : MASTER_REDIS_ROLE, rtpe_config.no_redis_required);
if (!rtpe_redis || !rtpe_redis_notify)
die("Cannot start up without running Redis %s database! See also NO_REDIS_REQUIRED parameter.",
endpoint_print_buf(&rtpe_config.redis_ep));
if (!rtpe_redis_write)
rtpe_redis_write = rtpe_redis;
}
daemonize();
wpidfile();
homer_sender_init(&rtpe_config.homer_ep, rtpe_config.homer_protocol, rtpe_config.homer_id);
rtcp_init(); // must come after Homer init
if (rtpe_redis) {
// start redis restore timer
gettimeofday(&redis_start, NULL);
// restore
if (redis_restore(rtpe_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(&rtpe_latest_graphite_interval_start, NULL);
timeval_from_us(&tmp_tv, (long long) rtpe_config.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);
}