int
rtpp_proc_async_init(struct cfg *cf)
{
struct rtpp_proc_async_cf *proc_cf;
proc_cf = malloc(sizeof(*proc_cf));
if (proc_cf == NULL)
return (-1);
memset(proc_cf, '\0', sizeof(*proc_cf));
init_rstats(cf->stable->rtpp_stats, &proc_cf->rstats);
#if RTPP_DEBUG
recfilter_init(&proc_cf->sleep_time, 0.999, 0.0, 0);
recfilter_init(&proc_cf->poll_time, 0.999, 0.0, 0);
recfilter_init(&proc_cf->proc_time, 0.999, 0.0, 0);
#endif
proc_cf->time_q = rtpp_queue_init(1, "RTP_PROC(time)");
if (proc_cf->time_q == NULL) {
free(proc_cf);
return (-1);
}
proc_cf->op = rtpp_netio_async_init(cf, 10);
if (proc_cf->op == NULL) {
rtpp_queue_destroy(proc_cf->time_q);
free(proc_cf);
return (-1);
}
cf->stable->rtpp_proc_cf = proc_cf;
if (pthread_create(&proc_cf->thread_id, NULL, (void *(*)(void *))&rtpp_proc_async_run, cf) != 0) {
rtpp_queue_destroy(proc_cf->time_q);
rtpp_netio_async_destroy(proc_cf->op);
free(proc_cf);
cf->stable->rtpp_proc_cf = NULL;
return (-1);
}
return (0);
}
struct rtpp_notify *
rtpp_notify_ctor(struct rtpp_log *glog)
{
struct rtpp_notify_priv *pvt;
pvt = rtpp_zmalloc(sizeof(struct rtpp_notify_priv));
if (pvt == NULL) {
goto e0;
}
pvt->nqueue = rtpp_queue_init(1, "rtpp_notify");
if (pvt->nqueue == NULL) {
goto e1;
}
/* Pre-allocate sigterm, so that we don't have any malloc() in dtor() */
pvt->sigterm = rtpp_wi_malloc_sgnl(SIGTERM, NULL, 0);
if (pvt->sigterm == NULL) {
goto e2;
}
if (pthread_create(&pvt->thread_id, NULL, (void *(*)(void *))&rtpp_notify_queue_run, pvt) != 0) {
goto e3;
}
CALL_METHOD(glog->rcnt, incref);
pvt->glog = glog;
pvt->pub.schedule = &rtpp_notify_schedule;
pvt->pub.dtor = &rtpp_notify_dtor;
return (&pvt->pub);
e3:
rtpp_wi_free(pvt->sigterm);
e2:
rtpp_queue_destroy(pvt->nqueue);
e1:
free(pvt);
e0:
return (NULL);
}
struct rtpp_module_if *
rtpp_module_if_ctor(struct rtpp_cfg_stable *cfsp, struct rtpp_log *log,
const char *mpath)
{
struct rtpp_refcnt *rcnt;
struct rtpp_module_if_priv *pvt;
const char *derr;
pvt = rtpp_rzmalloc(sizeof(struct rtpp_module_if_priv), &rcnt);
if (pvt == NULL) {
goto e0;
}
pvt->pub.rcnt = rcnt;
pvt->dmp = dlopen(mpath, RTLD_NOW);
if (pvt->dmp == NULL) {
derr = dlerror();
if (strstr(derr, mpath) == NULL) {
RTPP_LOG(log, RTPP_LOG_ERR, "can't dlopen(%s): %s", mpath, derr);
} else {
RTPP_LOG(log, RTPP_LOG_ERR, "can't dlopen() module: %s", derr);
}
goto e1;
}
pvt->mip = dlsym(pvt->dmp, "rtpp_module");
if (pvt->mip == NULL) {
derr = dlerror();
if (strstr(derr, mpath) == NULL) {
RTPP_LOG(log, RTPP_LOG_ERR, "can't find 'rtpp_module' symbol in the %s"
": %s", mpath, derr);
} else {
RTPP_LOG(log, RTPP_LOG_ERR, "can't find 'rtpp_module' symbol: %s",
derr);
}
goto e2;
}
if (!MI_VER_CHCK(pvt->mip)) {
RTPP_LOG(log, RTPP_LOG_ERR, "incompatible API version in the %s, "
"consider recompiling the module", mpath);
goto e2;
}
#if RTPP_CHECK_LEAKS
pvt->mip->_malloc = &rtpp_memdeb_malloc;
pvt->mip->_zmalloc = &rtpp_zmalloc_memdeb;
pvt->mip->_free = &rtpp_memdeb_free;
pvt->mip->_realloc = &rtpp_memdeb_realloc;
pvt->mip->_strdup = &rtpp_memdeb_strdup;
pvt->mip->_asprintf = &rtpp_memdeb_asprintf;
pvt->mip->_vasprintf = &rtpp_memdeb_vasprintf;
pvt->memdeb_p = rtpp_memdeb_init();
rtpp_memdeb_setlog(pvt->memdeb_p, log);
#else
pvt->mip->_malloc = (rtpp_module_malloc_t)&malloc;
pvt->mip->_zmalloc = (rtpp_module_zmalloc_t)&rtpp_zmalloc;
pvt->mip->_free = (rtpp_module_free_t)&free;
pvt->mip->_realloc = (rtpp_module_realloc_t)&realloc;
pvt->mip->_strdup = (rtpp_module_strdup_t)&strdup;
pvt->mip->_asprintf = rtpp_module_asprintf;
pvt->mip->_vasprintf = rtpp_module_vasprintf;
#endif
if (pvt->memdeb_p == NULL) {
goto e2;
}
/* We make a copy, so that the module cannot screw us up */
pvt->mip->memdeb_p = pvt->memdeb_p;
pvt->sigterm = rtpp_wi_malloc_sgnl(SIGTERM, NULL, 0);
if (pvt->sigterm == NULL) {
goto e3;
}
pvt->req_q = rtpp_queue_init(1, "rtpp_module_if(%s)", pvt->mip->name);
if (pvt->req_q == NULL) {
goto e4;
}
if (pvt->mip->ctor != NULL) {
pvt->mpvt = pvt->mip->ctor(cfsp);
if (pvt->mpvt == NULL) {
RTPP_LOG(log, RTPP_LOG_ERR, "module '%s' failed to initialize",
pvt->mip->name);
goto e5;
}
}
if (pvt->mip->on_session_end.argsize != rtpp_acct_OSIZE()) {
RTPP_LOG(log, RTPP_LOG_ERR, "incompatible API version in the %s, "
"consider recompiling the module", mpath);
goto e6;
}
if (pthread_create(&pvt->thread_id, NULL,
(void *(*)(void *))&rtpp_mif_run, pvt) != 0) {
goto e6;
}
CALL_METHOD(log->rcnt, incref);
pvt->log = log;
pvt->pub.do_acct = &rtpp_mif_do_acct;
CALL_METHOD(pvt->pub.rcnt, attach, (rtpp_refcnt_dtor_t)&rtpp_mif_dtor,
pvt);
return ((&pvt->pub));
e6:
if (pvt->mip->dtor != NULL) {
pvt->mip->dtor(pvt->mpvt);
}
e5:
rtpp_queue_destroy(pvt->req_q);
#if RTPP_CHECK_LEAKS
if (rtpp_memdeb_dumpstats(pvt->memdeb_p, 1) != 0) {
RTPP_LOG(log, RTPP_LOG_ERR, "module '%s' leaked memory in the failed "
"constructor", pvt->mip->name);
}
#endif
e4:
rtpp_wi_free(pvt->sigterm);
e3:
#if RTPP_CHECK_LEAKS
rtpp_memdeb_dtor(pvt->memdeb_p);
#endif
e2:
dlclose(pvt->dmp);
e1:
CALL_METHOD(rcnt, decref);
free(pvt);
e0:
return (NULL);
}
struct rtpp_anetio_cf *
rtpp_netio_async_init(struct cfg *cf, int qlen)
{
struct rtpp_anetio_cf *netio_cf;
int i, ri;
netio_cf = rtpp_zmalloc(sizeof(*netio_cf));
if (netio_cf == NULL)
return (NULL);
for (i = 0; i < SEND_THREADS; i++) {
netio_cf->args[i].out_q = rtpp_queue_init(qlen, "RTPP->NET%.2d", i);
if (netio_cf->args[i].out_q == NULL) {
for (ri = i - 1; ri >= 0; ri--) {
rtpp_queue_destroy(netio_cf->args[ri].out_q);
}
goto e0;
}
netio_cf->args[i].glog = cf->stable->glog;
netio_cf->args[i].dmode = cf->stable->dmode;
#ifdef RTPP_DEBUG
recfilter_init(&netio_cf->args[i].average_load, 0.9, 0.0, 0);
#endif
}
for (i = 0; i < SEND_THREADS; i++) {
netio_cf->args[i].sigterm = rtpp_wi_malloc_sgnl(SIGTERM, NULL, 0);
if (netio_cf->args[i].sigterm == NULL) {
for (ri = i - 1; ri >= 0; ri--) {
rtpp_wi_free(netio_cf->args[ri].sigterm);
}
goto e1;
}
}
cf->stable->rtpp_netio_cf = netio_cf;
for (i = 0; i < SEND_THREADS; i++) {
if (pthread_create(&(netio_cf->thread_id[i]), NULL, (void *(*)(void *))&rtpp_anetio_sthread, &netio_cf->args[i]) != 0) {
for (ri = i - 1; ri >= 0; ri--) {
rtpp_queue_put_item(netio_cf->args[ri].sigterm, netio_cf->args[ri].out_q);
pthread_join(netio_cf->thread_id[ri], NULL);
}
for (ri = i; ri < SEND_THREADS; ri++) {
rtpp_wi_free(netio_cf->args[ri].sigterm);
}
goto e1;
}
}
return (netio_cf);
#if 0
e2:
for (i = 0; i < SEND_THREADS; i++) {
rtpp_wi_free(netio_cf->args[i].sigterm);
}
#endif
e1:
for (i = 0; i < SEND_THREADS; i++) {
rtpp_queue_destroy(netio_cf->args[i].out_q);
}
e0:
free(netio_cf);
return (NULL);
}
