void cw_slinfactory_init(struct cw_slinfactory *sf)
{
memset(sf, 0, sizeof(struct cw_slinfactory));
sf->offset = sf->hold;
sf->queue.head = sf->queue.tail = NULL;
cw_mutex_init(&(sf->lock));
}
static struct sched_context *context_create(void)
{
struct sched_context *tmp;
tmp = malloc(sizeof(struct sched_context));
if (tmp) {
memset(tmp, 0, sizeof(struct sched_context));
tmp->tid = CW_PTHREADT_NULL;
cw_mutex_init(&tmp->lock);
tmp->eventcnt = 1;
tmp->schedcnt = 0;
tmp->schedq = NULL;
#ifdef SCHED_MAX_CACHE
tmp->schedc = NULL;
tmp->schedccnt = 0;
#endif
}
return tmp;
}
/* Initializer for an already created member object. */
icd_status init_icd_member(icd_member * that, icd_queue * queue, icd_caller * caller, icd_config * data)
{
icd_status vetoed;
assert(that != NULL);
assert(queue != NULL);
assert(caller != NULL);
if (that->allocated != 1)
ICD_MEMSET_ZERO(that, sizeof(icd_member));
cw_mutex_init(&that->lock);
that->queue = queue;
that->caller = caller;
that->distributor = icd_queue__get_distributor(queue);
//if (icd_distributor__get_plugable_fn_ptr(that->distributor) !=NULL)
that->get_plugable_fn = icd_distributor__get_plugable_fn_ptr(that->distributor);
snprintf(that->name, sizeof(that->name), "Queue %s Member %s", icd_queue__get_name(that->queue),
icd_caller__get_name(that->caller));
that->entered_queue = (time_t) 0;
that->entered_distributor = (time_t) 0;
that->calls = 0;
that->answered_calls = 0;
that->listeners = create_icd_listeners();
that->allocated = 0;
that->params = NULL;
if (data != NULL) {
that->params = icd_config__get_any_value(data, "params", NULL);
}
vetoed = icd_event__generate(ICD_EVENT_INIT, NULL);
if (vetoed == ICD_EVETO) {
return ICD_EVETO;
}
that->state = ICD_MEMBER_STATE_INITIALIZED;
return ICD_SUCCESS;
}
static struct cw_conference* create_conf( char* name, struct cw_conf_member* member )
{
cw_log( CW_CONF_DEBUG, "entered create_conf, name => %s\n", name ) ;
// allocate memory for conference
struct cw_conference *conf = calloc(1, sizeof( struct cw_conference ) ) ;
if ( conf == NULL )
{
cw_log( LOG_ERROR, "unable to malloc cw_conference\n" ) ;
return NULL ;
}
//
// initialize conference
//
conf->next = NULL ;
conf->memberlist = NULL ;
conf->membercount = 0 ;
conf->conference_thread = CW_PTHREADT_NULL ;
conf->is_locked = 0;
conf->command_queue = NULL ;
// copy name to conference
strncpy( (char*)&(conf->name), name, sizeof(conf->name) - 1 ) ;
// initialize mutexes
cw_mutex_init( &conf->lock ) ;
// add the initial member
add_member( conf, member) ;
//
// prepend new conference to conflist
//
// acquire mutex
cw_mutex_lock( &conflist_lock ) ;
conf->next = conflist ;
conflist = conf ;
cw_log( CW_CONF_DEBUG, "added new conference to conflist, name => %s\n", name ) ;
//
// spawn thread for new conference, using conference_exec( conf )
//
// acquire conference mutexes
cw_mutex_lock( &conf->lock ) ;
if ( cw_pthread_create( &conf->conference_thread, NULL, (void*)conference_exec, conf ) == 0 )
{
// detach the thread so it doesn't leak
pthread_detach( conf->conference_thread ) ;
// release conference mutexes
cw_mutex_unlock( &conf->lock ) ;
cw_log( CW_CONF_DEBUG, "started conference thread for conference, name => %s\n", conf->name ) ;
manager_event(
EVENT_FLAG_CALL,
APP_CONFERENCE_MANID"ConfCreate",
"Channel: %s\r\n"
"ConfNo: %s\r\n",
member->channel_name,
name
) ;
}
else
{
cw_log( LOG_ERROR, "unable to start conference thread for conference %s\n", conf->name ) ;
conf->conference_thread = CW_PTHREADT_NULL ;
// release conference mutexes
cw_mutex_unlock( &conf->lock ) ;
// clean up conference
free( conf ) ;
conf = NULL ;
}
// count new conference
if ( conf != NULL )
++conference_count ;
conf->auto_destroy = 1;
// release mutex
cw_mutex_unlock( &conflist_lock ) ;
return conf ;
}
// called by app_conference.c:load_module()
void init_conference( void )
{
cw_mutex_init( &conflist_lock ) ;
cw_mutex_init( &start_stop_conf_lock ) ;
}
struct cw_conf_member *create_member( struct cw_channel *chan, int argc, char **argv ) {
if ( chan == NULL )
{
cw_log( LOG_ERROR, "unable to create member with null channel\n" ) ;
return NULL ;
}
if ( chan->name == NULL )
{
cw_log( LOG_ERROR, "unable to create member with null channel name\n" ) ;
return NULL ;
}
struct cw_conf_member *member = calloc( 1, sizeof( struct cw_conf_member ) ) ;
if ( member == NULL )
{
cw_log( LOG_ERROR, "unable to malloc cw_conf_member\n" ) ;
return NULL ;
}
//
// initialize member with passed data values
//
// initialize mutex
cw_mutex_init( &member->lock ) ;
char argstr[80];
char *stringp, *token ;
// copy the passed data
strncpy( argstr, argv[0], sizeof(argstr) - 1 ) ;
// point to the copied data
stringp = argstr ;
cw_log( CW_CONF_DEBUG, "attempting to parse passed params, stringp => %s\n", stringp ) ;
// parse the id
if ( ( token = strsep( &stringp, "/" ) ) != NULL )
{
member->id = malloc( strlen( token ) + 1 ) ;
strcpy( member->id, token ) ;
}
else
{
cw_log( LOG_ERROR, "unable to parse member id\n" ) ;
free( member ) ;
return NULL ;
}
// parse the flags
if ( ( token = strsep( &stringp, "/" ) ) != NULL )
{
member->flags = malloc( strlen( token ) + 1 ) ;
strcpy( member->flags, token ) ;
}
else
{
// make member->flags something
member->flags = malloc( sizeof( char ) ) ;
memset( member->flags, 0x0, sizeof( char ) ) ;
}
// parse the pin
if ( ( token = strsep( &stringp, "/" ) ) != NULL )
{
member->pin = malloc( strlen( token ) + 1 ) ;
strcpy( member->pin, token ) ;
}
else
{
// make member->pin something
member->pin = malloc( sizeof( char ) ) ;
memset( member->pin, 0x0, sizeof( char ) ) ;
}
// debugging
cw_log(
CW_CONF_DEBUG,
"parsed data params, id => %s, flags => %s, pin %s\n",
member->id, member->flags, member->pin
) ;
//
// initialize member with default values
//
// keep pointer to member's channel
member->chan = chan ;
member->auto_destroy = 1 ;
// copy the channel name
member->channel_name = strdup(chan->name);
// Copy the channel CallerID
if (chan->cid.cid_dnid)
member->cid.cid_dnid = strdup(chan->cid.cid_dnid);
else
member->cid.cid_dnid = NULL;
if (chan->cid.cid_num)
member->cid.cid_num = strdup(chan->cid.cid_num);
else
member->cid.cid_num = NULL;
if (chan->cid.cid_name)
member->cid.cid_name = strdup(chan->cid.cid_name);
else
member->cid.cid_name = NULL;
if (chan->cid.cid_ani)
member->cid.cid_ani = strdup(chan->cid.cid_ani);
else
member->cid.cid_ani = NULL;
if (chan->cid.cid_rdnis)
member->cid.cid_rdnis = strdup(chan->cid.cid_rdnis);
else
member->cid.cid_rdnis = NULL;
member->cid.cid_pres = chan->cid.cid_pres;
member->cid.cid_ani2 = chan->cid.cid_ani2;
member->cid.cid_ton = chan->cid.cid_ton;
member->cid.cid_tns = chan->cid.cid_tns;
// ( default can be overridden by passed flags )
member->type = MEMBERTYPE_LISTENER ;
// linked-list pointer
member->next = NULL ;
// flags
member->remove_flag = 0 ;
member->force_remove_flag = 0 ;
// record start time
gettimeofday( &member->time_entered, NULL ) ;
// Initialize member RTP data
member->framelen = 0; // frame length in milliseconds
member->samples = 0; // number of samples in framelen
member->samplefreq = 0; // calculated sample frequency
member->enable_vad = 0;
member->enable_vad_allowed = 0;
member->silence_nr = 1;
if (!strncmp(chan->name,"Local",sizeof("Local")) )
member->enable_vad_allowed = 0;
// smoother defaults.
member->smooth_size_in = -1;
member->smooth_size_out = -1;
member->inSmoother= NULL;
// Audio data
member->talk_volume = 0;
member->talk_volume_adjust = 0;
member->talk_mute = 0;
member->skip_voice_detection = 10;
member->quiet_mode = 0;
member->beep_only_mode = 0;
member->is_on_hold = 0;
member->skip_moh_when_alone = 0;
member->lostframecount = 0;
//DTMF Data
member->manage_dtmf = 1;
member->dtmf_admin_mode=0;
member->dtmf_long_insert=0;
//Play conference sounds by default
member->dont_play_any_sound=0;
// Zeroing output frame buffer
memset(member->framedata,0,sizeof(member->framedata));
//
// parse passed flags
//
// temp pointer to flags string
char* flags = member->flags ;
int i;
for ( i = 0 ; i < strlen( flags ) ; ++i )
{
// allowed flags are M, L, T, C, V, d
switch ( flags[i] )
{
// member types ( last flag wins )
case 'M':
member->type = MEMBERTYPE_MASTER ;
break ;
case 'S':
member->type = MEMBERTYPE_SPEAKER ;
break ;
case 'L':
member->type = MEMBERTYPE_LISTENER ;
break ;
case 'T':
member->type = MEMBERTYPE_TALKER ;
break ;
case 'C':
member->type = MEMBERTYPE_CONSULTANT ;
break ;
// speex preprocessing options
case 'V':
#if ENABLE_VAD
if ( strncmp(chan->name,"Local",sizeof("Local")-1) ) {
if (member->type != MEMBERTYPE_LISTENER) {
member->enable_vad_allowed = 1 ;
member->enable_vad = 1 ;
}
} else {
member->enable_vad_allowed = 0;
member->enable_vad = 0 ;
cw_log( LOG_WARNING, "VAD Not supported on outgoing channels.\n");
}
#else
cw_log( LOG_WARNING, "VAD Support is not compiled in. Disabling.\n");
#endif
break ;
// additional features
case 'd': // Send DTMF manager events..
member->manage_dtmf = 0;
break;
case 'm': // don't play MOH when alone
member->skip_moh_when_alone = 1;
break;
case 'x': // Don't destroy when empty
if ( member->type == MEMBERTYPE_MASTER )
member->auto_destroy = 0;
break;
case 'q': // Quiet mode
member->quiet_mode = 1;
break;
case 'b': // Only beep to announce if a member join/left
member->beep_only_mode = 1;
break;
default:
cw_log( LOG_WARNING, "received invalid flag, chan => %s, flag => %c\n",
chan->name, flags[i] ) ;
break ;
}
}
// Circular buffer
member->cbuf = calloc( 1, sizeof( struct member_cbuffer ) ) ;
if ( member->cbuf == NULL )
{
cw_log( LOG_ERROR, "unable to malloc member_cbuffer\n" ) ;
return NULL ;
} else {
// initialize it
memset(member->cbuf, 0, sizeof(struct member_cbuffer) );
}
//
// read, write, and translation options
//
cw_log( CW_CONF_DEBUG, "created member on channel %s, type => %d, readformat => %d, writeformat => %d\n",
member->chan->name, member->type, chan->readformat, chan->writeformat ) ;
// set member's audio formats, taking dsp preprocessing into account
// ( chan->nativeformats, CW_FORMAT_SLINEAR, CW_FORMAT_ULAW, CW_FORMAT_GSM )
member->read_format = CW_FORMAT_SLINEAR ;
member->write_format = CW_FORMAT_SLINEAR ;
//
// finish up
//
cw_log( CW_CONF_DEBUG, "created member on channel %s, type => %d, readformat => %d, writeformat => %d\n",
member->chan->name, member->type, chan->readformat, chan->writeformat ) ;
if ( !cw_generator_is_active(chan) )
cw_generator_activate(chan,&membergen,member);
return member ;
}
int misdn_cfg_init (int this_max_ports)
{
char config[] = "misdn.conf";
char *cat, *p;
int i;
struct cw_config *cfg;
struct cw_variable *v;
if (!(cfg = CW_LOAD_CFG(config))) {
cw_log(LOG_WARNING, "missing file: misdn.conf\n");
return -1;
}
cw_mutex_init(&config_mutex);
misdn_cfg_lock();
if (this_max_ports) {
/* this is the first run */
max_ports = this_max_ports;
map = (int *)calloc(MISDN_GEN_LAST + 1, sizeof(int));
if (_enum_array_map())
return -1;
p = (char *)calloc(1, (max_ports + 1) * sizeof(union misdn_cfg_pt *)
+ (max_ports + 1) * NUM_PORT_ELEMENTS * sizeof(union misdn_cfg_pt));
port_cfg = (union misdn_cfg_pt **)p;
p += (max_ports + 1) * sizeof(union misdn_cfg_pt *);
for (i = 0; i <= max_ports; ++i) {
port_cfg[i] = (union misdn_cfg_pt *)p;
p += NUM_PORT_ELEMENTS * sizeof(union misdn_cfg_pt);
}
general_cfg = (union misdn_cfg_pt *)calloc(1, sizeof(union misdn_cfg_pt *) * NUM_GEN_ELEMENTS);
ptp = (int *)calloc(max_ports + 1, sizeof(int));
}
else {
/* misdn reload */
_free_port_cfg();
_free_general_cfg();
memset(port_cfg[0], 0, NUM_PORT_ELEMENTS * sizeof(union misdn_cfg_pt) * (max_ports + 1));
memset(general_cfg, 0, sizeof(union misdn_cfg_pt *) * NUM_GEN_ELEMENTS);
memset(ptp, 0, sizeof(int) * (max_ports + 1));
}
cat = cw_category_browse(cfg, NULL);
while(cat) {
v = cw_variable_browse(cfg, cat);
if (!strcasecmp(cat, "general")) {
_build_general_config(v);
} else {
_build_port_config(v, cat);
}
cat = cw_category_browse(cfg, cat);
}
_fill_defaults();
misdn_cfg_unlock();
CW_DESTROY_CFG(cfg);
return 0;
}
