Code cleanup..
modified: README
modified: apppbx.cpp
modified: default/interface.conf
modified: default/options.conf
modified: dss1.cpp
modified: extension.c
modified: gsm.cpp
modified: interface.c
modified: interface.h
modified: mISDN.cpp
modified: options.c
modified: options.h
modified: port.cpp
-> Requires OpenBSC, GSM codec, and a BS11 base station.
-> For more refer to www.linux-call-router.de.
+Changes after Version 1.5
+- Tones are restructured:
+ -> mISDN_dsp.ko tones must now be specified via 'tones_dir' parameter.
+ -> interface.conf has a tones_dir options for individual interfaces.
+ -> interface.conf has priority over tones_dir in options.conf.
+ -> exnsion's settings has pritority over other tones_dir setting.
+
/* detach */
temp =apppbx_first;
tempp = &apppbx_first;
- while(temp)
- {
+ while(temp) {
if (temp == this)
break;
void EndpointAppPBX::new_state(int state)
{
#if 0
- if (e_state != state)
- {
+ if (e_state != state) {
trace_header("NEW STATE", DIRECTION_NONE);
add_trace("state", "old", "%s", state_name[e_state]);
add_trace("state", "new", "%s", state_name[state]);
admin_call_response(e_adminid, ADMIN_CALL_RELEASE, "", joincause, joinlocation, 0);
/* if a release is pending */
- if (release==RELEASE_JOIN || release==RELEASE_ALL || release==RELEASE_PORT_JOINONLY)
- {
+ if (release==RELEASE_JOIN || release==RELEASE_ALL || release==RELEASE_PORT_JOINONLY) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d): do pending release (joincause %d location %d)\n", ea_endpoint->ep_serial, joincause, joinlocation);
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_RELEASE);
message->param.disconnectinfo.cause = joincause;
message->param.disconnectinfo.location = joinlocation;
}
e_join_pattern = 0;
#if 0
- if (release != RELEASE_PORT_JOINONLY)
- {
+ if (release != RELEASE_PORT_JOINONLY) {
if (e_hold_id)
join_release(e_hold_id, ea_endpoint->ep_serial, 1, joinlocation, joincause);
e_hold_id = 0;
}
#endif
}
- if (release==RELEASE_ALL || release==RELEASE_PORT_JOINONLY)
- {
+ if (release==RELEASE_ALL || release==RELEASE_PORT_JOINONLY) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) do pending release (portcause %d portlocation)\n", ea_endpoint->ep_serial, portcause, portlocation);
- while((portlist = ea_endpoint->ep_portlist))
- {
- if (portlist->port_id)
- {
+ while((portlist = ea_endpoint->ep_portlist)) {
+ if (portlist->port_id) {
SPRINT(cause, "cause_%02x", portcause);
set_tone(portlist, cause);
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
}
/* if callback is enabled, call back with the given caller id */
- if (e_callback)
- {
+ if (e_callback) {
/* reset some stuff */
new_state(EPOINT_STATE_IDLE);
memset(&e_connectinfo, 0, sizeof(struct connect_info));
memcpy(&e_callbackinfo, &e_callerinfo, sizeof(e_callbackinfo));
memset(&e_dialinginfo, 0, sizeof(e_dialinginfo));
/* create dialing by callerinfo */
- if (e_ext.number[0] && e_extension_interface[0])
- {
+ if (e_ext.number[0] && e_extension_interface[0]) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) preparing callback to internal: %s interface %s\n", ea_endpoint->ep_serial, e_ext.number, e_extension_interface);
/* create callback to the current terminal */
SCPY(e_dialinginfo.id, e_ext.number);
SCPY(e_dialinginfo.interfaces, e_extension_interface);
e_dialinginfo.itype = INFO_ITYPE_ISDN_EXTENSION;
e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
- } else
- {
- if (e_cbto[0])
- {
+ } else {
+ if (e_cbto[0]) {
SCPY(e_dialinginfo.id, e_cbto);
- } else
- {
+ } else {
/* numberrize caller id and use it to dial to the callback */
SCPY(e_dialinginfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype, options.national, options.international));
}
/* NOTE: is caller is is not available for this extesion, it has been removed by apply_callerid_restriction already */
/* internal extension's caller id */
- if (extension[0] && e_ext.display_int)
- {
+ if (extension[0] && e_ext.display_int) {
if (!display[0])
SCAT(display, extension);
if (display[0])
}
/* external caller id */
- if (!extension[0] && e_ext.display_ext)
- {
- if (!display[0])
- {
- if (!cid[0])
- {
+ if (!extension[0] && e_ext.display_ext) {
+ if (!display[0]) {
+ if (!cid[0]) {
if (present == INFO_PRESENT_RESTRICTED)
SCAT(display, "anonymous");
else
}
/* display if callerid is anonymouse but available due anon-ignore */
- if (e_ext.display_anon && present==INFO_PRESENT_RESTRICTED)
- {
+ if (e_ext.display_anon && present==INFO_PRESENT_RESTRICTED) {
if (!cid[0])
SCAT(display, "unknown");
else
}
/* display if callerid is anonymouse but available due anon-ignore */
- if (e_ext.display_fake && screen==INFO_SCREEN_USER && ntype!=INFO_NTYPE_NOTPRESENT)
- {
- if (!display[0])
- {
- if (!id[0])
- {
+ if (e_ext.display_fake && screen==INFO_SCREEN_USER && ntype!=INFO_NTYPE_NOTPRESENT) {
+ if (!display[0]) {
+ if (!id[0]) {
if (present == INFO_PRESENT_RESTRICTED)
SCAT(display, "anonymous");
else
}
/* caller name */
- if (name[0] && e_ext.display_name)
- {
+ if (name[0] && e_ext.display_name) {
if (!display[0] && cid[0])
SCAT(display, cid);
if (display[0])
struct lcr_msg *message;
int notify = 0;
- switch(e_tx_state)
- {
+ switch(e_tx_state) {
case NOTIFY_STATE_ACTIVE:
/* we are already active, so we don't do anything */
break;
case NOTIFY_STATE_SUSPEND:
notify = INFO_NOTIFY_USER_RESUMED;
- while(portlist)
- {
+ while(portlist) {
set_tone(portlist, NULL);
portlist = portlist->next;
}
case NOTIFY_STATE_HOLD:
notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
- while(portlist)
- {
+ while(portlist) {
set_tone(portlist, NULL);
portlist = portlist->next;
}
case NOTIFY_STATE_CONFERENCE:
notify = INFO_NOTIFY_CONFERENCE_DISCONNECTED;
- while(portlist)
- {
+ while(portlist) {
set_tone(portlist, NULL);
portlist = portlist->next;
}
}
if (notify)
- while(portlist)
- {
+ while(portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
message->param.notifyinfo.notify = notify;
message_put(message);
{
/* we must be in a call, in order to send messages to the call */
- if (e_ext.number[0] == '\0')
- {
+ if (e_ext.number[0] == '\0') {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) IGNORING keypad received not from extension.\n", ea_endpoint->ep_serial);
return;
}
- switch(digit)
- {
+ switch(digit) {
/* join conference */
case '3':
- if (ea_endpoint->ep_join_id == 0)
- {
+ if (ea_endpoint->ep_join_id == 0) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad received during connect but not during a call.\n", ea_endpoint->ep_serial);
break;
}
&& !(e_ext.own_proceeding && e_state == EPOINT_STATE_OUT_PROCEEDING)
&& !(e_ext.own_alerting && e_state == EPOINT_STATE_OUT_ALERTING)
&& !(e_ext.own_cause && e_state == EPOINT_STATE_OUT_DISCONNECT)
- && tone[0] && !!strncmp(tone,"crypt_*",6))
- {
+ && tone[0] && !!strncmp(tone,"crypt_*",6)) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) tone not provided since patterns are available\n", ea_endpoint->ep_serial);
tone = "";
}
- if (portlist)
- {
+ if (portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_TONE);
- SCPY(message->param.tone.dir, e_ext.tones_dir[0]?e_ext.tones_dir:options.tones_dir);
+ SCPY(message->param.tone.dir, e_ext.tones_dir);
SCPY(message->param.tone.name, tone);
message_put(message);
logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
- } else
- {
+ } else {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no port to notify tone.\n", ea_endpoint->ep_serial);
return;
}
return(NULL);
/* check for given interface */
- if (ifname)
- {
- if (!strcasecmp(interface->name, ifname))
- {
+ if (ifname) {
+ if (!strcasecmp(interface->name, ifname)) {
/* found explicit interface */
trace_header("CHANNEL SELECTION (found interface)", DIRECTION_NONE);
add_trace("interface", NULL, "%s", ifname);
goto foundif;
}
- } else
- {
- if (!interface->extension)
- {
+ } else {
+ if (!interface->extension) {
/* found non extension */
trace_header("CHANNEL SELECTION (found non extension interface)", DIRECTION_NONE);
add_trace("interface", NULL, "%s", interface->name);
foundif:
/* see if interface has ports */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
/* no ports */
trace_header("CHANNEL SELECTION (active ports, skipping)", DIRECTION_NONE);
add_trace("interface", NULL, "%s", interface->name);
/* select port by algorithm */
ifport_start = interface->ifport;
index = 0;
- if (interface->hunt == HUNT_ROUNDROBIN)
- {
- while(ifport_start->next && index<interface->hunt_next)
- {
+ if (interface->hunt == HUNT_ROUNDROBIN) {
+ while(ifport_start->next && index<interface->hunt_next) {
ifport_start = ifport_start->next;
index++;
}
nextport:
/* see if port is available */
- if (!ifport->mISDNport)
- {
+ if (!ifport->mISDNport) {
trace_header("CHANNEL SELECTION (port not available, skipping)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
mISDNport = ifport->mISDNport;
/* see if port is administratively blocked */
- if (ifport->block)
- {
+ if (ifport->block) {
trace_header("CHANNEL SELECTION (port blocked by admin, skipping)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
}
/* see if link is up on PTP*/
- if (mISDNport->l2hold && mISDNport->l2link<1)
- {
+ if (mISDNport->l2hold && mISDNport->l2link<1) {
trace_header("CHANNEL SELECTION (port's layer 2 is down, skipping)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
/* check for channel form selection list */
*channel = 0;
selchannel = ifport->out_channel;
- while(selchannel)
- {
- switch(selchannel->channel)
- {
+ while(selchannel) {
+ switch(selchannel->channel) {
case CHANNEL_FREE: /* free channel */
if (mISDNport->b_reserved >= mISDNport->b_num)
break; /* all channel in use or reserverd */
/* find channel */
i = 0;
- while(i < mISDNport->b_num)
- {
- if (mISDNport->b_port[i] == NULL)
- {
+ while(i < mISDNport->b_num) {
+ if (mISDNport->b_port[i] == NULL) {
*channel = i+1+(i>=15);
trace_header("CHANNEL SELECTION (selecting free channel)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
break;
case CHANNEL_ANY: /* don't ask for channel */
- if (mISDNport->b_reserved >= mISDNport->b_num)
- {
+ if (mISDNport->b_reserved >= mISDNport->b_num) {
trace_header("CHANNEL SELECTION (cannot ask for 'any' channel, all reserved)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
break;
default:
- if (selchannel->channel<1 || selchannel->channel==16)
- {
+ if (selchannel->channel<1 || selchannel->channel==16) {
trace_header("CHANNEL SELECTION (channel out of range)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
break; /* invalid channels */
}
i = selchannel->channel-1-(selchannel->channel>=17);
- if (i >= mISDNport->b_num)
- {
+ if (i >= mISDNport->b_num) {
trace_header("CHANNEL SELECTION (channel out of range)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
end_trace();
break; /* channel not in port */
}
- if (mISDNport->b_port[i] == NULL)
- {
+ if (mISDNport->b_port[i] == NULL) {
*channel = selchannel->channel;
trace_header("CHANNEL SELECTION (selecting given channel)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
}
/* if channel was found, return mISDNport and channel */
- if (*channel)
- {
+ if (*channel) {
/* setting next port to start next time */
- if (interface->hunt == HUNT_ROUNDROBIN)
- {
+ if (interface->hunt == HUNT_ROUNDROBIN) {
index++;
if (!ifport->next)
index = 0;
/* go next port, until all ports are checked */
index++;
ifport = ifport->next;
- if (!ifport)
- {
+ if (!ifport) {
index = 0;
ifport = interface->ifport;
}
/* NOTE: currently the try_card feature is not supported. it should be used later to try another card, if the outgoing call fails on one port */
/* check what dialinginfo.itype we got */
- switch(e_dialinginfo.itype)
- {
+ switch(e_dialinginfo.itype) {
/* *********************** call to extension or vbox */
case INFO_ITYPE_ISDN_EXTENSION:
/* check if we deny incoming calls when we use an extension */
- if (e_ext.noknocking)
- {
+ if (e_ext.noknocking) {
atemp = apppbx_first;
- while(atemp)
- {
+ while(atemp) {
if (atemp != this)
if (!strcmp(atemp->e_ext.number, e_ext.number))
break;
atemp = atemp->next;
}
- if (atemp)
- {
+ if (atemp) {
PERROR("EPOINT(%d) noknocking and currently a call\n", ea_endpoint->ep_serial);
release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_BUSY, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYSPE_ join, port */
return; /* must exit here */
// if (strchr(exten, ','))
// *strchr(exten, ',') = '\0';
// if (!read_extension(&e_ext, exten))
- if (!read_extension(&e_ext, e_dialinginfo.id))
- {
+ if (!read_extension(&e_ext, e_dialinginfo.id)) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) extension %s not configured\n", ea_endpoint->ep_serial, e_dialinginfo.id);
release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_OUTOFORDER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
return; /* must exit here */
}
- if (e_dialinginfo.itype == INFO_ITYPE_VBOX)
- {
+ if (e_dialinginfo.itype == INFO_ITYPE_VBOX) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing directly to VBOX\n", ea_endpoint->ep_serial);
p = "vbox";
goto vbox_only;
/* string from unconditional call forward (cfu) */
p = e_ext.cfu;
- if (*p)
- {
+ if (*p) {
/* present to forwarded party */
- if (e_ext.anon_ignore && e_callerinfo.id[0])
- {
+ if (e_ext.anon_ignore && e_callerinfo.id[0]) {
e_callerinfo.present = INFO_PRESENT_ALLOWED;
}
if (!!strcmp(p, "vbox") || (e_capainfo.bearer_capa==INFO_BC_AUDIO) || (e_capainfo.bearer_capa==INFO_BC_SPEECH))
/* string from busy call forward (cfb) */
p = e_ext.cfb;
- if (*p)
- {
+ if (*p) {
class EndpointAppPBX *checkapp = apppbx_first;
- while(checkapp)
- {
- if (checkapp != this) /* any other endpoint except our own */
- {
- if (!strcmp(checkapp->e_ext.number, e_ext.number))
- {
+ while(checkapp) {
+ if (checkapp != this) { /* any other endpoint except our own */
+ if (!strcmp(checkapp->e_ext.number, e_ext.number)) {
/* present to forwarded party */
- if (e_ext.anon_ignore && e_callerinfo.id[0])
- {
+ if (e_ext.anon_ignore && e_callerinfo.id[0]) {
e_callerinfo.present = INFO_PRESENT_ALLOWED;
}
if (!!strcmp(p, "vbox") || (e_capainfo.bearer_capa==INFO_BC_AUDIO) || (e_capainfo.bearer_capa==INFO_BC_SPEECH))
/* string from no-response call forward (cfnr) */
p = e_ext.cfnr;
- if (*p)
- {
+ if (*p) {
/* when cfnr is done, out_setup() will setup the call */
- if (e_cfnr_call)
- {
+ if (e_cfnr_call) {
/* present to forwarded party */
- if (e_ext.anon_ignore && e_callerinfo.id[0])
- {
+ if (e_ext.anon_ignore && e_callerinfo.id[0]) {
e_callerinfo.present = INFO_PRESENT_ALLOWED;
}
goto cfnr_only;
}
- if (!!strcmp(p, "vbox") || (e_capainfo.bearer_capa==INFO_BC_AUDIO) || (e_capainfo.bearer_capa==INFO_BC_SPEECH))
- {
+ if (!!strcmp(p, "vbox") || (e_capainfo.bearer_capa==INFO_BC_AUDIO) || (e_capainfo.bearer_capa==INFO_BC_SPEECH)) {
e_cfnr_release = now + e_ext.cfnr_delay;
e_cfnr_call = now + e_ext.cfnr_delay + 1; /* call one second after release */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) setting time for call-forward-busy to %s with delay %ld.\n", ea_endpoint->ep_serial, e_ext.cfnr, e_ext.cfnr_delay);
/* call to all internal interfaces */
p = e_ext.interfaces;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) generating multiple joins for extension %s to interfaces %s\n", ea_endpoint->ep_serial, e_dialinginfo.id, p);
- while(*p)
- {
+ while(*p) {
ifname[0] = '\0';
while(*p!=',' && *p!='\0')
if (*p > ' ')
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) calling to interface %s\n", ea_endpoint->ep_serial, ifname);
/* hunt for mISDNport and create Port */
mISDNport = hunt_port(ifname, &channel);
- if (!mISDNport)
- {
+ if (!mISDNport) {
trace_header("INTERFACE (not found or busy)", DIRECTION_NONE);
add_trace("interface", NULL, "%s", ifname);
end_trace();
dialinginfo.ntype = e_dialinginfo.ntype;
/* create port_list relation */
portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->earlyb);
- if (!portlist)
- {
+ if (!portlist) {
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
delete port;
goto check_anycall_intern;
}
/* directory.list */
- if (e_callerinfo.id[0] && e_ext.display_name)
- {
+ if (e_callerinfo.id[0] && e_ext.display_name) {
dirname = parse_directory(e_callerinfo.id, e_callerinfo.ntype);
if (dirname)
SCPY(e_callerinfo.name, dirname);
// if (!e_ext.centrex)
// message->param.setup.callerinfo.name[0] = '\0';
/* screen clip if prefix is required */
- if (message->param.setup.callerinfo.id[0] && e_ext.clip_prefix[0])
- {
+ if (message->param.setup.callerinfo.id[0] && e_ext.clip_prefix[0]) {
SCPY(message->param.setup.callerinfo.id, e_ext.clip_prefix);
SCAT(message->param.setup.callerinfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype, options.national, options.international));
message->param.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
}
- if (message->param.setup.callerinfo.id2[0] && e_ext.clip_prefix[0])
- {
+ if (message->param.setup.callerinfo.id2[0] && e_ext.clip_prefix[0]) {
SCPY(message->param.setup.callerinfo.id2, e_ext.clip_prefix);
SCAT(message->param.setup.callerinfo.id2, numberrize_callerinfo(e_callerinfo.id2,e_callerinfo.ntype2, options.national, options.international));
message->param.setup.callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
}
/* use internal caller id */
- if (e_callerinfo.extension[0] && (message->param.setup.callerinfo.present!=INFO_PRESENT_RESTRICTED || e_ext.anon_ignore))
- {
+ if (e_callerinfo.extension[0] && (message->param.setup.callerinfo.present!=INFO_PRESENT_RESTRICTED || e_ext.anon_ignore)) {
SCPY(message->param.setup.callerinfo.id, e_callerinfo.extension);
message->param.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
message->param.setup.callerinfo.ntype2 = INFO_NTYPE_NOTPRESENT;
/* string from parallel call forward (cfp) */
p = e_ext.cfp;
- if (*p)
- {
- if (e_ext.anon_ignore && e_callerinfo.id[0])
- {
+ if (*p) {
+ if (e_ext.anon_ignore && e_callerinfo.id[0]) {
e_callerinfo.present = INFO_PRESENT_ALLOWED;
e_callerinfo.present2 = INFO_PRESENT_ALLOWED;
}
cfnr_only: /* entry point for cfnr */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call extension %s for external destiantion(s) '%s'\n", ea_endpoint->ep_serial, e_dialinginfo.id, p);
// i=0;
- while(*p)
- {
+ while(*p) {
earlyb = 0;
/* only if vbox should be dialed, and terminal is given */
- if (!strcmp(p, "vbox") && e_ext.number[0])
- {
+ if (!strcmp(p, "vbox") && e_ext.number[0]) {
/* go to the end of p */
p += strlen(p);
FATAL("No memory for VBOX Port instance\n");
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) allocated port %s\n", ea_endpoint->ep_serial, port->p_name);
UCPY(cfp, e_ext.number); /* cfp or any other direct forward/vbox */
- } else
- {
+ } else {
cfp[0] = '\0';
while(*p!=',' && *p!='\0')
SCCAT(cfp, *p++);
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cfp external %s\n", ea_endpoint->ep_serial, cfp);
/* hunt for mISDNport and create Port */
mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
- if (mISDNport)
- {
+ if (mISDNport) {
/* creating EXTERNAL port*/
SPRINT(portname, "%s-%d-out", mISDNport->ifport->interface->name, mISDNport->portnum);
port = new Pdss1((mISDNport->ntmode)?PORT_TYPE_DSS1_NT_OUT:PORT_TYPE_DSS1_TE_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force, mode);
if (!port)
FATAL("No memory for Port instance\n");
earlyb = mISDNport->earlyb;
- } else
- {
+ } else {
port = NULL;
trace_header("INTERFACE (too busy)", DIRECTION_NONE);
add_trace("interface", NULL, "%s", e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
end_trace();
}
}
- if (!port)
- {
+ if (!port) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no port found or created, which is idle.\n", ea_endpoint->ep_serial);
goto check_anycall_intern;
}
dialinginfo.itype = INFO_ITYPE_ISDN;
dialinginfo.ntype = e_dialinginfo.ntype;
portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, earlyb);
- if (!portlist)
- {
+ if (!portlist) {
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
delete port;
goto check_anycall_intern;
memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
/* if clip is hidden */
- if (e_ext.clip==CLIP_HIDE && port->p_type!=PORT_TYPE_VBOX_OUT)
- {
+ if (e_ext.clip==CLIP_HIDE && port->p_type!=PORT_TYPE_VBOX_OUT) {
SCPY(message->param.setup.callerinfo.id, e_ext.callerid);
SCPY(message->param.setup.callerinfo.extension, e_ext.number);
message->param.setup.callerinfo.ntype = e_ext.callerid_type;
check_anycall_intern:
/* now we have all ports created */
- if (!anycall)
- {
+ if (!anycall) {
trace_header("INTERFACE (no extension's interface)", DIRECTION_NONE);
end_trace();
if (!ea_endpoint->ep_join_id)
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing external: '%s'\n", ea_endpoint->ep_serial, e_dialinginfo.id);
/* call to extenal interfaces */
p = e_dialinginfo.id;
- do
- {
+ do {
number[0] = '\0';
while(*p!=',' && *p!='\0')
SCCAT(number, *p++);
/* hunt for mISDNport and create Port */
/* hunt for mISDNport and create Port */
mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
- if (!mISDNport)
- {
+ if (!mISDNport) {
trace_header("INTERFACE (too busy)", DIRECTION_NONE);
add_trace("interface", NULL, "%s", e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
end_trace();
dialinginfo.itype = INFO_ITYPE_ISDN;
dialinginfo.ntype = e_dialinginfo.ntype;
portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->earlyb);
- if (!portlist)
- {
+ if (!portlist) {
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
delete port;
goto check_anycall_extern;
check_anycall_extern:
/* now we have all ports created */
- if (!anycall)
- {
+ if (!anycall) {
trace_header("INTERFACE (no free ports found)", DIRECTION_NONE);
end_trace();
if (!ea_endpoint->ep_join_id)
extern int quit;
int EndpointAppPBX::handler(void)
{
- if (e_crypt_state!=CM_ST_NULL)
- {
+ if (e_crypt_state!=CM_ST_NULL) {
cryptman_handler();
}
/* process answering machine (play) handling */
- if (e_action)
- {
+ if (e_action) {
if (e_action->index == ACTION_VBOX_PLAY)
vbox_handler();
/* process action timeout */
if (e_action_timeout)
- if (now_d >= e_action_timeout)
- {
- if (e_state!=EPOINT_STATE_CONNECT)
- {
+ if (now_d >= e_action_timeout) {
+ if (e_state!=EPOINT_STATE_CONNECT) {
e_redial = 0;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current action timed out.\n", ea_endpoint->ep_serial);
e_multipoint_cause = 0;
} else {
/* process action timeout */
if (e_match_timeout)
- if (now_d >= e_match_timeout)
- {
+ if (now_d >= e_match_timeout) {
e_redial = 0;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we got a match timeout.\n", ea_endpoint->ep_serial);
process_dialing();
/* process redialing (epoint redials to port) */
- if (e_redial)
- {
- if (now_d >= e_redial)
- {
+ if (e_redial) {
+ if (now_d >= e_redial) {
e_redial = 0;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting redial.\n", ea_endpoint->ep_serial);
}
/* process powerdialing (epoint redials to epoint) */
- if (e_powerdialing > 0)
- {
- if (now_d >= e_powerdialing)
- {
+ if (e_powerdialing > 0) {
+ if (now_d >= e_powerdialing) {
e_powerdialing = -1; /* leave power dialing on */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting redial of powerdial.\n", ea_endpoint->ep_serial);
}
/* process call forward no response */
- if (e_cfnr_release)
- {
+ if (e_cfnr_release) {
struct port_list *portlist;
struct lcr_msg *message;
- if (now >= e_cfnr_release)
- {
+ if (now >= e_cfnr_release) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call-forward-no-response time has expired, hanging up.\n", ea_endpoint->ep_serial);
e_cfnr_release = 0;
/* release all ports */
- while((portlist = ea_endpoint->ep_portlist))
- {
+ while((portlist = ea_endpoint->ep_portlist)) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
new_state(EPOINT_STATE_OUT_SETUP);
}
} else
- if (e_cfnr_call)
- {
- if (now >= e_cfnr_call)
- {
+ if (e_cfnr_call) {
+ if (now >= e_cfnr_call) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call-forward-busy time has expired, calling the forwarded number: %s.\n", ea_endpoint->ep_serial, e_ext.cfnr);
out_setup();
e_cfnr_call = 0;
}
/* handle connection to user */
- if (e_state == EPOINT_STATE_IDLE)
- {
+ if (e_state == EPOINT_STATE_IDLE) {
/* epoint is idle, check callback */
if (e_callback)
- if (now_d >= e_callback)
- {
+ if (now_d >= e_callback) {
e_callback = 0; /* done with callback */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) starting callback.\n", ea_endpoint->ep_serial);
new_state(EPOINT_STATE_OUT_SETUP);
/* check for password timeout */
if (e_action)
- if (e_action->index==ACTION_PASSWORD || e_action->index==ACTION_PASSWORD_WRITE)
- {
+ if (e_action->index==ACTION_PASSWORD || e_action->index==ACTION_PASSWORD_WRITE) {
struct port_list *portlist;
- if (now >= e_password_timeout)
- {
+ if (now >= e_password_timeout) {
e_ruleset = ruleset_main;
if (e_ruleset)
e_rule = e_ruleset->rule_first;
e_dtmf = 0;
new_state(EPOINT_STATE_OUT_DISCONNECT);
portlist = ea_endpoint->ep_portlist;
- if (portlist)
- {
+ if (portlist) {
message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
set_tone(portlist, "cause_10");
}
trace_header("HOOKFLASH DTMF", DIRECTION_NONE);
end_trace();
- if (ea_endpoint->ep_use > 1)
- {
+ if (ea_endpoint->ep_use > 1) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot hooflash while child process is running.\n", ea_endpoint->ep_serial);
return;
}
e_multipoint_cause = 0;
e_multipoint_location = 0;
port = find_port_id(ea_endpoint->ep_portlist->port_id);
- if (port)
- {
+ if (port) {
port->set_echotest(0);
}
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
}
e_ruleset = ruleset_main;
SCPY(e_dialinginfo.id, e_ext.prefix);
e_extdialing = e_dialinginfo.id;
e_join_pattern = 0;
- if (e_dialinginfo.id[0])
- {
+ if (e_dialinginfo.id[0]) {
set_tone(ea_endpoint->ep_portlist, "dialing");
process_dialing();
- } else
- {
+ } else {
set_tone(ea_endpoint->ep_portlist, "dialpbx");
}
e_dtmf_time = now;
// e_dtmf = param->setup.dtmf;
/* screen incoming caller id */
interface = interface_first;
- while(interface)
- {
- if (!strcmp(e_callerinfo.interface, interface->name))
- {
+ while(interface) {
+ if (!strcmp(e_callerinfo.interface, interface->name)) {
break;
}
interface = interface->next;
}
/* process extension */
- if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
- {
+ if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call is extension\n", ea_endpoint->ep_serial);
/* port makes call from extension */
SCPY(e_callerinfo.extension, e_callerinfo.id);
SCPY(e_ext.number, e_callerinfo.extension);
SCPY(e_extension_interface, e_callerinfo.interface);
- } else
- {
+ } else {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call is external or voip\n", ea_endpoint->ep_serial);
}
- if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
- {
+ if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call from extension '%s'\n", ea_endpoint->ep_serial, e_ext.number);
/* get extension's info about caller */
- if (!read_extension(&e_ext, e_ext.number))
- {
+ if (!read_extension(&e_ext, e_ext.number)) {
/* extension doesn't exist */
trace_header("EXTENSION (not created)", DIRECTION_IN);
add_trace("extension", NULL, "%s", e_ext.number);
writeext = 0;
/* put prefix (next) in front of e_dialinginfo.id */
- if (e_ext.next[0])
- {
+ if (e_ext.next[0]) {
SPRINT(buffer, "%s%s", e_ext.next, e_dialinginfo.id);
SCPY(e_dialinginfo.id, buffer);
e_ext.next[0] = '\0';
writeext = 1;
- } else if (e_ext.prefix[0])
- {
+ } else if (e_ext.prefix[0]) {
SPRINT(buffer, "%s%s", e_ext.prefix, e_dialinginfo.id);
SCPY(e_dialinginfo.id, buffer);
}
if (e_ext.name[0])
SCPY(e_callerinfo.name, e_ext.name);
/* use caller id (or if exist: id_next_call) for this call */
- if (e_ext.id_next_call_present >= 0)
- {
+ if (e_ext.id_next_call_present >= 0) {
SCPY(e_callerinfo.id, e_ext.id_next_call);
/* if we restrict the pesentation */
if (e_ext.id_next_call_present==INFO_PRESENT_ALLOWED && e_callerinfo.present==INFO_PRESENT_RESTRICTED)
e_callerinfo.ntype = e_ext.id_next_call_type;
e_ext.id_next_call_present = -1;
writeext = 1;
- } else
- {
+ } else {
SCPY(e_callerinfo.id, e_ext.callerid);
/* if we restrict the pesentation */
if (e_ext.callerid_present==INFO_PRESENT_ALLOWED && e_callerinfo.present==INFO_PRESENT_RESTRICTED)
/* set volume of rx and tx */
if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
- if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0)
- {
+ if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
}
/* start recording if enabled */
- if (e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO))
- {
+ if (e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO)) {
/* check if we are a terminal */
if (e_ext.number[0] == '\0')
PERROR("Port(%d) cannot record because we are not a terminal\n", ea_endpoint->ep_serial);
- else
- {
+ else {
port = find_port_id(portlist->port_id);
if (port)
port->open_record(e_ext.record, 0, 0, e_ext.number, e_ext.anon_ignore, "", 0);
}
}
- } else
- {
+ } else {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call from external port\n", ea_endpoint->ep_serial);
/* no terminal identification */
e_ext.number[0] = '\0';
e_action = NULL;
e_extdialing = e_dialinginfo.id;
new_state(EPOINT_STATE_IN_SETUP);
- if (e_dialinginfo.id[0])
- {
+ if (e_dialinginfo.id[0]) {
set_tone(portlist, "dialing");
- } else
- {
+ } else {
if (e_ext.number[0])
set_tone(portlist, "dialpbx");
else
set_tone(portlist, "dialtone");
}
process_dialing();
- if (e_state == EPOINT_STATE_IN_SETUP)
- {
+ if (e_state == EPOINT_STATE_IN_SETUP) {
/* request MORE info, if not already at higher state */
new_state(EPOINT_STATE_IN_OVERLAP);
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_OVERLAP);
e_overlap = 1;
/* turn off dtmf detection, in case dtmf is sent with keypad information */
- if (e_dtmf)
- {
+ if (e_dtmf) {
trace_header("DTMF (disabling due to keypad)", DIRECTION_IN);
end_trace();
e_dtmf = 0;
/* if vbox_play is done, the information are just used as they come */
if (e_action)
- if (e_action->index == ACTION_VBOX_PLAY)
- {
+ if (e_action->index == ACTION_VBOX_PLAY) {
/* concat dialing string */
SCAT(e_dialinginfo.id, param->information.id);
process_dialing();
}
/* keypad when disconnect but in connected mode */
- if (e_state==EPOINT_STATE_OUT_DISCONNECT && e_connectedmode)
- {
+ if (e_state==EPOINT_STATE_OUT_DISCONNECT && e_connectedmode) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad information received after disconnect: %s.\n", ea_endpoint->ep_serial, param->information.id);
/* processing keypad function */
- if (param->information.id[0] == '0')
- {
+ if (param->information.id[0] == '0') {
hookflash();
}
return;
}
/* keypad when connected */
- if (e_state == EPOINT_STATE_CONNECT)
- {
- if (e_ext.keypad || e_enablekeypad)
- {
+ if (e_state == EPOINT_STATE_CONNECT) {
+ if (e_ext.keypad || e_enablekeypad) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad information received during connect: %s.\n", ea_endpoint->ep_serial, param->information.id);
/* processing keypad function */
- if (param->information.id[0] == '0')
- {
+ if (param->information.id[0] == '0') {
hookflash();
}
if (param->information.id[0])
keypad_function(param->information.id[0]);
- } else
- {
+ } else {
if (e_ext.number[0])
trace_header("KEYPAD (not enabled by extension's settings)", DIRECTION_IN);
else
}
return;
}
- if (e_state != EPOINT_STATE_IN_OVERLAP)
- {
+ if (e_state != EPOINT_STATE_IN_OVERLAP) {
if (e_ext.number[0])
trace_header("KEYPAD (ignored, not connected and not dialing)", DIRECTION_IN);
else
}
if (!param->information.id[0])
return;
- if (e_dialinginfo.id[0]=='\0' && !e_action)
- {
+ if (e_dialinginfo.id[0]=='\0' && !e_action) {
set_tone(portlist, "dialing");
}
if (e_action)
if (e_action->index==ACTION_OUTDIAL
|| e_action->index==ACTION_EXTERNAL
- || e_action->index==ACTION_REMOTE)
- {
+ || e_action->index==ACTION_REMOTE) {
if (!e_extdialing)
set_tone(portlist, "dialing");
else if (!e_extdialing[0])
void EndpointAppPBX::port_dtmf(struct port_list *portlist, int message_type, union parameter *param)
{
/* only if dtmf detection is enabled */
- if (!e_dtmf)
- {
+ if (!e_dtmf) {
trace_header("DTMF (disabled)", DIRECTION_IN);
end_trace();
return;
NOTE: vbox is now handled due to overlap state
/* if vbox_play is done, the dtmf digits are just used as they come */
if (e_action)
- if (e_action->index == ACTION_VBOX_PLAY)
- {
+ if (e_action->index == ACTION_VBOX_PLAY) {
/* concat dialing string */
- if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id))
- {
+ if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id)) {
e_dialinginfo.id[strlen(e_dialinginfo.id)+1] = '\0';
e_dialinginfo.id[strlen(e_dialinginfo.id)] = param->dtmf;
process_dialing();
#endif
/* check for *X# sequence */
- if (e_state == EPOINT_STATE_CONNECT)
- {
- if (e_dtmf_time+3 < now)
- {
+ if (e_state == EPOINT_STATE_CONNECT) {
+ if (e_dtmf_time+3 < now) {
/* the last digit was too far in the past to be a sequence */
if (param->dtmf == '*')
/* only start is allowed in the sequence */
e_dtmf_last = '*';
else
e_dtmf_last = '\0';
- } else
- {
+ } else {
/* we have a sequence of digits, see what we got */
if (param->dtmf == '*')
e_dtmf_last = '*';
- else if (param->dtmf>='0' && param->dtmf<='9')
- {
+ else if (param->dtmf>='0' && param->dtmf<='9') {
/* we need to have a star before we receive the digit of the sequence */
if (e_dtmf_last == '*')
e_dtmf_last = param->dtmf;
- } else if (param->dtmf == '#')
- {
+ } else if (param->dtmf == '#') {
/* the hash key */
- if (e_dtmf_last>='0' && e_dtmf_last<='9')
- {
+ if (e_dtmf_last>='0' && e_dtmf_last<='9') {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dtmf sequence *%c# detected.\n", ea_endpoint->ep_serial, e_dtmf_last);
- if (e_dtmf_last == '0')
- {
+ if (e_dtmf_last == '0') {
hookflash();
return;
}
if (e_action->index==ACTION_PASSWORD
|| e_action->index==ACTION_PASSWORD_WRITE)
goto password;
- if (param->dtmf=='#') /* current digit is '#' */
- {
+ if (param->dtmf=='#') { /* current digit is '#' */
if (e_state==EPOINT_STATE_IN_DISCONNECT
- || (e_state!=EPOINT_STATE_CONNECT && e_dtmf_time+3>=now && e_dtmf_last=='#')) /* when disconnected, just #. when dialing, ##. */
- {
+ || (e_state!=EPOINT_STATE_CONNECT && e_dtmf_time+3>=now && e_dtmf_last=='#')) { /* when disconnected, just #. when dialing, ##. */
hookflash();
return;
- } else
- {
+ } else {
e_dtmf_time = now;
e_dtmf_last = '#';
}
- } else
- {
+ } else {
password:
e_dtmf_time = now;
e_dtmf_last = '\0';
/* dialing using dtmf digit */
- if (e_state==EPOINT_STATE_IN_OVERLAP)// && e_state==e_connectedmode)
- {
- if (e_dialinginfo.id[0]=='\0' && !e_action)
- {
+ if (e_state==EPOINT_STATE_IN_OVERLAP){ // && e_state==e_connectedmode)
+ if (e_dialinginfo.id[0]=='\0' && !e_action) {
set_tone(portlist, "dialing");
}
/* concat dialing string */
- if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id))
- {
+ if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id)) {
e_dialinginfo.id[strlen(e_dialinginfo.id)+1] = '\0';
e_dialinginfo.id[strlen(e_dialinginfo.id)] = param->dtmf;
process_dialing();
/* signal to call tool */
admin_call_response(e_adminid, ADMIN_CALL_SETUP_ACK, "", 0, 0, 0);
- if (e_dialing_queue[0] && portlist)
- {
+ if (e_dialing_queue[0] && portlist) {
/* send what we have not dialed yet, because we had no setup complete */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing pending digits: '%s'\n", ea_endpoint->ep_serial, e_dialing_queue);
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
e_dialing_queue[0] = '\0';
}
/* check if pattern is available */
- if (!ea_endpoint->ep_portlist->next && portlist->early_b) /* one port_list relation and tones available */
- {
+ if (!ea_endpoint->ep_portlist->next && portlist->early_b) { /* one port_list relation and tones available */
/* indicate patterns */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
message_put(message);
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
message->param.audiopath = 1;
message_put(message);
- } else
- {
+ } else {
/* indicate no patterns */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
message_put(message);
}
new_state(EPOINT_STATE_OUT_OVERLAP);
/* if we are in a join */
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
memcpy(&message->param, param, sizeof(union parameter));
message_put(message);
e_state = EPOINT_STATE_OUT_PROCEEDING;
/* check if pattern is availatle */
- if (!ea_endpoint->ep_portlist->next && (portlist->early_b || portlist->port_type==PORT_TYPE_VBOX_OUT)) /* one port_list relation and tones available */
- {
+ if (!ea_endpoint->ep_portlist->next && (portlist->early_b || portlist->port_type==PORT_TYPE_VBOX_OUT)) { /* one port_list relation and tones available */
/* indicate patterns */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
message_put(message);
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
message->param.audiopath = 1;
message_put(message);
- } else
- {
+ } else {
/* indicate no patterns */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
message_put(message);
message_put(message);
}
/* if we are in a call */
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
memcpy(&message->param, param, sizeof(union parameter));
message_put(message);
new_state(EPOINT_STATE_OUT_ALERTING);
/* check if pattern is available */
- if (!ea_endpoint->ep_portlist->next && (portlist->early_b || portlist->port_type==PORT_TYPE_VBOX_OUT)) /* one port_list relation and tones available */
- {
+ if (!ea_endpoint->ep_portlist->next && (portlist->early_b || portlist->port_type==PORT_TYPE_VBOX_OUT)) { /* one port_list relation and tones available */
/* indicate patterns */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
message_put(message);
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
message->param.audiopath = 1;
message_put(message);
- } else
- {
+ } else {
/* indicate no patterns */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
message_put(message);
message_put(message);
}
/* if we are in a call */
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
memcpy(&message->param, param, sizeof(union parameter));
message_put(message);
memcpy(&e_connectinfo, ¶m->connectinfo, sizeof(e_connectinfo));
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing all other ports (start)\n", ea_endpoint->ep_serial);
- while(ea_endpoint->ep_portlist->next) /* as long as we have at least two ports */
- {
+ while(ea_endpoint->ep_portlist->next) { /* as long as we have at least two ports */
tportlist = ea_endpoint->ep_portlist;
if (tportlist->port_id == port_id) /* if the first portlist is the calling one, the second must be a different one */
tportlist = tportlist->next;
/* screen incoming connected id */
interface = interface_first;
- while(interface)
- {
- if (!strcmp(e_connectinfo.interface, interface->name))
- {
+ while(interface) {
+ if (!strcmp(e_connectinfo.interface, interface->name)) {
break;
}
interface = interface->next;
SCPY(e_extension_interface, e_connectinfo.interface);
/* for internal and am calls, we get the extension's id */
- if (portlist->port_type==PORT_TYPE_VBOX_OUT || e_ext.colp==COLP_HIDE)
- {
+ if (portlist->port_type==PORT_TYPE_VBOX_OUT || e_ext.colp==COLP_HIDE) {
SCPY(e_connectinfo.id, e_ext.callerid);
SCPY(e_connectinfo.extension, e_ext.number);
e_connectinfo.itype = INFO_ITYPE_ISDN_EXTENSION;
e_connectinfo.ntype = e_ext.callerid_type;
e_connectinfo.present = e_ext.callerid_present;
}
- if (portlist->port_type==PORT_TYPE_VBOX_OUT)
- {
+ if (portlist->port_type==PORT_TYPE_VBOX_OUT) {
e_connectinfo.itype = INFO_ITYPE_VBOX;
e_connectinfo.ntype = INFO_NTYPE_UNKNOWN;
}
new_state(EPOINT_STATE_CONNECT);
/* set volume of rx and tx */
- if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0)
- {
+ if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
/* modify colp */
/* other calls with no caller id (or not available for the extension) and force colp */
- if ((e_connectinfo.id[0]=='\0' || (e_connectinfo.present==INFO_PRESENT_RESTRICTED && !e_ext.anon_ignore))&& e_ext.colp==COLP_FORCE)
- {
+ if ((e_connectinfo.id[0]=='\0' || (e_connectinfo.present==INFO_PRESENT_RESTRICTED && !e_ext.anon_ignore))&& e_ext.colp==COLP_FORCE) {
e_connectinfo.ntype = INFO_NTYPE_NOTPRESENT;
- if (portlist->port_type==PORT_TYPE_DSS1_TE_OUT || portlist->port_type==PORT_TYPE_DSS1_NT_OUT || portlist->port_type==PORT_TYPE_GSM_OUT) /* external extension answered */
- {
+ if (portlist->port_type==PORT_TYPE_DSS1_TE_OUT || portlist->port_type==PORT_TYPE_DSS1_NT_OUT || portlist->port_type==PORT_TYPE_GSM_OUT) { /* external extension answered */
port = find_port_id(portlist->port_id);
- if (port)
- {
+ if (port) {
SCPY(e_connectinfo.id, nationalize_callerinfo(port->p_dialinginfo.id, &e_connectinfo.ntype, options.national, options.international));
e_connectinfo.present = INFO_PRESENT_ALLOWED;
}
}
/* send connect to join */
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
memcpy(&message->param.connectinfo, &e_connectinfo, sizeof(struct connect_info));
message_put(message);
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
message->param.audiopath = 1;
message_put(message);
- } else if (!e_adminid)
- {
+ } else if (!e_adminid) {
/* callback */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have a callback, so we create a call with cbcaller: \"%s\".\n", ea_endpoint->ep_serial, e_cbcaller);
SCPY(e_ext.number, e_cbcaller);
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) callback from extension '%s'\n", ea_endpoint->ep_serial, e_ext.number);
/* get extension's info about terminal */
- if (!read_extension(&e_ext, e_ext.number))
- {
+ if (!read_extension(&e_ext, e_ext.number)) {
/* extension doesn't exist */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) rejecting callback from not existing extension: '%s'\n", ea_endpoint->ep_serial, e_ext.number);
message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
/* use caller id (or if exist: id_next_call) for this call */
e_callerinfo.screen = INFO_SCREEN_NETWORK;
SCPY(e_callerinfo.extension, e_ext.number);
- if (e_ext.id_next_call_present >= 0)
- {
+ if (e_ext.id_next_call_present >= 0) {
SCPY(e_callerinfo.id, e_ext.id_next_call);
e_callerinfo.present = e_ext.id_next_call_present;
e_callerinfo.ntype = e_ext.id_next_call_type;
e_ext.id_next_call_present = -1;
/* extension is written */
write_extension(&e_ext, e_ext.number);
- } else
- {
+ } else {
SCPY(e_callerinfo.id, e_ext.callerid);
e_callerinfo.present = e_ext.callerid_present;
e_callerinfo.ntype = e_ext.callerid_type;
e_dtmf = 1;
/* check if caller id is NOT authenticated */
- if (!parse_callbackauth(e_ext.number, &e_callbackinfo))
- {
+ if (!parse_callbackauth(e_ext.number, &e_callbackinfo)) {
/* make call state to enter password */
new_state(EPOINT_STATE_IN_OVERLAP);
e_action = &action_password_write;
e_extdialing = strchr(e_dialinginfo.id, '\0');
e_password_timeout = now+20;
process_dialing();
- } else
- {
+ } else {
/* incoming call (callback) */
e_ruleset = ruleset_main;
if (e_ruleset)
e_rule = e_ruleset->rule_first;
e_action = NULL;
e_extdialing = e_dialinginfo.id;
- if (e_dialinginfo.id[0])
- {
+ if (e_dialinginfo.id[0]) {
set_tone(portlist, "dialing");
process_dialing();
- } else
- {
+ } else {
set_tone(portlist, "dialpbx");
}
}
- } else /* testcall */
- {
+ } else { /* testcall */
set_tone(portlist, "hold");
}
/* start recording if enabled, not when answering machine answers */
- if (param->connectinfo.itype!=INFO_ITYPE_VBOX && e_ext.number[0] && e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO))
- {
+ if (param->connectinfo.itype!=INFO_ITYPE_VBOX && e_ext.number[0] && e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO)) {
/* check if we are a terminal */
if (e_ext.number[0] == '\0')
PERROR("Port(%d) cannot record because we are not a terminal\n", ea_endpoint->ep_serial);
- else
- {
+ else {
port = find_port_id(portlist->port_id);
if (port)
port->open_record(e_ext.record, 0, 0, e_ext.number, e_ext.anon_ignore, "", 0);
admin_call_response(e_adminid, (message_type==MESSAGE_DISCONNECT)?ADMIN_CALL_DISCONNECT:ADMIN_CALL_RELEASE, "", param->disconnectinfo.cause, param->disconnectinfo.location, 0);
//#warning does this work? only disconnect when incoming port hat not already disconnected yet?
- if (e_state==EPOINT_STATE_IN_DISCONNECT && message_type!=MESSAGE_RELEASE)// || e_state==EPOINT_STATE_OUT_DISCONNECT || e_state==EPOINT_STATE_IDLE)
- {
+ if (e_state==EPOINT_STATE_IN_DISCONNECT && message_type!=MESSAGE_RELEASE){ // || e_state==EPOINT_STATE_OUT_DISCONNECT || e_state==EPOINT_STATE_IDLE)
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are already disconnected.\n", ea_endpoint->ep_serial);
return;
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) new multipoint cause %d location %d.\n", ea_endpoint->ep_serial, e_multipoint_cause, e_multipoint_location);
/* check if we have more than one portlist relation and we just ignore the disconnect */
- if (ea_endpoint->ep_portlist) if (ea_endpoint->ep_portlist->next)
- {
+ if (ea_endpoint->ep_portlist) if (ea_endpoint->ep_portlist->next) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the disconnect was from a multipoint call. we just release that relation.\n", ea_endpoint->ep_serial);
portlist = ea_endpoint->ep_portlist;
- while(portlist)
- {
+ while(portlist) {
if (portlist->port_id == port_id)
break;
portlist = portlist->next;
}
if (!portlist)
FATAL("EPOINT(%d) no portlist related to the calling port.\n", ea_endpoint->ep_serial);
- if (message_type != MESSAGE_RELEASE)
- {
+ if (message_type != MESSAGE_RELEASE) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
ea_endpoint->free_portlist(portlist);
return; /* one relation removed */
}
- if (e_state == EPOINT_STATE_CONNECT)
- {
+ if (e_state == EPOINT_STATE_CONNECT) {
/* use cause from port after connect */
cause = param->disconnectinfo.cause;
location = param->disconnectinfo.location;
- } else
- {
+ } else {
/* use multipoint cause if no connect yet */
- if (e_multipoint_cause)
- {
+ if (e_multipoint_cause) {
cause = e_multipoint_cause;
location = e_multipoint_location;
- } else
- {
+ } else {
cause = CAUSE_NOUSER;
location = LOCATION_PRIVATE_LOCAL;
}
e_multipoint_cause = 0;
e_multipoint_location = 0;
- if (message_type == MESSAGE_DISCONNECT)
- {
+ if (message_type == MESSAGE_DISCONNECT) {
/* tone to disconnected end */
SPRINT(buffer, "cause_%02x", cause);
if (ea_endpoint->ep_portlist)
new_state(EPOINT_STATE_IN_DISCONNECT);
}
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
int haspatterns = 0;
/* check if pattern is available */
if (ea_endpoint->ep_portlist)
if (joinpbx_countrelations(ea_endpoint->ep_join_id)==2 // we must count relations, in order not to disturb the conference ; NOTE: asterisk always counts two, since it is a point to point call
&& message_type != MESSAGE_RELEASE) // if we release, we are done
haspatterns = 1;
- if (haspatterns)
- {
+ if (haspatterns) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the port has patterns.\n", ea_endpoint->ep_serial);
/* indicate patterns */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
if (e_crypt_state)
cryptman_message(CI_DISCONNECT_IND, NULL, 0);
return;
- } else
- {
+ } else {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the port has no patterns.\n", ea_endpoint->ep_serial);
}
}
trace_header("TIMEOUT", DIRECTION_IN);
message_type = MESSAGE_DISCONNECT;
- switch (param->state)
- {
+ switch (param->state) {
case PORT_STATE_OUT_SETUP:
case PORT_STATE_OUT_OVERLAP:
add_trace("state", NULL, "outgoing setup/dialing");
new_state(EPOINT_STATE_OUT_DISCONNECT);
SPRINT(cause, "cause_%02x", param->disconnectinfo.cause);
SCPY(e_tone, cause);
- while(portlist)
- {
+ while(portlist) {
set_tone(portlist, cause);
message_disconnect_port(portlist, param->disconnectinfo.cause, param->disconnectinfo.location, "");
portlist = portlist->next;
/* signal to call tool */
admin_call_response(e_adminid, ADMIN_CALL_NOTIFY, numberrize_callerinfo(param->notifyinfo.id,param->notifyinfo.ntype, options.national, options.international), 0, 0, param->notifyinfo.notify);
- if (param->notifyinfo.notify)
- {
+ if (param->notifyinfo.notify) {
e_rx_state = track_notify(e_rx_state, param->notifyinfo.notify);
}
/* if we get notification from stack, local shows if we disabled/enabled audio stream */
- if (param->notifyinfo.local) switch(param->notifyinfo.notify)
- {
+ if (param->notifyinfo.local) switch(param->notifyinfo.notify) {
case INFO_NOTIFY_REMOTE_HOLD:
case INFO_NOTIFY_USER_SUSPENDED:
/* tell call about it */
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
message->param.audiopath = 0;
message_put(message);
/* set volume of rx and tx */
if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0)
- if (portlist)
- {
+ if (portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
message->param.mISDNsignal.message = mISDNSIGNAL_VOLUME;
message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
if (portlist)
set_tone(portlist, e_tone);
/* tell call about it */
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
message->param.audiopath = 1;
message_put(message);
}
/* get name of notify */
- switch(param->notifyinfo.notify)
- {
+ switch(param->notifyinfo.notify) {
case 0x00:
logtext = "NULL";
break;
}
/* notify call if available */
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOTIFY);
memcpy(&message->param.notifyinfo, ¶m->notifyinfo, sizeof(struct notify_info));
message_put(message);
struct port_list *portlist;
portlist = ea_endpoint->ep_portlist;
- while(portlist)
- {
+ while(portlist) {
if (port_id == portlist->port_id)
break;
portlist = portlist->next;
}
- if (!portlist)
- {
+ if (!portlist) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) warning: port is not related to this endpoint. This may happen, if port has been released after the message was created.\n", ea_endpoint->ep_serial);
return;
}
// PDEBUG(DEBUG_EPOINT, "received message %d (terminal %s, caller id %s)\n", message, e_ext.number, e_callerinfo.id);
- switch(message_type)
- {
+ switch(message_type) {
case MESSAGE_DATA: /* data from port */
/* check if there is a call */
if (!ea_endpoint->ep_join_id)
case MESSAGE_TONE_EOF: /* tone is end of file */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current tone is now end of file.\n", ea_endpoint->ep_serial);
- if (e_action)
- {
- if (e_action->index == ACTION_VBOX_PLAY)
- {
+ if (e_action) {
+ if (e_action->index == ACTION_VBOX_PLAY) {
vbox_message_eof();
}
- if (e_action->index == ACTION_EFI)
- {
+ if (e_action->index == ACTION_EFI) {
efi_message_eof();
}
}
case MESSAGE_TONE_COUNTER: /* counter info received */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) received counter information: %d / %d seconds after start of tone.\n", ea_endpoint->ep_serial, param->counter.current, param->counter.max);
if (e_action)
- if (e_action->index == ACTION_VBOX_PLAY)
- {
+ if (e_action->index == ACTION_VBOX_PLAY) {
e_vbox_counter = param->counter.current;
if (param->counter.max >= 0)
e_vbox_counter_max = param->counter.max;
/* PORT sends SETUP message */
case MESSAGE_SETUP:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call from callerid=%s, dialing=%s\n", ea_endpoint->ep_serial, param->setup.callerinfo.id, param->setup.dialinginfo.id);
- if (e_state!=EPOINT_STATE_IDLE)
- {
+ if (e_state!=EPOINT_STATE_IDLE) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in idle state.\n", ea_endpoint->ep_serial);
break;
}
/* PORT sends MORE message */
case MESSAGE_OVERLAP:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is accepted [overlap dialing] (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
- if (e_state != EPOINT_STATE_OUT_SETUP)
- {
+ if (e_state != EPOINT_STATE_OUT_SETUP) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup state (for port_list: another portlist might have changed the state already).\n", ea_endpoint->ep_serial);
break;
}
case MESSAGE_PROCEEDING: /* port is proceeding */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is proceeding (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_OUT_SETUP
- && e_state!=EPOINT_STATE_OUT_OVERLAP)
- {
+ && e_state!=EPOINT_STATE_OUT_OVERLAP) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in overlap state (for port_list: another portlist might have changed the state already).\n", ea_endpoint->ep_serial);
break;
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is ringing (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_OUT_SETUP
&& e_state!=EPOINT_STATE_OUT_OVERLAP
- && e_state!=EPOINT_STATE_OUT_PROCEEDING)
- {
+ && e_state!=EPOINT_STATE_OUT_PROCEEDING) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup or proceeding state (for port_list: another portlist might have changed the state already).\n", ea_endpoint->ep_serial);
break;
}
if (e_state!=EPOINT_STATE_OUT_SETUP
&& e_state!=EPOINT_STATE_OUT_OVERLAP
&& e_state!=EPOINT_STATE_OUT_PROCEEDING
- && e_state!=EPOINT_STATE_OUT_ALERTING)
- {
+ && e_state!=EPOINT_STATE_OUT_ALERTING) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup, proceeding or alerting state.\n", ea_endpoint->ep_serial);
break;
}
/* join MESSAGE_CRYPT */
void EndpointAppPBX::join_crypt(struct port_list *portlist, int message_type, union parameter *param)
{
- switch(param->crypt.type)
- {
+ switch(param->crypt.type) {
/* message from remote port to "crypt manager" */
case CU_ACTK_REQ: /* activate key-exchange */
case CU_ACTS_REQ: /* activate shared key */
e_overlap = 1;
- while(portlist)
- {
+ while(portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
memcpy(&message->param.information, ¶m->information, sizeof(struct dialing_info));
message_put(message);
{
struct lcr_msg *message;
- if (!e_ext.facility && e_ext.number[0])
- {
+ if (!e_ext.facility && e_ext.number[0]) {
return;
}
- while(portlist)
- {
+ while(portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_FACILITY);
memcpy(&message->param.facilityinfo, ¶m->facilityinfo, sizeof(struct facility_info));
message_put(message);
new_state(EPOINT_STATE_IN_OVERLAP);
/* own dialtone */
- if (e_join_pattern && e_ext.own_setup)
- {
+ if (e_join_pattern && e_ext.own_setup) {
/* disconnect audio */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
message->param.audiopath = 0;
message_put(message);
}
- if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL)
- {
+ if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL) {
if (e_dialinginfo.id[0])
set_tone(portlist, "dialing");
else
set_tone(portlist, "dialtone");
return;
}
- if (e_dialinginfo.id[0])
- {
+ if (e_dialinginfo.id[0]) {
set_tone(portlist, "dialing");
- } else
- {
+ } else {
if (e_ext.number[0])
set_tone(portlist, "dialpbx");
else
new_state(EPOINT_STATE_IN_PROCEEDING);
/* own proceeding tone */
- if (e_join_pattern)
- {
+ if (e_join_pattern) {
/* connect / disconnect audio */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
if (e_ext.own_proceeding)
message_put(message);
}
// UCPY(e_join_tone, "proceeding");
- if (portlist)
- {
+ if (portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
message_put(message);
logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
new_state(EPOINT_STATE_IN_ALERTING);
/* own alerting tone */
- if (e_join_pattern)
- {
+ if (e_join_pattern) {
/* connect / disconnect audio */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
if (e_ext.own_alerting)
message->param.audiopath = 1;
message_put(message);
}
- if (portlist)
- {
+ if (portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_ALERTING);
message_put(message);
logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
- if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL)
- {
+ if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL) {
set_tone(portlist, "ringing");
return;
}
e_powerdialing = 0;
memcpy(&e_connectinfo, ¶m->connectinfo, sizeof(e_callerinfo));
- if(portlist)
- {
+ if(portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
memcpy(&message->param, param, sizeof(union parameter));
/* screen clip if prefix is required */
- if (e_ext.number[0] && message->param.connectinfo.id[0] && e_ext.clip_prefix[0])
- {
+ if (e_ext.number[0] && message->param.connectinfo.id[0] && e_ext.clip_prefix[0]) {
SCPY(message->param.connectinfo.id, e_ext.clip_prefix);
SCAT(message->param.connectinfo.id, numberrize_callerinfo(e_connectinfo.id,e_connectinfo.ntype, options.national, options.international));
message->param.connectinfo.ntype = INFO_NTYPE_UNKNOWN;
}
/* use internal caller id */
- if (e_ext.number[0] && e_connectinfo.extension[0] && (message->param.connectinfo.present!=INFO_PRESENT_RESTRICTED || e_ext.anon_ignore))
- {
+ if (e_ext.number[0] && e_connectinfo.extension[0] && (message->param.connectinfo.present!=INFO_PRESENT_RESTRICTED || e_ext.anon_ignore)) {
SCPY(message->param.connectinfo.id, e_connectinfo.extension);
message->param.connectinfo.ntype = INFO_NTYPE_UNKNOWN;
}
e_tx_state = NOTIFY_STATE_ACTIVE;
/* we are powerdialing, if e_powerdialing is set and limit is not exceeded if given */
- if (e_powerdialing && ((e_powercount+1)<e_powerlimit || e_powerlimit<1))
- {
+ if (e_powerdialing && ((e_powercount+1)<e_powerlimit || e_powerlimit<1)) {
release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
/* set time for power dialing */
e_powercount++;
/* set redial tone */
- if (ea_endpoint->ep_portlist)
- {
+ if (ea_endpoint->ep_portlist) {
e_join_pattern = 0;
}
set_tone(ea_endpoint->ep_portlist, "redial");
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') redialing in %d seconds\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, (int)e_powerdelay);
/* send proceeding when powerdialing and still setup (avoid dialing timeout) */
- if (e_state==EPOINT_STATE_IN_OVERLAP)
- {
+ if (e_state==EPOINT_STATE_IN_OVERLAP) {
new_state(EPOINT_STATE_IN_PROCEEDING);
- if (ea_endpoint->ep_portlist)
- {
+ if (ea_endpoint->ep_portlist) {
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
message_put(message);
logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
/* set_tone(portlist, "proceeding"); */
}
/* send display of powerdialing */
- if (e_ext.display_dialing)
- {
+ if (e_ext.display_dialing) {
portlist = ea_endpoint->ep_portlist;
- while (portlist)
- {
+ while (portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
if (e_powerlimit)
SPRINT(message->param.notifyinfo.display, "Retry %d of %d", e_powercount, e_powerlimit);
&& e_state!=EPOINT_STATE_IN_OVERLAP
&& e_state!=EPOINT_STATE_IN_PROCEEDING
&& e_state!=EPOINT_STATE_IN_ALERTING)
- || !ea_endpoint->ep_portlist) /* or no port */
- {
+ || !ea_endpoint->ep_portlist) { /* or no port */
process_hangup(param->disconnectinfo.cause, param->disconnectinfo.location);
release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, param->disconnectinfo.cause); /* RELEASE_TYPE, join, port */
return; /* must exit here */
}
/* save cause */
- if (!e_join_cause)
- {
+ if (!e_join_cause) {
e_join_cause = param->disconnectinfo.cause;
e_join_location = param->disconnectinfo.location;
}
/* on release we need the audio again! */
- if (message_type == MESSAGE_RELEASE)
- {
+ if (message_type == MESSAGE_RELEASE) {
e_join_pattern = 0;
ea_endpoint->ep_join_id = 0;
}
SPRINT(cause, "cause_%02x", param->disconnectinfo.cause);
/* if own_cause, we must release the join */
if (e_ext.own_cause /* own cause */
- || !e_join_pattern) /* no patterns */
- {
+ || !e_join_pattern) { /* no patterns */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have own cause or we have no patterns. (own_cause=%d pattern=%d)\n", ea_endpoint->ep_serial, e_ext.own_cause, e_join_pattern);
if (message_type != MESSAGE_RELEASE)
release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
e_join_pattern = 0;
- } else /* else we enable audio */
- {
+ } else { /* else we enable audio */
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
message->param.audiopath = 1;
message_put(message);
/* send disconnect message */
SCPY(e_tone, cause);
portlist = ea_endpoint->ep_portlist;
- while(portlist)
- {
+ while(portlist) {
set_tone(portlist, cause);
message_disconnect_port(portlist, param->disconnectinfo.cause, param->disconnectinfo.location, "");
portlist = portlist->next;
/* if we already in setup state, we just update the dialing with new digits */
if (e_state == EPOINT_STATE_OUT_SETUP
- || e_state == EPOINT_STATE_OUT_OVERLAP)
- {
+ || e_state == EPOINT_STATE_OUT_OVERLAP) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we are in setup state, so we do overlap dialing.\n", ea_endpoint->ep_serial);
/* if digits changed, what we have already dialed */
- if (!!strncmp(e_dialinginfo.id,param->setup.dialinginfo.id,strlen(e_dialinginfo.id)))
- {
+ if (!!strncmp(e_dialinginfo.id,param->setup.dialinginfo.id,strlen(e_dialinginfo.id))) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have dialed digits which have been changed or we have a new multidial, so we must redial.\n", ea_endpoint->ep_serial);
/* release all ports */
- while((portlist = ea_endpoint->ep_portlist))
- {
+ while((portlist = ea_endpoint->ep_portlist)) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
return;
}
/* if we have a pending redial, so we just adjust the dialing number */
- if (e_redial)
- {
+ if (e_redial) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) redial in progress, so we update the dialing number to %s.\n", ea_endpoint->ep_serial, param->setup.dialinginfo.id);
memcpy(&e_dialinginfo, ¶m->setup.dialinginfo, sizeof(e_dialinginfo));
return;
}
- if (!ea_endpoint->ep_portlist)
- {
+ if (!ea_endpoint->ep_portlist) {
PERROR("ERROR: overlap dialing to a NULL port relation\n");
}
- if (ea_endpoint->ep_portlist->next)
- {
+ if (ea_endpoint->ep_portlist->next) {
PERROR("ERROR: overlap dialing to a port_list port relation\n");
}
- if (e_state == EPOINT_STATE_OUT_SETUP)
- {
+ if (e_state == EPOINT_STATE_OUT_SETUP) {
/* queue digits */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) digits '%s' are queued because we didn't receive a setup acknowledge.\n", ea_endpoint->ep_serial, param->setup.dialinginfo.id);
SCAT(e_dialing_queue, param->setup.dialinginfo.id + strlen(e_dialinginfo.id));
- } else
- {
+ } else {
/* get what we have not dialed yet */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have already dialed '%s', we received '%s', what's left '%s'.\n", ea_endpoint->ep_serial, e_dialinginfo.id, param->setup.dialinginfo.id, param->setup.dialinginfo.id+strlen(e_dialinginfo.id));
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
return;
}
- if (e_state != EPOINT_STATE_IDLE)
- {
+ if (e_state != EPOINT_STATE_IDLE) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in idle state.\n", ea_endpoint->ep_serial);
return;
}
if (param->setup.dialinginfo.itype==INFO_ITYPE_ISDN_EXTENSION || param->setup.dialinginfo.itype==INFO_ITYPE_VBOX)
SCPY(e_ext.number, param->setup.dialinginfo.id);
/* if an internal extension is dialed, get extension's info about caller */
- if (e_ext.number[0])
- {
- if (!read_extension(&e_ext, e_ext.number))
- {
+ if (e_ext.number[0]) {
+ if (!read_extension(&e_ext, e_ext.number)) {
e_ext.number[0] = '\0';
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the called terminal='%s' is not found in directory tree!\n", ea_endpoint->ep_serial, e_ext.number);
}
memcpy(&e_capainfo, ¶m->setup.capainfo, sizeof(e_capainfo));
/* process (voice over) data calls */
- if (e_ext.datacall && e_capainfo.bearer_capa!=INFO_BC_SPEECH && e_capainfo.bearer_capa!=INFO_BC_AUDIO)
- {
+ if (e_ext.datacall && e_capainfo.bearer_capa!=INFO_BC_SPEECH && e_capainfo.bearer_capa!=INFO_BC_AUDIO) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) handling data call as audio call: '%s'\n", ea_endpoint->ep_serial, e_ext.number);
memset(&e_capainfo, 0, sizeof(e_capainfo));
e_capainfo.bearer_capa = INFO_BC_AUDIO;
{
struct lcr_msg *message;
- while(portlist)
- {
+ while(portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
memcpy(&message->param, param, sizeof(union parameter));
message_put(message);
struct lcr_msg *message;
int new_state;
- if (param->notifyinfo.notify)
- {
+ if (param->notifyinfo.notify) {
new_state = track_notify(e_tx_state, param->notifyinfo.notify);
// /* if notification was generated locally, we turn hold music on/off */
// if (param->notifyinfo.local)
// NOTE: we always assume that we send hold music on suspension of call, because we don't track if audio is available or not (we assume that we always have no audio, to make it easier)
{
- if (e_hold)
- {
+ if (e_hold) {
/* unhold if */
- if (new_state!=NOTIFY_STATE_HOLD && new_state!=NOTIFY_STATE_SUSPEND)
- {
- if (!strcmp(e_tone, "hold")) // don't interrupt other tones
- {
- while(portlist)
- {
+ if (new_state!=NOTIFY_STATE_HOLD && new_state!=NOTIFY_STATE_SUSPEND) {
+ if (!strcmp(e_tone, "hold")) { // don't interrupt other tones
+ while(portlist) {
set_tone(portlist, "");
portlist = portlist->next;
}
}
} else {
/* hold if */
- if (new_state==NOTIFY_STATE_HOLD || new_state==NOTIFY_STATE_SUSPEND)
- {
- while(portlist)
- {
+ if (new_state==NOTIFY_STATE_HOLD || new_state==NOTIFY_STATE_SUSPEND) {
+ while(portlist) {
set_tone(portlist, "hold");
portlist = portlist->next;
}
}
/* notify port(s) about it */
- while(portlist)
- {
+ while(portlist) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
memcpy(&message->param.notifyinfo, ¶m->notifyinfo, sizeof(struct notify_info));
/* handle restricted caller ids */
struct port_list *portlist;
struct lcr_msg *message;
- if (!join_id)
- {
+ if (!join_id) {
PERROR("EPOINT(%d) error: JOIN == NULL.\n", ea_endpoint->ep_serial);
return;
}
portlist = ea_endpoint->ep_portlist;
/* send MESSAGE_DATA to port */
- if (message_type == MESSAGE_DATA)
- {
- if (join_id == ea_endpoint->ep_join_id) // still linked with JOIN
- {
+ if (message_type == MESSAGE_DATA) {
+ if (join_id == ea_endpoint->ep_join_id) { // still linked with JOIN
/* skip if no port relation */
if (!portlist)
return;
}
// PDEBUG(DEBUG_EPOINT, "EPOINT(%d) received message %d for active JOIN (terminal %s, caller id %s state=%d)\n", ea_endpoint->ep_serial, message, e_ext.number, e_callerinfo.id, e_state);
- switch(message_type)
- {
+ switch(message_type) {
/* JOIN SENDS TONE message */
case MESSAGE_TONE:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received tone message: '%d'\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->tone.name);
case MESSAGE_OVERLAP:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received 'more info required'\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_IN_SETUP
- && e_state!=EPOINT_STATE_IN_OVERLAP)
- {
+ && e_state!=EPOINT_STATE_IN_OVERLAP) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup state.\n", ea_endpoint->ep_serial);
break;
}
/* JOIN sends PROCEEDING message */
case MESSAGE_PROCEEDING:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s (caller id '%s') received proceeding\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
- if(e_state!=EPOINT_STATE_IN_OVERLAP)
- {
+ if(e_state!=EPOINT_STATE_IN_OVERLAP) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup state.\n", ea_endpoint->ep_serial);
break;
}
case MESSAGE_ALERTING:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received alerting\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_IN_OVERLAP
- && e_state!=EPOINT_STATE_IN_PROCEEDING)
- {
+ && e_state!=EPOINT_STATE_IN_PROCEEDING) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup or proceeding state.\n", ea_endpoint->ep_serial);
break;
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received connect\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_IN_OVERLAP
&& e_state!=EPOINT_STATE_IN_PROCEEDING
- && e_state!=EPOINT_STATE_IN_ALERTING)
- {
+ && e_state!=EPOINT_STATE_IN_ALERTING) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup, proceeding or alerting state.\n", ea_endpoint->ep_serial);
break;
}
/* JOIN has pattern available */
case MESSAGE_PATTERN: /* indicating pattern available */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received pattern availability.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
- if (!e_join_pattern)
- {
+ if (!e_join_pattern) {
PDEBUG(DEBUG_EPOINT, "-> pattern becomes available\n");
e_join_pattern = 1;
SCPY(e_tone, "");
- while(portlist)
- {
+ while(portlist) {
set_tone(portlist, NULL);
portlist = portlist->next;
}
/* JOIN has no pattern available */
case MESSAGE_NOPATTERN: /* indicating no pattern available */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received pattern NOT available.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
- if (e_join_pattern)
- {
+ if (e_join_pattern) {
PDEBUG(DEBUG_EPOINT, "-> pattern becomes unavailable\n");
e_join_pattern = 0;
/* disconnect our audio tx and rx */
if (!list)
return(1);
- while(42)
- {
+ while(42) {
/* eliminate white spaces */
while (*list <= ' ')
list++;
- if (*list == ',')
- {
+ if (*list == ',') {
list++;
continue;
}
vbox = 0;
found = NULL;
eapp = apppbx_first;
- while(eapp)
- {
- if (eapp!=this && ea_endpoint->ep_portlist)
- {
+ while(eapp) {
+ if (eapp!=this && ea_endpoint->ep_portlist) {
portlist = eapp->ea_endpoint->ep_portlist;
- while(portlist)
- {
- if ((port = find_port_id(portlist->port_id)))
- {
- if (port->p_type == PORT_TYPE_VBOX_OUT)
- {
- if (match_list(extensions, eapp->e_ext.number))
- {
+ while(portlist) {
+ if ((port = find_port_id(portlist->port_id))) {
+ if (port->p_type == PORT_TYPE_VBOX_OUT) {
+ if (match_list(extensions, eapp->e_ext.number)) {
found = eapp;
vbox = 1;
break;
}
if ((port->p_type==PORT_TYPE_DSS1_NT_OUT || port->p_type==PORT_TYPE_DSS1_TE_OUT || port->p_type==PORT_TYPE_GSM_OUT)
&& port->p_state==PORT_STATE_OUT_ALERTING)
- if (match_list(extensions, eapp->e_ext.number))
- {
+ if (match_list(extensions, eapp->e_ext.number)) {
found = eapp;
}
}
}
/* if no endpoint found */
- if (!found)
- {
+ if (!found) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) nobody is ringing internally (or we don't have her in the access list), so we disconnect.\n", ea_endpoint->ep_serial);
reject:
set_tone(ea_endpoint->ep_portlist, "cause_10");
}
eapp = found;
- if (ea_endpoint->ep_join_id)
- {
+ if (ea_endpoint->ep_join_id) {
PERROR("EPOINT(%d) we already have a join. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
goto reject;
}
- if (!eapp->ea_endpoint->ep_join_id)
- {
+ if (!eapp->ea_endpoint->ep_join_id) {
PERROR("EPOINT(%d) ringing endpoint has no join.\n", ea_endpoint->ep_serial);
goto reject;
}
join = find_join_id(eapp->ea_endpoint->ep_join_id);
- if (!join)
- {
+ if (!join) {
PERROR("EPOINT(%d) ringing endpoint's join not found.\n", ea_endpoint->ep_serial);
goto reject;
}
- if (join->j_type != JOIN_TYPE_PBX)
- {
+ if (join->j_type != JOIN_TYPE_PBX) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ringing endpoint's join is not a PBX join, so we must reject.\n", ea_endpoint->ep_serial);
goto reject;
}
joinpbx = (class JoinPBX *)join;
relation = joinpbx->j_relation;
- if (!relation)
- {
+ if (!relation) {
PERROR("EPOINT(%d) ringing endpoint's join has no relation. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
goto reject;
}
- while (relation->epoint_id != eapp->ea_endpoint->ep_serial)
- {
+ while (relation->epoint_id != eapp->ea_endpoint->ep_serial) {
relation = relation->next;
- if (!relation)
- {
+ if (!relation) {
PERROR("EPOINT(%d) ringing endpoint's join has no relation to that join. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
goto reject;
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) found ringing endpoint: %d.\n", ea_endpoint->ep_serial, eapp->ea_endpoint->ep_serial);
- if (options.deb & DEBUG_EPOINT)
- {
+ if (options.deb & DEBUG_EPOINT) {
class Join *debug_c = join_first;
class Endpoint *debug_e = epoint_first;
class Port *debug_p = port_first;
joinpbx_debug(joinpbx, "EndpointAppPBX::pick_join(before)");
PDEBUG(DEBUG_EPOINT, "showing all joins:\n");
- while(debug_c)
- {
+ while(debug_c) {
PDEBUG(DEBUG_EPOINT, "join=%ld\n", debug_c->j_serial);
debug_c = debug_c->next;
}
PDEBUG(DEBUG_EPOINT, "showing all endpoints:\n");
- while(debug_e)
- {
+ while(debug_e) {
PDEBUG(DEBUG_EPOINT, "ep=%ld, join=%ld\n", debug_e->ep_serial, debug_e->ep_join_id);
debug_e = debug_e->next;
}
PDEBUG(DEBUG_EPOINT, "showing all ports:\n");
- while(debug_p)
- {
+ while(debug_p) {
PDEBUG(DEBUG_EPOINT, "port=%ld, ep=%ld (active)\n", debug_p->p_serial, ACTIVE_EPOINT(debug_p->p_epointlist));
debug_p = debug_p->next;
}
/* beeing paranoid, we make call update */
joinpbx->j_updatebridge = 1;
- if (options.deb & DEBUG_EPOINT)
- {
+ if (options.deb & DEBUG_EPOINT) {
class Join *debug_c = join_first;
class Endpoint *debug_e = epoint_first;
class Port *debug_p = port_first;
joinpbx_debug(joinpbx, "EndpointAppPBX::pick_join(after)");
PDEBUG(DEBUG_EPOINT, "showing all joins:\n");
- while(debug_c)
- {
+ while(debug_c) {
PDEBUG(DEBUG_EPOINT, "join=%ld\n", debug_c->j_serial);
debug_c = debug_c->next;
}
PDEBUG(DEBUG_EPOINT, "showing all endpoints:\n");
- while(debug_e)
- {
+ while(debug_e) {
PDEBUG(DEBUG_EPOINT, "ep=%ld, join=%ld\n", debug_e->ep_serial, debug_e->ep_join_id);
debug_e = debug_e->next;
}
PDEBUG(DEBUG_EPOINT, "showing all ports:\n");
- while(debug_p)
- {
+ while(debug_p) {
PDEBUG(DEBUG_EPOINT, "port=%ld, ep=%ld\n", debug_p->p_serial, ACTIVE_EPOINT(debug_p->p_epointlist));
debug_p = debug_p->next;
}
/* are we a candidate to join a join */
our_join = find_join_id(ea_endpoint->ep_join_id);
- if (!our_join)
- {
+ if (!our_join) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: our join doesn't exist anymore.\n", ea_endpoint->ep_serial);
return;
}
- if (our_join->j_type != JOIN_TYPE_PBX)
- {
+ if (our_join->j_type != JOIN_TYPE_PBX) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: join is not a pbx join.\n", ea_endpoint->ep_serial);
return;
}
our_joinpbx = (class JoinPBX *)our_join;
- if (!ea_endpoint->ep_portlist)
- {
+ if (!ea_endpoint->ep_portlist) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: we have no port.\n", ea_endpoint->ep_serial);
return;
}
- if (!e_ext.number[0])
- {
+ if (!e_ext.number[0]) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: we are not internal extension.\n", ea_endpoint->ep_serial);
return;
}
our_port = find_port_id(ea_endpoint->ep_portlist->port_id);
- if (!our_port)
- {
+ if (!our_port) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: our port doesn't exist anymore.\n", ea_endpoint->ep_serial);
return;
}
- if ((our_port->p_type&PORT_CLASS_mISDN_MASK) != PORT_CLASS_mISDN_DSS1)
- {
+ if ((our_port->p_type&PORT_CLASS_mISDN_MASK) != PORT_CLASS_mISDN_DSS1) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: our port is not isdn.\n", ea_endpoint->ep_serial);
return;
}
/* find an endpoint that is on hold and has the same mISDNport that we are on */
other_eapp = apppbx_first;
- while(other_eapp)
- {
- if (other_eapp == this)
- {
+ while(other_eapp) {
+ if (other_eapp == this) {
other_eapp = other_eapp->next;
continue;
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) comparing other endpoint candiate: (ep%d) terminal='%s' port=%s join=%d.\n", ea_endpoint->ep_serial, other_eapp->ea_endpoint->ep_serial, other_eapp->e_ext.number, (other_eapp->ea_endpoint->ep_portlist)?"YES":"NO", other_eapp->ea_endpoint->ep_join_id);
if (other_eapp->e_ext.number[0] /* has terminal */
&& other_eapp->ea_endpoint->ep_portlist /* has port */
- && other_eapp->ea_endpoint->ep_join_id) /* has join */
- {
+ && other_eapp->ea_endpoint->ep_join_id) { /* has join */
other_port = find_port_id(other_eapp->ea_endpoint->ep_portlist->port_id);
- if (other_port) /* port still exists */
- {
+ if (other_port) { /* port still exists */
if (other_port->p_type==PORT_TYPE_DSS1_NT_OUT
- || other_port->p_type==PORT_TYPE_DSS1_NT_IN) /* port is isdn nt-mode */
- {
+ || other_port->p_type==PORT_TYPE_DSS1_NT_IN) { /* port is isdn nt-mode */
other_pdss1 = (class Pdss1 *)other_port;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) comparing other endpoint's port is of type isdn! comparing our portnum=%d with other's portnum=%d hold=%s ces=%d\n", ea_endpoint->ep_serial, our_pdss1->p_m_mISDNport->portnum, other_pdss1->p_m_mISDNport->portnum, (other_pdss1->p_m_hold)?"YES":"NO", other_pdss1->p_m_d_ces);
if (other_pdss1->p_m_hold /* port is on hold */
&& other_pdss1->p_m_mISDNport == our_pdss1->p_m_mISDNport /* same isdn interface */
&& other_pdss1->p_m_d_ces == our_pdss1->p_m_d_ces) /* same tei+sapi */
break;
- } else
- {
+ } else {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) comparing other endpoint's port is of other type!\n", ea_endpoint->ep_serial);
}
- } else
- {
+ } else {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) comparing other endpoint's port doesn't exist enymore.\n", ea_endpoint->ep_serial);
}
}
other_eapp = other_eapp->next;
}
- if (!other_eapp)
- {
+ if (!other_eapp) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: no other endpoint on same isdn interface with port on hold.\n", ea_endpoint->ep_serial);
return;
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) port on hold found.\n", ea_endpoint->ep_serial);
/* if we have the same join */
- if (other_eapp->ea_endpoint->ep_join_id == ea_endpoint->ep_join_id)
- {
+ if (other_eapp->ea_endpoint->ep_join_id == ea_endpoint->ep_join_id) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: we an the other have the same join.\n", ea_endpoint->ep_serial);
return;
}
other_join = find_join_id(other_eapp->ea_endpoint->ep_join_id);
- if (!other_join)
- {
+ if (!other_join) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: other join doesn't exist anymore.\n", ea_endpoint->ep_serial);
return;
}
- if (other_join->j_type != JOIN_TYPE_PBX)
- {
+ if (other_join->j_type != JOIN_TYPE_PBX) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: other join is not a pbx join.\n", ea_endpoint->ep_serial);
return;
}
other_joinpbx = (class JoinPBX *)other_join;
- if (our_joinpbx->j_partyline && other_joinpbx->j_partyline)
- {
+ if (our_joinpbx->j_partyline && other_joinpbx->j_partyline) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: both joins are partylines.\n", ea_endpoint->ep_serial);
return;
}
/* remove relation to endpoint for join on hold */
other_relation = other_joinpbx->j_relation;
other_relation_pointer = &other_joinpbx->j_relation;
- while(other_relation)
- {
- if (other_relation->epoint_id == other_eapp->ea_endpoint->ep_serial)
- {
+ while(other_relation) {
+ if (other_relation->epoint_id == other_eapp->ea_endpoint->ep_serial) {
/* detach other endpoint on hold */
*other_relation_pointer = other_relation->next;
FREE(other_relation, sizeof(struct join_relation));
/* change join/hold pointer of endpoint to the new join */
temp_epoint = find_epoint_id(other_relation->epoint_id);
- if (temp_epoint)
- {
+ if (temp_epoint) {
if (temp_epoint->ep_join_id == other_join->j_serial)
temp_epoint->ep_join_id = our_join->j_serial;
}
/* join call relations */
our_relation = our_joinpbx->j_relation;
our_relation_pointer = &our_joinpbx->j_relation;
- while(our_relation)
- {
+ while(our_relation) {
our_relation_pointer = &our_relation->next;
our_relation = our_relation->next;
}
class Endpoint *epoint;
/* some paranoia check */
- if (!ea_endpoint->ep_portlist)
- {
+ if (!ea_endpoint->ep_portlist) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) error: we have no port.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
- if (!e_ext.number[0])
- {
+ if (!e_ext.number[0]) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) error: we are not internal extension.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
/* check if we have a join with 2 parties */
join = find_join_id(ea_endpoint->ep_join_id);
- if (!join)
- {
+ if (!join) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have currently no join.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
- if (join->j_type != JOIN_TYPE_PBX)
- {
+ if (join->j_type != JOIN_TYPE_PBX) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join is not a pbx join.\n", ea_endpoint->ep_serial);
*errstr = "No PBX Call";
return(1);
}
joinpbx = (class JoinPBX *)join;
relation = joinpbx->j_relation;
- if (!relation)
- {
+ if (!relation) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join has no relation.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
- if (!relation->next)
- {
+ if (!relation->next) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join has no 2nd relation.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
- if (relation->next->next)
- {
+ if (relation->next->next) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join has more than two relations.\n", ea_endpoint->ep_serial);
*errstr = "Err: Conference";
return(1);
}
- if (relation->epoint_id == ea_endpoint->ep_serial)
- {
+ if (relation->epoint_id == ea_endpoint->ep_serial) {
relation = relation->next;
- if (relation->epoint_id == ea_endpoint->ep_serial)
- {
+ if (relation->epoint_id == ea_endpoint->ep_serial) {
PERROR("EPOINT(%d) SOFTWARE ERROR: both join relations are related to our endpoint.\n", ea_endpoint->ep_serial);
*errstr = "Software Error";
return(1);
/* check remote port for external call */
epoint = find_epoint_id(relation->epoint_id);
- if (!epoint)
- {
+ if (!epoint) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join has no 2nd endpoint.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
- if (!epoint->ep_portlist)
- {
+ if (!epoint->ep_portlist) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) 2nd endpoint has not port.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
*port = find_port_id(epoint->ep_portlist->port_id);
- if (!(*port))
- {
+ if (!(*port)) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) 2nd endpoint has an none existing port.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
- if (((*port)->p_type&PORT_CLASS_mISDN_MASK)!=PORT_CLASS_mISDN_DSS1) /* port is not external isdn */
- {
+ if (((*port)->p_type&PORT_CLASS_mISDN_MASK)!=PORT_CLASS_mISDN_DSS1) { /* port is not external isdn */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) 2nd endpoint has not an external port.\n", ea_endpoint->ep_serial);
*errstr = "No Ext Call";
return(1);
}
- if ((*port)->p_state != PORT_STATE_CONNECT)
- {
+ if ((*port)->p_state != PORT_STATE_CONNECT) {
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) 2nd endpoint's port is not in connected state.\n", ea_endpoint->ep_serial);
*errstr = "No Ext Connect";
return(1);
const char *logtext = "unknown";
char buffer[64];
- switch(message_type)
- {
+ switch(message_type) {
case MESSAGE_SETUP:
trace_header("SETUP", dir);
if (dir == DIRECTION_OUT)
if (param->setup.callerinfo.extension[0])
add_trace("extension", NULL, "%s", param->setup.callerinfo.extension);
add_trace("caller id", "number", "%s", numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international));
- switch(param->setup.callerinfo.present)
- {
+ switch(param->setup.callerinfo.present) {
case INFO_PRESENT_RESTRICTED:
add_trace("caller id", "present", "restricted");
break;
default:
add_trace("caller id", "present", "not available");
}
- if (param->setup.callerinfo.ntype2)
- {
+ if (param->setup.callerinfo.ntype2) {
add_trace("caller id2", "number", "%s", numberrize_callerinfo(param->setup.callerinfo.id2, param->setup.callerinfo.ntype2, options.national, options.international));
- switch(param->setup.callerinfo.present)
- {
+ switch(param->setup.callerinfo.present) {
case INFO_PRESENT_RESTRICTED:
add_trace("caller id2", "present", "restricted");
break;
add_trace("caller id2", "present", "not available");
}
}
- if (param->setup.redirinfo.id[0])
- {
+ if (param->setup.redirinfo.id[0]) {
add_trace("redir'ing", "number", "%s", numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
- switch(param->setup.redirinfo.present)
- {
+ switch(param->setup.redirinfo.present) {
case INFO_PRESENT_RESTRICTED:
add_trace("redir'ing", "present", "restricted");
break;
if (param->connectinfo.extension[0])
add_trace("extension", NULL, "%s", param->connectinfo.extension);
add_trace("connect id", "number", "%s", numberrize_callerinfo(param->connectinfo.id, param->connectinfo.ntype, options.national, options.international));
- switch(param->connectinfo.present)
- {
+ switch(param->connectinfo.present) {
case INFO_PRESENT_RESTRICTED:
add_trace("connect id", "present", "restricted");
break;
if (dir == DIRECTION_IN)
add_trace("from", NULL, "CH(%lu)", port_id);
add_trace("cause", "value", "%d", param->disconnectinfo.cause);
- switch(param->disconnectinfo.location)
- {
+ switch(param->disconnectinfo.location) {
case LOCATION_USER:
add_trace("cause", "location", "0-User");
break;
break;
case MESSAGE_NOTIFY:
- switch(param->notifyinfo.notify)
- {
+ switch(param->notifyinfo.notify) {
case 0x00:
logtext = "NULL";
break;
add_trace("from", NULL, "CH(%lu)", port_id);
if (param->notifyinfo.notify)
add_trace("indicator", NULL, "%s", logtext);
- if (param->notifyinfo.id[0])
- {
+ if (param->notifyinfo.id[0]) {
add_trace("redir'on", "number", "%s", numberrize_callerinfo(param->notifyinfo.id, param->notifyinfo.ntype, options.national, options.international));
- switch(param->notifyinfo.present)
- {
+ switch(param->notifyinfo.present) {
case INFO_PRESENT_RESTRICTED:
add_trace("redir'on", "present", "restricted");
break;
add_trace("to", NULL, "CH(%lu)", port_id);
if (dir == DIRECTION_IN)
add_trace("from", NULL, "CH(%lu)", port_id);
- if (param->tone.name[0])
- {
+ if (param->tone.name[0]) {
add_trace("directory", NULL, "%s", param->tone.dir[0]?param->tone.dir:"default");
add_trace("name", NULL, "%s", param->tone.name);
} else
#if 0
case MESSAGE_BCHANNEL:
trace_header("BCHANNEL", dir);
- switch(param->bchannel.type)
- {
+ switch(param->bchannel.type) {
case BCHANNEL_REQUEST:
add_trace("type", NULL, "request");
break;
if (!portlist->port_id)
return;
- if (!e_connectedmode)
- {
+ if (!e_connectedmode) {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_DISCONNECT);
message->param.disconnectinfo.cause = cause;
message->param.disconnectinfo.location = location;
SCPY(message->param.disconnectinfo.display, display);
else
SCPY(message->param.disconnectinfo.display, get_isdn_cause(cause, location, e_ext.display_cause));
- } else
- {
+ } else {
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
if (display[0])
SCPY(message->param.notifyinfo.display, display);
logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
-
#dialmax 20
+# Example of an ISDN interface on port 1, with alternate tones_dir to use.
+# In this case, the tones are "german" tones generated by mISDN_dsp.ko.
+# It is possible to give different sample sets, like "tones_german".
+
+#[Int]
+#extension
+#msn 201,202,203
+#tones_dir german
+#portnum 1
+#nt
+
+
# A special case for GSM interface.
# Don't remove/change the settings, they will cause undefined behaviour
# of LCR. The actual interface is defined in gsm.conf.
#schedule 0
# Use tone sets (default= tones_american).
-# This can be overridden by the extension setting
+# Tones/announcements are streamed from user space. It is possible to use
+# the module "mISDN_dsp.o" instead. It provides simple tones with much less cpu
+# usage. If supported by special hardware, tones are loops that require no
+# bus/cpu load at all, except when the tone changes.
+# Use parameter "american", "german", or "oldgerman". "oldgerman" sounds like
+# the old german telephone system used until end of year 1998.
+# This can be overridden by the the tones_dir in the interface.conf.
+# Both options.conf and interface.conf can be overridden by extension setting.
#tones_dir tones_american
# Fetch tone sets as specified here.
# Default is nothing.
#dummyid 0
-# Tones/announcements are streamed from user space. It is possible to use
-# the module "mISDN_dsp.o" instead. It provides simple tones with much less cpu
-# usage. If supported by special hardware, tones are loops that require no
-# bus/cpu load at all, except when the tone changes.
-# This works only for ISDN ports. It can be overridden by extension's tone set.
-# Defautlt is streaming of tones. Use parameter "american", "german", or
-# "oldgerman". "oldgerman" sounds like the old german telephone system (POTS).
-#dsptones none
-
# Source email address of the LCR. E.g. it is used when sending a mail
# from the voice box. It is not the address the mails are sent to.
# Most mail servers require an existing domain in order to accept mails.
memcpy(&p_dialinginfo, ¶m->setup.dialinginfo, sizeof(p_dialinginfo));
memcpy(&p_capainfo, ¶m->setup.capainfo, sizeof(p_capainfo));
memcpy(&p_redirinfo, ¶m->setup.redirinfo, sizeof(p_redirinfo));
-// SCPY(&p_m_tones_dir, param->setup.ext.tones_dir);
/* screen outgoing caller id */
do_screen(1, p_callerinfo.id, sizeof(p_callerinfo.id), &p_callerinfo.ntype, &p_callerinfo.present, p_m_mISDNport->ifport->interface);
do_screen(1, p_callerinfo.id2, sizeof(p_callerinfo.id2), &p_callerinfo.ntype2, &p_callerinfo.present2, p_m_mISDNport->ifport->interface);
SPRINT(filename, "%s/%s/settings", EXTENSION_DATA, number);
- if (!(fp = fopen(filename, "r")))
- {
+ if (!(fp = fopen(filename, "r"))) {
printf("the given extension doesn't exist: \"%s\"\n", filename);
PDEBUG(DEBUG_CONFIG, "the given extension doesn't exist: \"%s\"\n", filename);
return(0);
ext->vbox_codec = CODEC_MONO;
line=0;
- while((fgets(buffer, sizeof(buffer), fp)))
- {
+ while((fgets(buffer, sizeof(buffer), fp))) {
line++;
buffer[sizeof(buffer)-1] = '\0';
if (buffer[0]) buffer[strlen(buffer)-1] = '\0';
p = buffer;
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
option[0]=0;
i=0; /* read option */
- while(*p > 32)
- {
- if (i+1 >= sizeof(option))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(option)) {
PERROR_RUNTIME("Error in %s (line %d): option too long.\n",filename,line);
break;
}
option[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
param[0]=0;
param2[0]=0;
- if (*p!=0 && *p!='#') /* param */
- {
+ if (*p!=0 && *p!='#') { /* param */
i=0; /* read param */
- while(*p > 32)
- {
- if (i+1 >= sizeof(param))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(param)) {
PERROR_RUNTIME("Error in %s (line %d): param too long.\n",filename,line);
break;
}
param[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
- if (*p!=0 && *p!='#') /* param2 */
- {
+ if (*p!=0 && *p!='#') { /* param2 */
i=0; /* read param2 */
- while(*p >= 32)
- {
- if (i+1 >= sizeof(param2))
- {
+ while(*p >= 32) {
+ if (i+1 >= sizeof(param2)) {
PERROR_RUNTIME("Error in %s (line %d): param too long.\n",filename,line);
break;
}
/* at this point we have option and param */
/* check option */
- if (!strcmp(option,"name"))
- {
+ if (!strcmp(option,"name")) {
SCPY(ext->name, param);
- if (param2[0])
- {
+ if (param2[0]) {
SCAT(ext->name, (char *)" ");
SCAT(ext->name, param2);
}
PDEBUG(DEBUG_CONFIG, "name of extension: %s\n",param);
} else
- if (!strcmp(option,"prefix"))
- {
+ if (!strcmp(option,"prefix")) {
SCPY(ext->prefix, param);
PDEBUG(DEBUG_CONFIG, "dial prefix on pickup: %s\n",param);
} else
- if (!strcmp(option,"next"))
- {
+ if (!strcmp(option,"next")) {
SCPY(ext->next, param);
PDEBUG(DEBUG_CONFIG, "dial next on pickup: %s\n",param);
} else
- if (!strcmp(option,"alarm"))
- {
+ if (!strcmp(option,"alarm")) {
SCPY(ext->alarm, param);
PDEBUG(DEBUG_CONFIG, "alarm message (if prefix): %s\n",param);
} else
- if (!strcmp(option,"cfu"))
- {
+ if (!strcmp(option,"cfu")) {
SCPY(ext->cfu, param);
PDEBUG(DEBUG_CONFIG, "call forward unconditional: %s\n",param);
} else
- if (!strcmp(option,"cfb"))
- {
+ if (!strcmp(option,"cfb")) {
SCPY(ext->cfb, param);
PDEBUG(DEBUG_CONFIG, "call forward when busy: %s\n",param);
} else
- if (!strcmp(option,"cfnr"))
- {
+ if (!strcmp(option,"cfnr")) {
SCPY(ext->cfnr, param);
PDEBUG(DEBUG_CONFIG, "call forward on no response: %s\n",param);
} else
- if (!strcmp(option,"cfnr_delay"))
- {
+ if (!strcmp(option,"cfnr_delay")) {
ext->cfnr_delay = atoi(param);
if (ext->cfnr_delay < 0)
ext->cfnr_delay = 1;
PDEBUG(DEBUG_CONFIG, "call forward no response delay: %d\n",ext->cfnr_delay);
} else
- if (!strcmp(option,"cfp"))
- {
+ if (!strcmp(option,"cfp")) {
SCPY(ext->cfp, param);
PDEBUG(DEBUG_CONFIG, "call forward parallel: %s\n",param);
} else
- if (!strcmp(option,"change_forward"))
- {
+ if (!strcmp(option,"change_forward")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->change_forward = i;
PDEBUG(DEBUG_CONFIG, "allow the change of forwarding: %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "unknown parameter for change_forward: %s\n", param);
}
} else
- if (!strcmp(option,"interfaces"))
- {
+ if (!strcmp(option,"interfaces")) {
SCPY(ext->interfaces, param);
PDEBUG(DEBUG_CONFIG, "interfaces to ring calls to extension: %s %s\n",param,param2);
} else
- if (!strcmp(option,"callerid"))
- {
+ if (!strcmp(option,"callerid")) {
ext->callerid_present = INFO_PRESENT_ALLOWED;
if (!strncasecmp(param2, "anonymous", 9))
ext->callerid_present = INFO_PRESENT_RESTRICTED;
- if (!strncasecmp(param, "non", 3))
- {
+ if (!strncasecmp(param, "non", 3)) {
ext->callerid[0] = '\0';
ext->callerid_present = INFO_PRESENT_NOTAVAIL;
ext->callerid_type = INFO_NTYPE_UNKNOWN;
PDEBUG(DEBUG_CONFIG, "caller id: ID NOT AVAILABLE\n");
} else
- switch(param[0])
- {
+ switch(param[0]) {
case 'i':
case 'I':
ext->callerid_type = INFO_NTYPE_INTERNATIONAL;
}
ext->callerid[sizeof(ext->callerid)-1] = 0;
} else
- if (!strcmp(option,"id_next_call"))
- {
+ if (!strcmp(option,"id_next_call")) {
ext->id_next_call_present = INFO_PRESENT_ALLOWED;
if (!strncasecmp(param2, "anonymous", 9))
ext->id_next_call_present = INFO_PRESENT_RESTRICTED;
- if (param[0] == '\0')
- {
+ if (param[0] == '\0') {
ext->id_next_call_present = -1;
PDEBUG(DEBUG_CONFIG, "id next call: no id for next call\n");
} else
- if (!strncasecmp(param, "none", 3))
- {
+ if (!strncasecmp(param, "none", 3)) {
ext->id_next_call[0] = '\0';
ext->id_next_call_present = INFO_PRESENT_NOTAVAIL;
ext->id_next_call_type = INFO_NTYPE_UNKNOWN;
PDEBUG(DEBUG_CONFIG, "id next call: ID NOT AVAILABLE\n");
} else
- switch(param[0])
- {
+ switch(param[0]) {
case 'i':
case 'I':
ext->id_next_call_type = INFO_NTYPE_INTERNATIONAL;
} else
- if (!strcmp(option,"change_callerid"))
- {
+ if (!strcmp(option,"change_callerid")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->change_callerid = i;
PDEBUG(DEBUG_CONFIG, "allow the change of caller id: %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "unknown parameter for change_callerid: %s\n", param);
}
} else
- if (!strcmp(option,"anon-ignore"))
- {
+ if (!strcmp(option,"anon-ignore")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->anon_ignore = i;
PDEBUG(DEBUG_CONFIG, "ignore restriction of CLIP & COLP %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "unknown parameter given anon-ignore: %s\n", param);
}
} else
- if (!strcmp(option,"clip"))
- {
+ if (!strcmp(option,"clip")) {
if (!strcasecmp(param, "hide"))
ext->clip = CLIP_HIDE;
else
PDEBUG(DEBUG_CONFIG, "clip: %d\n",ext->clip);
} else
- if (!strcmp(option,"colp"))
- {
+ if (!strcmp(option,"colp")) {
if (!strcasecmp(param, "hide"))
ext->colp = COLP_HIDE;
else if (!strcasecmp(param, "force"))
PDEBUG(DEBUG_CONFIG, "colp: %d\n",ext->colp);
} else
- if (!strcmp(option,"clip_prefix"))
- {
+ if (!strcmp(option,"clip_prefix")) {
SCPY(ext->clip_prefix, param);
PDEBUG(DEBUG_CONFIG, "clip prefix: %s\n",param);
} else
- if (!strcmp(option,"keypad"))
- {
+ if (!strcmp(option,"keypad")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->keypad = i;
PDEBUG(DEBUG_CONFIG, "use keypad to do call control %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "unknown parameter given keypad: %s\n", param);
}
} else
- if (!strcmp(option,"rights"))
- {
+ if (!strcmp(option,"rights")) {
i=0;
- while(ext_rights[i])
- {
+ while(ext_rights[i]) {
if (!strcasecmp(param,ext_rights[i]))
break;
i++;
}
- if (ext_rights[i])
- {
+ if (ext_rights[i]) {
ext->rights = i;
PDEBUG(DEBUG_CONFIG, "rights to dial: %s\n", ext_rights[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given rights unknown: %s\n", param);
}
} else
- if (!strcmp(option,"delete_ext"))
- {
+ if (!strcmp(option,"delete_ext")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->delete_ext = i;
PDEBUG(DEBUG_CONFIG, "enables the delete key function for external calls: %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "unknown parameter given delete: %s\n", param);
}
} else
- if (!strcmp(option,"noknocking"))
- {
+ if (!strcmp(option,"noknocking")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->noknocking = i;
PDEBUG(DEBUG_CONFIG, "noknocking %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given noknocking param unknown: %s\n", param);
}
} else
if (!strcmp(option,"rx_gain")
- || !strcmp(option,"rxvol"))
- {
+ || !strcmp(option,"rxvol")) {
ext->rx_gain = atoi(param);
if (ext->rx_gain<-8 || ext->rx_gain>8)
ext->rx_gain = 0;
PDEBUG(DEBUG_CONFIG, "receive volume: %d\n",ext->rx_gain);
} else
if (!strcmp(option,"tx_gain")
- || !strcmp(option,"txvol"))
- {
+ || !strcmp(option,"txvol")) {
ext->tx_gain = atoi(param);
if (ext->tx_gain<-8 || ext->tx_gain>8)
ext->tx_gain = 0;
PDEBUG(DEBUG_CONFIG, "transmit volume: %d\n",ext->tx_gain);
} else
- if (!strcmp(option,"own_setup"))
- {
+ if (!strcmp(option,"own_setup")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->own_setup = i;
PDEBUG(DEBUG_CONFIG, "own_setup %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given own_setup param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"own_proceeding"))
- {
+ if (!strcmp(option,"own_proceeding")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->own_proceeding = i;
PDEBUG(DEBUG_CONFIG, "own_proceeding %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given own_proceeding param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"own_alerting"))
- {
+ if (!strcmp(option,"own_alerting")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->own_alerting = i;
PDEBUG(DEBUG_CONFIG, "own_alerting %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given own_alerting param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"own_cause"))
- {
+ if (!strcmp(option,"own_cause")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->own_cause = i;
PDEBUG(DEBUG_CONFIG, "own_cause %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given own_cause param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"facility"))
- {
+ if (!strcmp(option,"facility")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->facility = i;
PDEBUG(DEBUG_CONFIG, "facility %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given facility param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"display_cause"))
- {
+ if (!strcmp(option,"display_cause")) {
if (!strcasecmp(param, "german"))
ext->display_cause = DISPLAY_CAUSE_GERMAN;
else if (!strcasecmp(param, "english"))
PDEBUG(DEBUG_CONFIG, "display cause: %d\n",ext->display_cause);
} else
#if 0
- if (!strcmp(option,"display_ext"))
- {
+ if (!strcmp(option,"display_ext")) {
if (!strcasecmp(param, "number"))
ext->display_ext = DISPLAY_CID_NUMBER;
else if (!strcasecmp(param, "abbrev"))
PDEBUG(DEBUG_CONFIG, "display ext: %d\n",ext->display_ext);
} else
#endif
- if (!strcmp(option,"display_ext"))
- {
+ if (!strcmp(option,"display_ext")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->display_ext = i;
PDEBUG(DEBUG_CONFIG, "display ext %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given display_ext param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"display_int"))
- {
+ if (!strcmp(option,"display_int")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->display_int = i;
PDEBUG(DEBUG_CONFIG, "display int %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given display_int param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"display_fake"))
- {
+ if (!strcmp(option,"display_fake")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->display_fake = i;
PDEBUG(DEBUG_CONFIG, "display fake caller ids %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given display_fake param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"display_anon"))
- {
+ if (!strcmp(option,"display_anon")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->display_anon = i;
PDEBUG(DEBUG_CONFIG, "display anonymouse ids %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given display_anon param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"display_menu"))
- {
+ if (!strcmp(option,"display_menu")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->display_menu = i;
PDEBUG(DEBUG_CONFIG, "display menu %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given display_menu param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"display_dialing"))
- {
+ if (!strcmp(option,"display_dialing")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->display_dialing = i;
PDEBUG(DEBUG_CONFIG, "display dialing %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given display_dialing param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"display_name"))
- {
+ if (!strcmp(option,"display_name")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->display_name = i;
PDEBUG(DEBUG_CONFIG, "display name %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given display_name param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"tones_dir"))
- {
+ if (!strcmp(option,"tones_dir")) {
if (param[strlen(param)-1] == '/')
param[strlen(param)-1]=0;
SCPY(ext->tones_dir, param);
PDEBUG(DEBUG_CONFIG, "directory of tones: %s\n",param);
} else
- if (!strcmp(option,"record"))
- {
+ if (!strcmp(option,"record")) {
if (!strcasecmp(param, "mono"))
ext->record = CODEC_MONO;
else if (!strcasecmp(param, "stereo"))
ext->record = CODEC_OFF;
PDEBUG(DEBUG_CONFIG, "given record param: %s\n", param);
} else
- if (!strcmp(option,"password"))
- {
+ if (!strcmp(option,"password")) {
SCPY(ext->password, param);
PDEBUG(DEBUG_CONFIG, "password: %s\n",param);
} else
- if (!strcmp(option,"vbox_mode"))
- {
+ if (!strcmp(option,"vbox_mode")) {
if (!strcasecmp(param, "parallel"))
ext->vbox_mode = VBOX_MODE_PARALLEL;
else if (!strcasecmp(param, "announcement"))
ext->vbox_mode = VBOX_MODE_NORMAL;
PDEBUG(DEBUG_CONFIG, "given vbox mode: %s\n", param);
} else
- if (!strcmp(option,"vbox_codec"))
- {
+ if (!strcmp(option,"vbox_codec")) {
if (!strcasecmp(param, "stereo"))
ext->vbox_codec = CODEC_STEREO;
else if (!strcasecmp(param, "8bit"))
ext->vbox_codec = CODEC_MONO;
PDEBUG(DEBUG_CONFIG, "given record param: %s\n", param);
} else
- if (!strcmp(option,"vbox_time"))
- {
+ if (!strcmp(option,"vbox_time")) {
ext->vbox_time = atoi(param);
if (ext->vbox_time < 0)
ext->vbox_time = 0;
PDEBUG(DEBUG_CONFIG, "vbox time to record: %d\n",ext->vbox_time);
} else
- if (!strcmp(option,"vbox_display"))
- {
+ if (!strcmp(option,"vbox_display")) {
if (!strcasecmp(param, "detailed")
|| !strcasecmp(param, "detailled"))
ext->vbox_display = VBOX_DISPLAY_DETAILED;
ext->vbox_display = VBOX_DISPLAY_BRIEF;
PDEBUG(DEBUG_CONFIG, "given vbox mode: %s\n", param);
} else
- if (!strcmp(option,"vbox_language"))
- {
+ if (!strcmp(option,"vbox_language")) {
if (!strcasecmp(param, "german"))
ext->vbox_language = VBOX_LANGUAGE_GERMAN;
else
ext->vbox_language = VBOX_LANGUAGE_ENGLISH;
PDEBUG(DEBUG_CONFIG, "given vbox mode: %s\n", param);
} else
- if (!strcmp(option,"vbox_email"))
- {
+ if (!strcmp(option,"vbox_email")) {
SCPY(ext->vbox_email, param);
PDEBUG(DEBUG_CONFIG, "given vbox email: %s\n", param);
} else
- if (!strcmp(option,"vbox_email_file"))
- {
+ if (!strcmp(option,"vbox_email_file")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->vbox_email_file = i;
PDEBUG(DEBUG_CONFIG, "attach audio file %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given vbox_email_file param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"vbox_free"))
- {
+ if (!strcmp(option,"vbox_free")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->vbox_free = i;
PDEBUG(DEBUG_CONFIG, "vbox_free %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given vbox_free param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"last_in"))
- {
- if (param[0] && last_in_count<MAX_REMEMBER)
- {
+ if (!strcmp(option,"last_in")) {
+ if (param[0] && last_in_count<MAX_REMEMBER) {
SCPY(ext->last_in[last_in_count], param);
last_in_count++;
}
PDEBUG(DEBUG_CONFIG, "last_in dialed number: %s\n",param);
} else
- if (!strcmp(option,"last_out"))
- {
- if (param[0] && last_out_count<MAX_REMEMBER)
- {
+ if (!strcmp(option,"last_out")) {
+ if (param[0] && last_out_count<MAX_REMEMBER) {
SCPY(ext->last_out[last_out_count], param);
last_out_count++;
}
PDEBUG(DEBUG_CONFIG, "last_out dialed number: %s\n",param);
} else
- if (!strcmp(option,"datacall"))
- {
+ if (!strcmp(option,"datacall")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->datacall = i;
PDEBUG(DEBUG_CONFIG, "datacall %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "given datacall param unknown: %s\n", param);
}
} else
- if (!strcmp(option,"seconds"))
- {
+ if (!strcmp(option,"seconds")) {
i=0;
- while(ext_yesno[i])
- {
+ while(ext_yesno[i]) {
if (!strcasecmp(param,ext_yesno[i]))
break;
i++;
}
- if (ext_yesno[i])
- {
+ if (ext_yesno[i]) {
ext->no_seconds = 1-i;
PDEBUG(DEBUG_CONFIG, "seconds %s\n", ext_yesno[i]);
- } else
- {
+ } else {
PDEBUG(DEBUG_CONFIG, "unknown param for seconds: %s\n", param);
}
- } else
- {
+ } else {
PERROR_RUNTIME("Error in %s (line %d): wrong option keyword %s.\n",filename,line,option);
}
}
SPRINT(filename, "%s/%s/settings", EXTENSION_DATA, number);
- if (!(fp = fopen(filename, "w")))
- {
+ if (!(fp = fopen(filename, "w"))) {
PERROR("Cannot open settings: \"%s\"\n", filename);
return(0);
}
fprintf(fp,"# use prefix 's' for TYPE SUBSCRIBER (s<local number>)\n");
if (ext->callerid_present == INFO_PRESENT_NOTAVAIL)
fprintf(fp,"callerid none\n\n");
- else
- {
- switch(ext->callerid_type)
- {
+ else {
+ switch(ext->callerid_type) {
case INFO_NTYPE_INTERNATIONAL:
fprintf(fp,"callerid i%s%s\n\n",ext->callerid, (ext->callerid_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
break;
fprintf(fp,"id_next_call \n\n");
else if (ext->id_next_call_present == INFO_PRESENT_NOTAVAIL)
fprintf(fp,"id_next_call none\n\n");
- else
- {
- switch(ext->id_next_call_type)
- {
+ else {
+ switch(ext->id_next_call_type) {
case INFO_NTYPE_INTERNATIONAL:
fprintf(fp,"id_next_call i%s%s\n\n",ext->id_next_call, (ext->id_next_call_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
break;
fprintf(fp,"# clip (asis|hide)\n");
fprintf(fp,"# asis: On forwarded calls the CLIP is used as presented by the calling party.\n");
fprintf(fp,"# hide: Always use extension's caller id, even on forwared calls.\n");
- switch(ext->clip)
- {
+ switch(ext->clip) {
case CLIP_HIDE:
fprintf(fp,"clip hide\n\n");
break;
fprintf(fp,"# On forwarded calls the COLP is used as presented by the called party.\n");
fprintf(fp,"# hide: Always use extension's caller id, even on forwared calls.\n");
fprintf(fp,"# force: If COLP is not presented by forwarded calls the dialed number is used.\n");
- switch(ext->colp)
- {
+ switch(ext->colp) {
case COLP_HIDE:
fprintf(fp,"colp hide\n\n");
break;
fprintf(fp,"# number (display cause number only)\n");
fprintf(fp,"# english-location (display cause text in english and location)\n");
fprintf(fp,"# german-location (display cause text in german and location)\n");
- switch(ext->display_cause)
- {
+ switch(ext->display_cause) {
case DISPLAY_CAUSE_ENGLISH:
fprintf(fp,"display_cause english\n\n");
break;
fprintf(fp,"display_dialing %s\n\n",(ext->display_dialing)?"yes":"no");
fprintf(fp,"# Tones directory for announcements and patterns\n");
- fprintf(fp,"# Enter nothing for default tones as selected by options.conf.\n");
+ fprintf(fp,"# Enter nothing for default tones as selected by options.conf or interface.conf.\n");
fprintf(fp,"tones_dir %s\n\n",ext->tones_dir);
fprintf(fp,"# Record calls to extension's directory. The file is written as wave.\n");
fprintf(fp,"# stereo (records wave 32 bit stereo, 256kbits/s)\n");
fprintf(fp,"# 8bit (records wave 8 bit mono, 64kbits/s)\n");
fprintf(fp,"# law (records xLaw encoded, as specified in options.conf, 64kbps/s)\n");
- switch(ext->record)
- {
+ switch(ext->record) {
case CODEC_MONO:
fprintf(fp,"record mono\n\n");
break;
fprintf(fp,"# normal (plays announcement and records after that)\n");
fprintf(fp,"# parallel (plays announcement and records also DURING announcement.)\n");
fprintf(fp,"# announcement (just plays announcement and hangs up)\n");
- switch(ext->vbox_mode)
- {
+ switch(ext->vbox_mode) {
case VBOX_MODE_PARALLEL:
fprintf(fp,"vbox_mode parallel\n\n");
break;
fprintf(fp,"# mono (16 bit mono wave file)\n");
fprintf(fp,"# stereo (16 bit stereo wave file)\n");
fprintf(fp,"# 8bit (8 bit mono wave file)\n");
- switch(ext->vbox_codec)
- {
+ switch(ext->vbox_codec) {
case CODEC_LAW:
fprintf(fp,"vbox_codec law\n\n");
break;
fprintf(fp,"# brief (displays brief information, for small displays)\n");
fprintf(fp,"# detailed (displays detailed information, for larger displays)\n");
fprintf(fp,"# off (don't display anything)\n");
- switch(ext->vbox_display)
- {
+ switch(ext->vbox_display) {
case VBOX_DISPLAY_OFF:
fprintf(fp,"vbox_display off\n\n");
break;
fprintf(fp,"# Last outgoing and incoming numbers (including prefix)\n");
i = 0;
- while(i < MAX_REMEMBER)
- {
+ while(i < MAX_REMEMBER) {
if (ext->last_out[i][0])
fprintf(fp,"last_out %s\n",ext->last_out[i]);
i++;
}
i = 0;
- while(i < MAX_REMEMBER)
- {
+ while(i < MAX_REMEMBER) {
if (ext->last_in[i][0])
fprintf(fp,"last_in %s\n",ext->last_in[i]);
i++;
SPRINT(filename, "%s/%s/log", EXTENSION_DATA, number);
- if (!(fp = fopen(filename, "a")))
- {
+ if (!(fp = fopen(filename, "a"))) {
PERROR("Cannot open log: \"%s\"\n", filename);
return(0);
}
SPRINT(filename, "%s/%s/phonebook", EXTENSION_DATA, number);
- if (!(fp = fopen(filename, "r")))
- {
+ if (!(fp = fopen(filename, "r"))) {
PERROR("Cannot open phonebook: \"%s\"\n", filename);
return(0);
}
line=0;
- while((fgets(buffer, sizeof(buffer), fp)))
- {
+ while((fgets(buffer, sizeof(buffer), fp))) {
line++;
buffer[sizeof(buffer)-1] = '\0';
if (buffer[0]) buffer[strlen(buffer)-1] = '\0';
p = buffer;
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
name[0]=0;
i=0; /* read abbrev */
- while(*p > 32)
- {
- if (i+1 >= sizeof(abbrev))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(abbrev)) {
PERROR_RUNTIME("Error in %s (line %d): abbrev too long.\n",filename,line);
break;
}
abbrev[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
- if (*p!=0 && *p!='#') /* phone */
- {
+ if (*p!=0 && *p!='#') { /* phone */
i=0; /* read phone */
- while(*p > 32)
- {
- if (i+1 >= sizeof(phone))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(phone)) {
PERROR_RUNTIME("Error in %s (line %d): phone too long.\n",filename,line);
break;
}
phone[i+1] = '\0';
phone[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
}
- if (*p!=0 && *p!='#') /* name */
- {
+ if (*p!=0 && *p!='#') { /* name */
i=0; /* read name */
- while(*p > 0)
- {
- if (i+1 >= sizeof(name))
- {
+ while(*p > 0) {
+ if (i+1 >= sizeof(name)) {
PERROR_RUNTIME("Error in %s (line %d): name too long.\n",filename,line);
break;
}
}
}
- if (*abbrev_pointer)
- {
- if (!strncmp(*abbrev_pointer, abbrev, strlen(*abbrev_pointer)))
- {
+ if (*abbrev_pointer) {
+ if (!strncmp(*abbrev_pointer, abbrev, strlen(*abbrev_pointer))) {
/* may match if abbreviation is longer */
found_if_more_digits = 1;
}
if (fp) fclose(fp);
- if (found)
- {
+ if (found) {
*abbrev_pointer = abbrev;
*phone_pointer = phone;
*name_pointer = name;
}
- if (found == 0)
- {
+ if (found == 0) {
if (found_if_more_digits)
found = -1;
}
SPRINT(filename, "%s/%s/secrets", EXTENSION_DATA, number);
- if (!(fp = fopen(filename, "r")))
- {
+ if (!(fp = fopen(filename, "r"))) {
PERROR("Cannot open secrets: \"%s\"\n", filename);
return(0);
}
line=0;
- while((fgets(buffer, sizeof(buffer), fp)))
- {
+ while((fgets(buffer, sizeof(buffer), fp))) {
line++;
buffer[sizeof(buffer)-1] = '\0';
if (buffer[0]) buffer[strlen(buffer)-1] = '\0';
p = buffer;
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
key[0]=0;
i=0; /* read auth */
- while(*p > 32)
- {
- if (i+1 >= sizeof(remote))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(remote)) {
PERROR_RUNTIME("Error in %s (line %d): remote too long.\n",filename,line);
break;
}
remote[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
- if (*p!=0 && *p!='#') /* auth */
- {
+ if (*p!=0 && *p!='#') { /* auth */
i=0; /* read auth */
- while(*p > 32)
- {
- if (i+1 >= sizeof(auth))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(auth)) {
PERROR_RUNTIME("Error in %s (line %d): auth too long.\n",filename,line);
break;
}
auth[i+1] = '\0';
auth[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
}
- if (*p!=0 && *p!='#') /* crypt */
- {
+ if (*p!=0 && *p!='#') { /* crypt */
i=0; /* read crypt */
- while(*p > 32)
- {
- if (i+1 >= sizeof(crypt))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(crypt)) {
PERROR_RUNTIME("Error in %s (line %d): crypt too long.\n",filename,line);
break;
}
crypt[i+1] = '\0';
crypt[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
}
- if (*p!=0 && *p!='#') /* key */
- {
+ if (*p!=0 && *p!='#') { /* key */
i=0; /* read key */
- while(*p > 0)
- {
- if (i+1 >= sizeof(key))
- {
+ while(*p > 0) {
+ if (i+1 >= sizeof(key)) {
PERROR_RUNTIME("Error in %s (line %d): key too long.\n",filename,line);
break;
}
if (fp) fclose(fp);
- if (found)
- {
+ if (found) {
*auth_pointer = auth;
*crypt_pointer = crypt;
*key_pointer = key;
SPRINT(filename, "%s/directory.list", CONFIG_DATA);
- if (!(fp = fopen(filename, "r")))
- {
+ if (!(fp = fopen(filename, "r"))) {
PERROR("Cannot open directory: \"%s\"\n", filename);
return(NULL);
}
line=0;
- while((fgets(buffer, sizeof(buffer), fp)))
- {
+ while((fgets(buffer, sizeof(buffer), fp))) {
line++;
buffer[sizeof(buffer)-1] = '\0';
if (buffer[0]) buffer[strlen(buffer)-1] = '\0';
p = buffer;
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
name[0]=0;
i=0; /* read number */
- while(*p > 32)
- {
- if (i+1 >= sizeof(phone))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(phone)) {
PERROR_RUNTIME("Error in %s (line %d): number too long.\n",filename,line);
break;
}
phone[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
i=0; /* read name */
- while(*p >= 32)
- {
- if (i+1 >= sizeof(name))
- {
+ while(*p >= 32) {
+ if (i+1 >= sizeof(name)) {
PERROR_RUNTIME("Error in %s (line %d): name too long.\n",filename,line);
break;
}
name[i++] = *p++;
}
- if (phone[0] == 'i')
- {
+ if (phone[0] == 'i') {
if (type != INFO_NTYPE_INTERNATIONAL)
continue;
- if (!strcmp(number, phone+1))
- {
+ if (!strcmp(number, phone+1)) {
found = 1;
break;
}
continue;
}
- if (phone[0] == 'n')
- {
+ if (phone[0] == 'n') {
if (type != INFO_NTYPE_NATIONAL)
continue;
- if (!strcmp(number, phone+1))
- {
+ if (!strcmp(number, phone+1)) {
found = 1;
break;
}
continue;
}
- if (phone[0] == 's')
- {
+ if (phone[0] == 's') {
if (type==INFO_NTYPE_NATIONAL || type==INFO_NTYPE_INTERNATIONAL)
continue;
- if (!strcmp(number, phone+1))
- {
+ if (!strcmp(number, phone+1)) {
found = 1;
break;
}
continue;
}
- if (!strncmp(phone, options.international, strlen(options.international)))
- {
+ if (!strncmp(phone, options.international, strlen(options.international))) {
if (type != INFO_NTYPE_INTERNATIONAL)
continue;
- if (!strcmp(number, phone+strlen(options.international)))
- {
+ if (!strcmp(number, phone+strlen(options.international))) {
found = 1;
break;
}
continue;
}
- if (!options.national[0]) /* no national prefix */
- {
+ if (!options.national[0]) { /* no national prefix */
if (type == INFO_NTYPE_INTERNATIONAL)
continue;
- if (!strcmp(number, phone))
- {
+ if (!strcmp(number, phone)) {
found = 1;
break;
}
continue;
}
- if (!strncmp(phone, options.national, strlen(options.national)))
- {
+ if (!strncmp(phone, options.national, strlen(options.national))) {
if (type != INFO_NTYPE_NATIONAL)
continue;
- if (!strcmp(number, phone+strlen(options.national)))
- {
+ if (!strcmp(number, phone+strlen(options.national))) {
found = 1;
break;
}
}
if (type==INFO_NTYPE_NATIONAL || type==INFO_NTYPE_INTERNATIONAL)
continue;
- if (!strcmp(number, phone))
- {
+ if (!strcmp(number, phone)) {
found = 1;
break;
}
SPRINT(filename, "%s/%s/callbackauth", EXTENSION_DATA, number);
- if (!(fp = fopen(filename, "r")))
- {
+ if (!(fp = fopen(filename, "r"))) {
PDEBUG(DEBUG_EPOINT, "Cannot open callbackauth: \"%s\"\n", filename);
return(0);
}
line=0;
- while((fgets(buffer, sizeof(buffer), fp)))
- {
+ while((fgets(buffer, sizeof(buffer), fp))) {
line++;
buffer[sizeof(buffer)-1] = '\0';
if (buffer[0]) buffer[strlen(buffer)-1] = '\0';
p = buffer;
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
caller_id[0]=0;
i=0; /* read caller_type */
- while(*p > 32)
- {
- if (i+1 >= sizeof(caller_type))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(caller_type)) {
PERROR_RUNTIME("Error in %s (line %d): caller_type too long.\n",filename,line);
break;
}
caller_type[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
- if (*p!=0 && *p!='#') /* caller_id */
- {
+ if (*p!=0 && *p!='#') { /* caller_id */
i=0; /* read caller_id */
- while(*p > 32)
- {
- if (i+1 >= sizeof(caller_id))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(caller_id)) {
PERROR_RUNTIME("Error in %s (line %d): caller_id too long.\n",filename,line);
break;
}
SPRINT(filename, "%s/%s/callbackauth", EXTENSION_DATA, number);
- if (callerinfo->id[0]=='\0')
- {
+ if (callerinfo->id[0]=='\0') {
PERROR("caller has no id.\n");
return;
}
- if (!(fp = fopen(filename, "a")))
- {
+ if (!(fp = fopen(filename, "a"))) {
PERROR("Cannot open callbackauth: \"%s\"\n", filename);
return;
}
/* modify lchan to GSM codec V1 */
gsm_trace_header(p_m_mISDNport, this, MNCC_LCHAN_MODIFY, DIRECTION_OUT);
- end_trace();
mode = create_mncc(MNCC_LCHAN_MODIFY, p_m_g_callref);
mode->lchan_mode = 0x01; /* GSM V1 */
add_trace("mode", NULL, "0x%02x", mode->lchan_mode);
send_and_free_mncc(gsm->network, mode->msg_type, mode);
+ end_trace();
}
case MNCC_REL_IND:
case MNCC_REL_CNF:
+ case MNCC_REJ_IND:
pgsm->rel_ind(msg_type, callref, mncc);
break;
ifport->out_channel = selchannel;
/* additional channel selection for multipoint NT ports */
- if (!ifport->mISDNport->ptp && ifport->mISDNport->ntmode)
- {
+ if (!ifport->mISDNport->ptp && ifport->mISDNport->ntmode) {
selchannelp = &(selchannel->next);
selchannel = (struct select_channel *)MALLOC(sizeof(struct select_channel));
memuse++;
* and return pointer to next element in buffer */
static char *get_seperated(char *buffer)
{
- while(*buffer)
- {
- if (*buffer==',' || *buffer<=32) /* seperate */
- {
+ while(*buffer) {
+ if (*buffer==',' || *buffer<=32) { /* seperate */
*buffer++ = '\0';
while((*buffer>'\0' && *buffer<=32) || *buffer==',')
buffer++;
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
while(ifport->next)
ifport = ifport->next;
/* add value */
- if (value[0])
- {
+ if (value[0]) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects no value.\n", filename, line, parameter);
return(-1);
}
}
static int inter_extension(struct interface *interface, char *filename, int line, char *parameter, char *value)
{
- if (value[0])
- {
+ if (value[0]) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects no value.\n", filename, line, parameter);
return(-1);
}
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
- if (interface->ifport->ptmp)
- {
+ if (interface->ifport->ptmp) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' previously ptmp was given.\n", filename, line, parameter);
return(-1);
}
while(ifport->next)
ifport = ifport->next;
/* add value */
- if (value[0])
- {
+ if (value[0]) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects no value.\n", filename, line, parameter);
return(-1);
}
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
- if (interface->ifport->ptp)
- {
+ if (interface->ifport->ptp) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' previously ptp was given.\n", filename, line, parameter);
return(-1);
}
while(ifport->next)
ifport = ifport->next;
/* add value */
- if (value[0])
- {
+ if (value[0]) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects no value.\n", filename, line, parameter);
return(-1);
}
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
while(ifport->next)
ifport = ifport->next;
/* add value */
- if (value[0])
- {
+ if (value[0]) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects no value.\n", filename, line, parameter);
return(-1);
}
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
while(ifport->next)
ifport = ifport->next;
/* add value */
- if (value[0])
- {
+ if (value[0]) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects no value.\n", filename, line, parameter);
return(-1);
}
}
static int inter_tones(struct interface *interface, char *filename, int line, char *parameter, char *value)
{
- if (!strcasecmp(value, "yes"))
- {
+ if (!strcasecmp(value, "yes")) {
interface->is_tones = IS_YES;
} else
- if (!strcasecmp(value, "no"))
- {
+ if (!strcasecmp(value, "no")) {
interface->is_tones = IS_NO;
- } else
- {
+ } else {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects value 'yes' or 'no'.\n", filename, line, parameter);
return(-1);
}
}
static int inter_earlyb(struct interface *interface, char *filename, int line, char *parameter, char *value)
{
- if (!strcasecmp(value, "yes"))
- {
+ if (!strcasecmp(value, "yes")) {
interface->is_earlyb = IS_YES;
} else
- if (!strcasecmp(value, "no"))
- {
+ if (!strcasecmp(value, "no")) {
interface->is_earlyb = IS_NO;
- } else
- {
+ } else {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects value 'yes' or 'no'.\n", filename, line, parameter);
return(-1);
}
}
static int inter_hunt(struct interface *interface, char *filename, int line, char *parameter, char *value)
{
- if (!strcasecmp(value, "linear"))
- {
+ if (!strcasecmp(value, "linear")) {
interface->hunt = HUNT_LINEAR;
} else
- if (!strcasecmp(value, "roundrobin"))
- {
+ if (!strcasecmp(value, "roundrobin")) {
interface->hunt = HUNT_ROUNDROBIN;
- } else
- {
+ } else {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects value 'linear' or 'roundrobin'.\n", filename, line, parameter);
return(-1);
}
int val;
val = get_number(value);
- if (val == -1)
- {
+ if (val == -1) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects one numeric value.\n", filename, line, parameter);
return(-1);
}
/* check for port already assigned */
searchif = interface_newlist;
- while(searchif)
- {
+ while(searchif) {
ifport = searchif->ifport;
- while(ifport)
- {
- if (ifport->portnum == val)
- {
+ while(ifport) {
+ if (ifport->portnum == val) {
SPRINT(interface_error, "Error in %s (line %d): port '%d' already used above.\n", filename, line, val);
return(-1);
}
/* check for port already assigned */
searchif = interface_newlist;
- while(searchif)
- {
+ while(searchif) {
ifport = searchif->ifport;
- while(ifport)
- {
- if (!strcasecmp(ifport->portname, value))
- {
+ while(ifport) {
+ if (!strcasecmp(ifport->portname, value)) {
SPRINT(interface_error, "Error in %s (line %d): port '%s' already used above.\n", filename, line, value);
return(-1);
}
/* check for use as GSM */
- if (ifport->gsm)
- {
+ if (ifport->gsm) {
SPRINT(interface_error, "Error in %s (line %d): Interface already used for GSM.\n", filename, line);
return(-1);
}
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
ifport = interface->ifport;
while(ifport->next)
ifport = ifport->next;
- if (!strcmp(value, "yes"))
- {
+ if (!strcmp(value, "yes")) {
ifport->l1hold = 1;
} else
- if (!strcmp(value, "no"))
- {
+ if (!strcmp(value, "no")) {
ifport->l1hold = 0;
- } else
- {
+ } else {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expecting parameter 'yes' or 'no'.\n", filename, line, parameter);
return(-1);
}
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
ifport = interface->ifport;
while(ifport->next)
ifport = ifport->next;
- if (!strcmp(value, "yes"))
- {
+ if (!strcmp(value, "yes")) {
ifport->l2hold = 1;
} else
- if (!strcmp(value, "no"))
- {
+ if (!strcmp(value, "no")) {
ifport->l2hold = -1;
- } else
- {
+ } else {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expecting parameter 'yes' or 'no'.\n", filename, line, parameter);
return(-1);
}
char *p, *el;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
while(ifport->next)
ifport = ifport->next;
p = value;
- while(*p)
- {
+ while(*p) {
el = p;
p = get_seperated(p);
- if (!strcasecmp(el, "force"))
- {
+ if (!strcasecmp(el, "force")) {
ifport->channel_force = 1;
- if (ifport->out_channel)
- {
+ if (ifport->out_channel) {
SPRINT(interface_error, "Error in %s (line %d): value 'force' may only appear as first element in list.\n", filename, line);
return(-1);
}
} else
- if (!strcasecmp(el, "any"))
- {
+ if (!strcasecmp(el, "any")) {
val = CHANNEL_ANY;
goto selchannel;
} else
- if (!strcasecmp(el, "free"))
- {
+ if (!strcasecmp(el, "free")) {
val = CHANNEL_FREE;
goto selchannel;
} else
- if (!strcasecmp(el, "no"))
- {
+ if (!strcasecmp(el, "no")) {
val = CHANNEL_NO;
goto selchannel;
- } else
- {
+ } else {
val = get_number(el);
- if (val == -1)
- {
+ if (val == -1) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects a comma seperated list of 'force', 'any', 'free', 'no' and any channel number.\n", filename, line, parameter);
return(-1);
}
- if (val<1 || val==16 || val>126)
- {
+ if (val<1 || val==16 || val>126) {
SPRINT(interface_error, "Error in %s (line %d): channel '%d' out of range.\n", filename, line, val);
return(-1);
}
char *p, *el;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
while(ifport->next)
ifport = ifport->next;
p = value;
- while(*p)
- {
+ while(*p) {
el = p;
p = get_seperated(p);
- if (ifport->in_channel) if (ifport->in_channel->channel == CHANNEL_FREE)
- {
+ if (ifport->in_channel) if (ifport->in_channel->channel == CHANNEL_FREE) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' has values behind 'free' keyword. They has no effect.\n", filename, line, parameter);
return(-1);
}
- if (!strcasecmp(el, "free"))
- {
+ if (!strcasecmp(el, "free")) {
val = CHANNEL_FREE;
goto selchannel;
- } else
- {
+ } else {
val = get_number(el);
- if (val == -1)
- {
+ if (val == -1) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects a comma seperated list of channel numbers and 'free'.\n", filename, line, parameter);
return(-1);
}
- if (val<1 || val==16 || val>126)
- {
+ if (val<1 || val==16 || val>126) {
SPRINT(interface_error, "Error in %s (line %d): channel '%d' out of range.\n", filename, line, val);
return(-1);
}
char *p, *el;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
while(ifport->next)
ifport = ifport->next;
p = value;
- if (!*p)
- {
+ if (!*p) {
nofive:
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects five timeout values.\n", filename, line, parameter);
return(-1);
struct interface_msn *ifmsn, **ifmsnp;
char *p, *el;
- if (!value[0])
- {
+ if (!value[0]) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects one MSN number or a list.\n", filename, line, parameter);
return(-1);
}
- if (interface->ifscreen_in)
- {
+ if (interface->ifscreen_in) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' not allowed with 'screen_in' parameter.\n", filename, line, parameter);
return(-1);
}
/* process list */
p = value;
- while(*p)
- {
+ while(*p) {
el = p;
p = get_seperated(p);
/* add MSN to list */
struct interface_screen *ifscreen;
char *p, *el;
- if (!value[0])
- {
+ if (!value[0]) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects old caller ID and new caller ID.\n", filename, line, parameter);
return(-1);
}
// printf("interface=%s\n", interface->name);
/* get match */
p = value;
- while(*p)
- {
+ while(*p) {
el = p;
p = get_seperated(p);
- if (!strcasecmp(el, "unknown"))
- {
- if (ifscreen->match_type != -1)
- {
+ if (!strcasecmp(el, "unknown")) {
+ if (ifscreen->match_type != -1) {
typeerror:
SPRINT(interface_error, "Error in %s (line %d): number type already set earlier.\n", filename, line, parameter);
return(-1);
}
ifscreen->match_type = INFO_NTYPE_UNKNOWN;
} else
- if (!strcasecmp(el, "subscriber"))
- {
+ if (!strcasecmp(el, "subscriber")) {
if (ifscreen->match_type != -1)
goto typeerror;
ifscreen->match_type = INFO_NTYPE_SUBSCRIBER;
} else
- if (!strcasecmp(el, "national"))
- {
+ if (!strcasecmp(el, "national")) {
if (ifscreen->match_type != -1)
goto typeerror;
ifscreen->match_type = INFO_NTYPE_NATIONAL;
} else
- if (!strcasecmp(el, "international"))
- {
+ if (!strcasecmp(el, "international")) {
if (ifscreen->match_type != -1)
goto typeerror;
ifscreen->match_type = INFO_NTYPE_INTERNATIONAL;
} else
- if (!strcasecmp(el, "allowed"))
- {
- if (ifscreen->match_present != -1)
- {
+ if (!strcasecmp(el, "allowed")) {
+ if (ifscreen->match_present != -1) {
presenterror:
SPRINT(interface_error, "Error in %s (line %d): presentation type already set earlier.\n", filename, line);
return(-1);
}
ifscreen->match_present = INFO_PRESENT_ALLOWED;
} else
- if (!strcasecmp(el, "restrict") || !strcasecmp(el, "restricted"))
- {
+ if (!strcasecmp(el, "restrict") || !strcasecmp(el, "restricted")) {
if (ifscreen->match_present != -1)
goto presenterror;
ifscreen->match_present = INFO_PRESENT_RESTRICTED;
} else {
SCPY(ifscreen->match, el);
/* check for % at the end */
- if (strchr(el, '%'))
- {
- if (strchr(el, '%') != el+strlen(el)-1)
- {
+ if (strchr(el, '%')) {
+ if (strchr(el, '%') != el+strlen(el)-1) {
SPRINT(interface_error, "Error in %s (line %d): %% joker found, but must at the end.\n", filename, line, parameter);
return(-1);
}
break;
}
}
- if (ifscreen->match[0] == '\0')
- {
+ if (ifscreen->match[0] == '\0') {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects old caller ID.\n", filename, line, parameter);
return(-1);
}
/* get result */
- while(*p)
- {
+ while(*p) {
el = p;
p = get_seperated(p);
- if (!strcasecmp(el, "unknown"))
- {
+ if (!strcasecmp(el, "unknown")) {
if (ifscreen->result_type != -1)
goto typeerror;
ifscreen->result_type = INFO_NTYPE_UNKNOWN;
} else
- if (!strcasecmp(el, "subscriber"))
- {
+ if (!strcasecmp(el, "subscriber")) {
if (ifscreen->result_type != -1)
goto typeerror;
ifscreen->result_type = INFO_NTYPE_SUBSCRIBER;
} else
- if (!strcasecmp(el, "national"))
- {
+ if (!strcasecmp(el, "national")) {
if (ifscreen->result_type != -1)
goto typeerror;
ifscreen->result_type = INFO_NTYPE_NATIONAL;
} else
- if (!strcasecmp(el, "international"))
- {
+ if (!strcasecmp(el, "international")) {
if (ifscreen->result_type != -1)
goto typeerror;
ifscreen->result_type = INFO_NTYPE_INTERNATIONAL;
} else
- if (!strcasecmp(el, "present") || !strcasecmp(el, "presented") || !strcasecmp(el, "allowed") || !strcasecmp(el, "allow"))
- {
+ if (!strcasecmp(el, "present") || !strcasecmp(el, "presented") || !strcasecmp(el, "allowed") || !strcasecmp(el, "allow")) {
if (ifscreen->result_present != -1)
goto presenterror;
ifscreen->result_present = INFO_PRESENT_ALLOWED;
} else
- if (!strcasecmp(el, "restrict") || !strcasecmp(el, "restricted") || !strcasecmp(el, "deny") || !strcasecmp(el, "denied"))
- {
+ if (!strcasecmp(el, "restrict") || !strcasecmp(el, "restricted") || !strcasecmp(el, "deny") || !strcasecmp(el, "denied")) {
if (ifscreen->result_present != -1)
goto presenterror;
ifscreen->result_present = INFO_PRESENT_RESTRICTED;
} else {
SCPY(ifscreen->result, el);
/* check for % at the end */
- if (strchr(el, '%'))
- {
- if (strchr(el, '%') != el+strlen(el)-1)
- {
+ if (strchr(el, '%')) {
+ if (strchr(el, '%') != el+strlen(el)-1) {
SPRINT(interface_error, "Error in %s (line %d): %% joker found, but must at the end.\n", filename, line, parameter);
return(-1);
}
break;
}
}
- if (ifscreen->result[0] == '\0')
- {
+ if (ifscreen->result[0] == '\0') {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects new caller ID.\n", filename, line, parameter);
return(-1);
}
}
static int inter_screen_in(struct interface *interface, char *filename, int line, char *parameter, char *value)
{
- if (interface->ifmsn)
- {
+ if (interface->ifmsn) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' not allowed with 'msn' parameter.\n", filename, line, parameter);
return(-1);
}
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
p = value;
while(*p > 32)
p++;
- if (*p)
- {
+ if (*p) {
*p++ = 0;
while(*p > 0 && *p <= 32)
p++;
}
- if (!strcasecmp(value, "gain"))
- {
+ if (!strcasecmp(value, "gain")) {
q = p;
while(*q > 32)
q++;
- if (*q)
- {
+ if (*q) {
*q++ = 0;
while(*q > 0 && *q <= 32)
q++;
}
- if (*p == 0 || *q == 0)
- {
+ if (*p == 0 || *q == 0) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s %s' expects two gain values.\n", filename, line, parameter, value);
return(-1);
}
- if (atoi(p)<-8 || atoi(p)>8 || atoi(q)<-8 || atoi(q)>8)
- {
+ if (atoi(p)<-8 || atoi(p)>8 || atoi(q)<-8 || atoi(q)>8) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s %s' gain values not in range. (-8...8)\n", filename, line, parameter, value);
return(-1);
}
interface->tx_gain = atoi(p);
interface->rx_gain = atoi(q);
} else
- if (!strcasecmp(value, "pipeline"))
- {
- if (*p == 0)
- {
+ if (!strcasecmp(value, "pipeline")) {
+ if (*p == 0) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s %s' expects pipeline string.\n", filename, line, parameter, value);
return(-1);
}
SCPY(interface->pipeline, p);
} else
- if (!strcasecmp(value, "blowfish"))
- {
+ if (!strcasecmp(value, "blowfish")) {
unsigned char key[56];
int l;
- if (!!strncmp(p, "0x", 2))
- {
+ if (!!strncmp(p, "0x", 2)) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s %s' expects blowfish key starting with '0x'.\n", filename, line, parameter, value);
return(-1);
}
p += 2;
l = 0;
- while(*p)
- {
- if (l == 56)
- {
+ while(*p) {
+ if (l == 56) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s %s' key too long.\n", filename, line, parameter, value);
return(-1);
}
key[l] = (*p-'a'+10)<<4;
else if (*p >= 'A' && *p <= 'F')
key[l] = (*p-'A'+10)<<4;
- else
- {
+ else {
digout:
SPRINT(interface_error, "Error in %s (line %d): parameter '%s %s' key has digits out of range. (0...9, a...f)\n", filename, line, parameter, value);
return(-1);
}
p++;
- if (*p == 0)
- {
+ if (*p == 0) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s %s' key must end on an 8 bit boundary (two character boundary).\n", filename, line, parameter, value);
return(-1);
}
p++;
l++;
}
- if (l < 4)
- {
+ if (l < 4) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s %s' key must be at least 4 bytes (8 characters).\n", filename, line, parameter, value);
return(-1);
}
memcpy(interface->bf_key, key, l);
interface->bf_len = l;
- } else
- {
+ } else {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' has unknown filter '%s'.\n", filename, line, parameter, value);
return(-1);
}
struct interface_port *ifport;
/* port in chain ? */
- if (!interface->ifport)
- {
+ if (!interface->ifport) {
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
ifport->dialmax = atoi(value);
return(0);
}
+static int inter_tones_dir(struct interface *interface, char *filename, int line, char *parameter, char *value)
+{
+ struct interface_port *ifport;
+
+ /* port in chain ? */
+ if (!interface->ifport) {
+ SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
+ return(-1);
+ }
+ /* goto end of chain */
+ ifport = interface->ifport;
+ while(ifport->next)
+ ifport = ifport->next;
+ SCPY(ifport->tones_dir, value);
+ return(0);
+}
static int inter_gsm(struct interface *interface, char *filename, int line, char *parameter, char *value)
{
#ifndef WITH_GSM
struct interface *searchif;
/* check gsm */
- if (!gsm)
- {
+ if (!gsm) {
SPRINT(interface_error, "Error in %s (line %d): GSM is not activated.\n", filename, line);
return(-1);
}
searchif = interface_newlist;
- while(searchif)
- {
+ while(searchif) {
ifport = searchif->ifport;
- while(ifport)
- {
- if (ifport->gsm)
- {
+ while(ifport) {
+ if (ifport->gsm) {
SPRINT(interface_error, "Error in %s (line %d): port '%s' already uses gsm\n", filename, line, value);
return(-1);
}
{"dialmax", &inter_dialmax, "<digits>",
"Limits the number of digits in setup/information message."},
+ {"tones_dir", &inter_tones_dir, "<path>",
+ "Overrides the given tone_dir in options.conf.\n"
+ "To used kernel tones in mISDN_dsp.ko, say 'american', 'german', or 'oldgerman'."},
+
{"gsm", &inter_gsm, "",
"Sets up GSM interface for using OpenBSC.\n"
"This interface must be a loopback interface. The second loopback interface\n"
interface_error[0] = '\0';
SPRINT(filename, "%s/interface.conf", CONFIG_DATA);
- if (!(fp = fopen(filename,"r")))
- {
+ if (!(fp = fopen(filename,"r"))) {
SPRINT(interface_error, "Cannot open '%s'\n", filename);
goto error;
}
line=0;
- while((fgets(buffer,sizeof(buffer),fp)))
- {
+ while((fgets(buffer,sizeof(buffer),fp))) {
buffer[sizeof(buffer)-1]=0;
if (buffer[0]) buffer[strlen(buffer)-1]=0;
p=buffer;
line++;
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
parameter[0]=0;
value[0]=0;
i=0; /* read parameter */
- while(*p > 32)
- {
- if (i+1 >= sizeof(parameter))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(parameter)) {
SPRINT(interface_error, "Error in %s (line %d): parameter name too long.\n",filename,line);
goto error;
}
parameter[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
- if (*p!=0 && *p!='#') /* missing name */
- {
+ if (*p!=0 && *p!='#') { /* missing name */
i=0; /* read until end */
- while(*p!=0 && *p!='#')
- {
- if (i+1 >= sizeof(value))
- {
+ while(*p!=0 && *p!='#') {
+ if (i+1 >= sizeof(value)) {
SPRINT(interface_error, "Error in %s (line %d): value too long.\n", filename, line);
goto error;
}
}
/* remove trailing spaces from value */
- while(i)
- {
+ while(i) {
if (value[i-1]==0 || value[i-1]>32)
break;
value[i-1] = '\0';
}
/* check for interface name as first statement */
- if (expecting && parameter[0]!='[')
- {
+ if (expecting && parameter[0]!='[') {
SPRINT(interface_error, "Error in %s (line %d): expecting interface name inside [ and ], but got: '%s'.\n", filename, line, parameter);
goto error;
}
expecting = 0;
/* check for new interface */
- if (parameter[0] == '[')
- {
- if (parameter[strlen(parameter)-1] != ']')
- {
+ if (parameter[0] == '[') {
+ if (parameter[strlen(parameter)-1] != ']') {
SPRINT(interface_error, "Error in %s (line %d): expecting interface name inside [ and ], but got: '%s'.\n", filename, line, parameter);
goto error;
}
/* check if interface name already exists */
interface = interface_newlist;
- while(interface)
- {
- if (!strcasecmp(interface->name, parameter+1))
- {
+ while(interface) {
+ if (!strcasecmp(interface->name, parameter+1)) {
SPRINT(interface_error, "Error in %s (line %d): interface name '%s' already defined above.\n", filename, line, parameter+1);
goto error;
}
}
ifparam = interface_param;
- while(ifparam->name)
- {
- if (!strcasecmp(parameter, ifparam->name))
- {
+ while(ifparam->name) {
+ if (!strcasecmp(parameter, ifparam->name)) {
if (ifparam->func(interface, filename, line, parameter, value))
goto error;
break;
struct interface_msn *ifmsn;
struct interface_screen *ifscreen;
- while(interface)
- {
+ while(interface) {
ifport = interface->ifport;
- while(ifport)
- {
+ while(ifport) {
selchannel = ifport->in_channel;
- while(selchannel)
- {
+ while(selchannel) {
temp = selchannel;
selchannel = selchannel->next;
FREE(temp, sizeof(struct select_channel));
memuse--;
}
selchannel = ifport->out_channel;
- while(selchannel)
- {
+ while(selchannel) {
temp = selchannel;
selchannel = selchannel->next;
FREE(temp, sizeof(struct select_channel));
memuse--;
}
ifmsn = interface->ifmsn;
- while(ifmsn)
- {
+ while(ifmsn) {
temp = ifmsn;
ifmsn = ifmsn->next;
FREE(temp, sizeof(struct interface_msn));
memuse--;
}
ifscreen = interface->ifscreen_in;
- while(ifscreen)
- {
+ while(ifscreen) {
temp = ifscreen;
ifscreen = ifscreen->next;
FREE(temp, sizeof(struct interface_screen));
memuse--;
}
ifscreen = interface->ifscreen_out;
- while(ifscreen)
- {
+ while(ifscreen) {
temp = ifscreen;
ifscreen = ifscreen->next;
FREE(temp, sizeof(struct interface_screen));
/* unlink all mISDNports */
mISDNport = mISDNport_first;
- while(mISDNport)
- {
+ while(mISDNport) {
mISDNport->ifport = NULL;
mISDNport = mISDNport->next;
}
/* relink existing mISDNports */
interface = interface_newlist;
- while(interface)
- {
+ while(interface) {
ifport = interface->ifport;
- while(ifport)
- {
+ while(ifport) {
mISDNport = mISDNport_first;
- while(mISDNport)
- {
+ while(mISDNport) {
if (!strcmp(mISDNport->name, ifport->portname))
ifport->portnum = mISDNport->portnum; /* same name, so we use same number */
- if (mISDNport->portnum == ifport->portnum)
- {
+ if (mISDNport->portnum == ifport->portnum) {
PDEBUG(DEBUG_ISDN, "Port %d:%s relinking!\n", mISDNport->portnum);
ifport->mISDNport = mISDNport;
mISDNport->ifport = ifport;
/* close unused mISDNports */
closeagain:
mISDNport = mISDNport_first;
- while(mISDNport)
- {
- if (mISDNport->ifport == NULL)
- {
+ while(mISDNport) {
+ if (mISDNport->ifport == NULL) {
PDEBUG(DEBUG_ISDN, "Port %d is not used anymore and will be closed\n", mISDNport->portnum);
/* remove all port objects and destroy port */
mISDNport_close(mISDNport);
/* open and link new mISDNports */
interface = interface_newlist;
- while(interface)
- {
+ while(interface) {
ifport = interface->ifport;
- while(ifport)
- {
- if (!ifport->mISDNport)
- {
+ while(ifport) {
+ if (!ifport->mISDNport) {
load_port(ifport);
}
ifport = ifport->next;
/* open new port */
mISDNport = mISDNport_open(ifport->portnum, ifport->portname, ifport->ptp, ifport->nt, ifport->tespecial, ifport->l1hold, ifport->l2hold, ifport->interface, ifport->gsm);
- if (mISDNport)
- {
+ if (mISDNport) {
/* link port */
ifport->mISDNport = mISDNport;
mISDNport->ifport = ifport;
SCPY(ifport->portname, mISDNport->name);
/* set defaults */
set_defaults(ifport);
- } else
- {
+ } else {
ifport->block = 2; /* not available */
}
}
printf("[<name>]\n");
ifparam = interface_param;
- while(ifparam->name)
- {
+ while(ifparam->name) {
if (ifparam->name[0])
printf("%s %s\n", ifparam->name, ifparam->usage);
ifparam++;
}
ifparam = interface_param;
- while(ifparam->name)
- {
- if (ifparam->name[0])
- {
+ while(ifparam->name) {
+ if (ifparam->name[0]) {
printf("\nParameter: %s %s\n", ifparam->name, ifparam->usage);
printf("%s\n", ifparam->help);
}
char suffix[64];
/* screen incoming caller id */
- if (!out)
- {
+ if (!out) {
/* check for MSN numbers, use first MSN if no match */
msn1 = NULL;
ifmsn = interface->ifmsn;
- while(ifmsn)
- {
+ while(ifmsn) {
if (!msn1)
msn1 = ifmsn->msn;
- if (!strcmp(ifmsn->msn, id))
- {
+ if (!strcmp(ifmsn->msn, id)) {
break;
}
ifmsn = ifmsn->next;
}
- if (ifmsn)
- {
+ if (ifmsn) {
start_trace(-1, interface, numberrize_callerinfo(id, *type, options.national, options.international), NULL, DIRECTION_IN, 0, 0, "SCREEN (found in MSN list)");
add_trace("msn", NULL, "%s", id);
end_trace();
}
- if (!ifmsn && msn1) // not in list, first msn given
- {
+ if (!ifmsn && msn1) { // not in list, first msn given
start_trace(-1, interface, numberrize_callerinfo(id, *type, options.national, options.international), NULL, DIRECTION_IN, 0, 0, "SCREEN (not found in MSN list)");
add_trace("msn", "given", "%s", id);
add_trace("msn", "used", "%s", msn1);
ifscreen = interface->ifscreen_out;
else
ifscreen = interface->ifscreen_in;
- while (ifscreen)
- {
+ while (ifscreen) {
if (ifscreen->match_type==-1 || ifscreen->match_type==*type)
- if (ifscreen->match_present==-1 || ifscreen->match_present==*present)
- {
- if (strchr(ifscreen->match,'%'))
- {
+ if (ifscreen->match_present==-1 || ifscreen->match_present==*present) {
+ if (strchr(ifscreen->match,'%')) {
if (!strncmp(ifscreen->match, id, strchr(ifscreen->match,'%')-ifscreen->match))
break;
- } else
- {
+ } else {
if (!strcmp(ifscreen->match, id))
break;
}
}
ifscreen = ifscreen->next;
}
- if (ifscreen) // match
- {
+ if (ifscreen) { // match
start_trace(-1, interface, numberrize_callerinfo(id, *type, options.national, options.international), NULL, out?DIRECTION_OUT:DIRECTION_IN, 0, 0, "SCREEN (found in screen list)");
- switch(*type)
- {
+ switch(*type) {
case INFO_NTYPE_UNKNOWN:
add_trace("given", "type", "unknown");
break;
add_trace("given", "type", "international");
break;
}
- switch(*present)
- {
+ switch(*present) {
case INFO_PRESENT_ALLOWED:
add_trace("given", "present", "allowed");
break;
break;
}
add_trace("given", "id", "%s", id[0]?id:"<empty>");
- if (ifscreen->result_type != -1)
- {
+ if (ifscreen->result_type != -1) {
*type = ifscreen->result_type;
- switch(*type)
- {
+ switch(*type) {
case INFO_NTYPE_UNKNOWN:
add_trace("used", "type", "unknown");
break;
break;
}
}
- if (ifscreen->result_present != -1)
- {
+ if (ifscreen->result_present != -1) {
*present = ifscreen->result_present;
- switch(*present)
- {
+ switch(*present) {
case INFO_PRESENT_ALLOWED:
add_trace("used", "present", "allowed");
break;
break;
}
}
- if (strchr(ifscreen->match,'%'))
- {
+ if (strchr(ifscreen->match,'%')) {
SCPY(suffix, strchr(ifscreen->match,'%') - ifscreen->match + id);
UNCPY(id, ifscreen->result, idsize);
id[idsize-1] = '\0';
- if (strchr(id,'%'))
- {
+ if (strchr(id,'%')) {
*strchr(id,'%') = '\0';
UNCAT(id, suffix, idsize);
id[idsize-1] = '\0';
}
- } else
- {
+ } else {
UNCPY(id, ifscreen->result, idsize);
id[idsize-1] = '\0';
}
// int tout_hold;
// int tout_park;
int dialmax; /* maximum number of digits to dial */
+ char tones_dir[128];
};
struct interface_msn {
/* try to open raw socket to check kernel */
mISDNsocket = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
- if (mISDNsocket < 0)
- {
+ if (mISDNsocket < 0) {
fprintf(stderr, "Cannot open mISDN due to '%s'. (Does your Kernel support socket based mISDN?)\n", strerror(errno));
return(-1);
}
init_layer3(4); // buffer of 4
/* open debug, if enabled and not only stack debugging */
- if (options.deb)
- {
+ if (options.deb) {
SPRINT(filename, "%s/debug.log", LOG_DIR);
debug_fp = fopen(filename, "a");
}
- if (options.deb & DEBUG_STACK)
- {
+ if (options.deb & DEBUG_STACK) {
SPRINT(filename, "%s/debug_mISDN.log", LOG_DIR);
mISDN_debug_init(0xfffffeff, filename, filename, filename);
} else
p_m_crypt_listen_len = 0;
p_m_crypt_listen_msg[0] = '\0';
p_m_crypt_listen_crc = 0;
- if (mISDNport->ifport->interface->bf_len >= 4 && mISDNport->ifport->interface->bf_len <= 56)
- {
+ if (mISDNport->ifport->interface->bf_len >= 4 && mISDNport->ifport->interface->bf_len <= 56) {
memcpy(p_m_crypt_key, mISDNport->ifport->interface->bf_key, p_m_crypt_key_len);
p_m_crypt_key_len = mISDNport->ifport->interface->bf_len;
p_m_crypt = 1;
}
/* if any channel requested by constructor */
- if (channel == CHANNEL_ANY)
- {
+ if (channel == CHANNEL_ANY) {
/* reserve channel */
p_m_b_reserve = 1;
mISDNport->b_reserved++;
drop_bchannel();
/* release epoint */
- while (p_epointlist)
- {
+ while (p_epointlist) {
PDEBUG(DEBUG_ISDN, "destroy mISDNPort(%s). endpoint still exists, releaseing.\n", p_name);
message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
message->param.disconnectinfo.cause = 16;
SCPY(msgtext, "<<UNKNOWN MESSAGE>>");
/* select message and primitive text */
i = 0;
- while(isdn_message[i].name)
- {
+ while(isdn_message[i].name) {
// if (msg == L3_NOTIFY_REQ) printf("val = %x %s\n", isdn_message[i].value, isdn_message[i].name);
- if (isdn_message[i].value == (msg&0xffffff00))
- {
+ if (isdn_message[i].value == (msg&0xffffff00)) {
SCPY(msgtext, isdn_message[i].name);
break;
}
SCAT(msgtext, isdn_prim[msg&0x00000003]);
/* add direction */
- if (direction && (msg&0xffffff00)!=L3_NEW_L3ID_REQ && (msg&0xffffff00)!=L3_RELEASE_L3ID_REQ)
- {
- if (mISDNport)
- {
- if (mISDNport->ntmode)
- {
+ if (direction && (msg&0xffffff00)!=L3_NEW_L3ID_REQ && (msg&0xffffff00)!=L3_RELEASE_L3ID_REQ) {
+ if (mISDNport) {
+ if (mISDNport->ntmode) {
if (direction == DIRECTION_OUT)
SCAT(msgtext, " N->U");
else
SCAT(msgtext, " N<-U");
- } else
- {
+ } else {
if (direction == DIRECTION_OUT)
SCAT(msgtext, " U->N");
else
unsigned int on = 1;
struct sockaddr_mISDN addr;
- if (mISDNport->b_socket[i] > -1)
- {
+ if (mISDNport->b_socket[i] > -1) {
PERROR("Error: Socket already created for index %d\n", i);
return(0);
}
//#warning testing without DSP
// mISDNport->b_socket[i] = socket(PF_ISDN, SOCK_DGRAM, (mISDNport->b_mode[i]==B_MODE_HDLC)?ISDN_P_B_HDLC:ISDN_P_B_RAW);
mISDNport->b_socket[i] = socket(PF_ISDN, SOCK_DGRAM, (mISDNport->b_mode[i]==B_MODE_HDLC)?ISDN_P_B_L2DSPHDLC:ISDN_P_B_L2DSP);
- if (mISDNport->b_socket[i] < 0)
- {
+ if (mISDNport->b_socket[i] < 0) {
PERROR("Error: Failed to open bchannel-socket for index %d with mISDN-DSP layer. Did you load mISDN_dsp.ko?\n", i);
return(0);
}
/* set nonblocking io */
ret = ioctl(mISDNport->b_socket[i], FIONBIO, &on);
- if (ret < 0)
- {
+ if (ret < 0) {
PERROR("Error: Failed to set bchannel-socket index %d into nonblocking IO\n", i);
close(mISDNport->b_socket[i]);
mISDNport->b_socket[i] = -1;
addr.dev = mISDNport->portnum;
addr.channel = i+1+(i>=15);
ret = bind(mISDNport->b_socket[i], (struct sockaddr *)&addr, sizeof(addr));
- if (ret < 0)
- {
+ if (ret < 0) {
PERROR("Error: Failed to bind bchannel-socket for index %d with mISDN-DSP layer (errno=%d). Did you load mISDN_dsp.ko?\n", i, errno);
close(mISDNport->b_socket[i]);
mISDNport->b_socket[i] = -1;
handle = mISDNport->b_socket[i];
port = mISDNport->b_port[i];
mode = mISDNport->b_mode[i];
- if (!port)
- {
+ if (!port) {
PERROR("bchannel index i=%d not associated with a port object\n", i);
return;
}
int p_m_crypt_key_type = 0;
unsigned int portid = (mISDNport->portnum<<8) + i+1+(i>=15);
- if (b_port)
- {
+ if (b_port) {
p_m_remote_id = b_port->p_m_remote_id;
p_m_remote_ref = b_port->p_m_remote_ref;
p_m_tx_gain = b_port->p_m_tx_gain;
p_m_crypt_key_type = /*b_port->p_m_crypt_key_type*/1;
}
- switch(event)
- {
+ switch(event) {
case B_EVENT_USE:
/* port must be linked in order to allow activation */
if (!b_port)
FATAL("bchannel must be linked to a Port class\n");
- switch(state)
- {
+ switch(state) {
case B_STATE_IDLE:
- if (p_m_remote_ref)
- {
+ if (p_m_remote_ref) {
/* export bchannel */
message_bchannel_to_remote(p_m_remote_id, p_m_remote_ref, BCHANNEL_ASSIGN, portid, p_m_tx_gain, p_m_rx_gain, p_m_pipeline, p_m_crypt_key, p_m_crypt_key_len, p_m_crypt_key_type);
chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
state = B_STATE_EXPORTING;
mISDNport->b_remote_id[i] = p_m_remote_id;
mISDNport->b_remote_ref[i] = p_m_remote_ref;
- } else
- {
+ } else {
/* create stack and send activation request */
- if (_bchannel_create(mISDNport, i))
- {
+ if (_bchannel_create(mISDNport, i)) {
_bchannel_activate(mISDNport, i, 1);
state = B_STATE_ACTIVATING;
timer = now_d + B_TIMER_ACTIVATING;
case B_EVENT_EXPORTREQUEST:
/* special case where the bchannel is requested by remote */
- if (!p_m_remote_ref)
- {
+ if (!p_m_remote_ref) {
PERROR("export request without remote channel set, please correct.\n");
break;
}
- switch(state)
- {
+ switch(state) {
case B_STATE_IDLE:
/* in case, the bchannel is exported right after seize_bchannel */
/* export bchannel */
case B_EVENT_IMPORTREQUEST:
/* special case where the bchannel is released by remote */
- if (p_m_remote_ref)
- {
+ if (p_m_remote_ref) {
PERROR("import request with remote channel set, please correct.\n");
break;
}
- switch(state)
- {
+ switch(state) {
case B_STATE_IDLE:
case B_STATE_ACTIVE:
/* bchannel is not exported */
case B_EVENT_ACTIVATED:
timer = 0;
- switch(state)
- {
+ switch(state) {
case B_STATE_ACTIVATING:
- if (b_port && !p_m_remote_id)
- {
+ if (b_port && !p_m_remote_id) {
/* bchannel is active and used by Port class, so we configure bchannel */
_bchannel_configure(mISDNport, i);
state = B_STATE_ACTIVE;
b_port->p_m_load = 0;
- } else
- {
+ } else {
/* bchannel is active, but exported OR not used anymore (or has wrong stack config), so we deactivate */
_bchannel_activate(mISDNport, i, 0);
state = B_STATE_DEACTIVATING;
break;
case B_EVENT_EXPORTED:
- switch(state)
- {
+ switch(state) {
case B_STATE_EXPORTING:
- if (b_port && p_m_remote_ref && p_m_remote_ref==mISDNport->b_remote_ref[i])
- {
+ if (b_port && p_m_remote_ref && p_m_remote_ref==mISDNport->b_remote_ref[i]) {
/* remote export done */
state = B_STATE_REMOTE;
- } else
- {
+ } else {
/* bchannel is now exported, but we need bchannel back
* OR bchannel is not used anymore
* OR bchannel has been exported to an obsolete ref,
case B_EVENT_DROP:
if (!b_port)
FATAL("bchannel must be linked to a Port class\n");
- switch(state)
- {
+ switch(state) {
case B_STATE_IDLE:
/* bchannel is idle due to an error, so we do nothing */
break;
case B_EVENT_DEACTIVATED:
timer = 0;
- switch(state)
- {
+ switch(state) {
case B_STATE_IDLE:
/* ignore due to deactivation confirm after unloading */
break;
case B_STATE_DEACTIVATING:
_bchannel_destroy(mISDNport, i);
state = B_STATE_IDLE;
- if (b_port)
- {
+ if (b_port) {
/* bchannel is now deactivate, but is requied by Port class, so we reactivate / export */
- if (p_m_remote_ref)
- {
+ if (p_m_remote_ref) {
message_bchannel_to_remote(p_m_remote_id, p_m_remote_ref, BCHANNEL_ASSIGN, portid, p_m_tx_gain, p_m_rx_gain, p_m_pipeline, p_m_crypt_key, p_m_crypt_key_len, p_m_crypt_key_type);
chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
add_trace("type", NULL, "assign");
state = B_STATE_EXPORTING;
mISDNport->b_remote_id[i] = p_m_remote_id;
mISDNport->b_remote_ref[i] = p_m_remote_ref;
- } else
- {
- if (_bchannel_create(mISDNport, i))
- {
+ } else {
+ if (_bchannel_create(mISDNport, i)) {
_bchannel_activate(mISDNport, i, 1);
state = B_STATE_ACTIVATING;
timer = now_d + B_TIMER_ACTIVATING;
break;
case B_EVENT_IMPORTED:
- switch(state)
- {
+ switch(state) {
case B_STATE_IMPORTING:
state = B_STATE_IDLE;
mISDNport->b_remote_id[i] = 0;
mISDNport->b_remote_ref[i] = 0;
- if (b_port)
- {
+ if (b_port) {
/* bchannel is now imported, but is requied by Port class, so we reactivate / export */
- if (p_m_remote_ref)
- {
+ if (p_m_remote_ref) {
message_bchannel_to_remote(p_m_remote_id, p_m_remote_ref, BCHANNEL_ASSIGN, portid, p_m_tx_gain, p_m_rx_gain, p_m_pipeline, p_m_crypt_key, p_m_crypt_key_len, p_m_crypt_key_type);
chan_trace_header(mISDNport, b_port, "MESSAGE_BCHANNEL (to remote application)", DIRECTION_NONE);
add_trace("type", NULL, "assign");
state = B_STATE_EXPORTING;
mISDNport->b_remote_id[i] = p_m_remote_id;
mISDNport->b_remote_ref[i] = p_m_remote_ref;
- } else
- {
- if (_bchannel_create(mISDNport, i))
- {
+ } else {
+ if (_bchannel_create(mISDNport, i)) {
_bchannel_activate(mISDNport, i, 1);
state = B_STATE_ACTIVATING;
timer = now_d + B_TIMER_ACTIVATING;
case B_EVENT_TIMEOUT:
timer = 0;
- switch(state)
- {
+ switch(state) {
case B_STATE_IDLE:
/* ignore due to deactivation confirm after unloading */
break;
return(-6); /* channel unacceptable */
/* request exclusive channel */
- if (exclusive && channel>0)
- {
+ if (exclusive && channel>0) {
i = channel-1-(channel>16);
if (p_m_mISDNport->b_port[i])
return(-44); /* requested channel not available */
}
/* ask for channel */
- if (channel>0)
- {
+ if (channel>0) {
i = channel-1-(channel>16);
if (p_m_mISDNport->b_port[i] == NULL)
goto seize;
/* search for channel */
i = 0;
- while(i < p_m_mISDNport->b_num)
- {
- if (!p_m_mISDNport->b_port[i])
- {
+ while(i < p_m_mISDNport->b_num) {
+ if (!p_m_mISDNport->b_port[i]) {
channel = i+1+(i>=15);
goto seize;
}
p_m_mISDNport->b_mode[i] = p_m_b_mode;
/* reserve channel */
- if (!p_m_b_reserve)
- {
+ if (!p_m_b_reserve) {
p_m_b_reserve = 1;
p_m_mISDNport->b_reserved++;
}
struct mISDNport *mISDNport;
int i, ii;
- switch(type)
- {
+ switch(type) {
case BCHANNEL_REQUEST:
/* find the port object for the join object ref */
- if (!(epoint = find_epoint_id(joinremote->j_epoint_id)))
- {
+ if (!(epoint = find_epoint_id(joinremote->j_epoint_id))) {
PDEBUG(DEBUG_BCHANNEL, "join %d has no endpoint (anymore)\n", joinremote->j_serial);
return;
}
- if (!epoint->ep_portlist)
- {
+ if (!epoint->ep_portlist) {
PDEBUG(DEBUG_BCHANNEL, "join %d has no port (anymore in portlist)\n", joinremote->j_serial);
return;
}
- if (epoint->ep_portlist->next)
- {
+ if (epoint->ep_portlist->next) {
PERROR("join %d has enpoint %d with more than one port. this shall not happen to remote joins.\n", joinremote->j_serial, epoint->ep_serial);
}
- if (!(port = find_port_id(epoint->ep_portlist->port_id)))
- {
+ if (!(port = find_port_id(epoint->ep_portlist->port_id))) {
PDEBUG(DEBUG_BCHANNEL, "join %d has no port (anymore as object)\n", joinremote->j_serial);
return;
}
- if ((port->p_type&PORT_CLASS_MASK) != PORT_CLASS_mISDN)
- {
+ if ((port->p_type&PORT_CLASS_MASK) != PORT_CLASS_mISDN) {
PERROR("join %d has port %d not of mISDN type. This shall not happen.\n", joinremote->j_serial, port->p_serial);
}
isdnport = (class PmISDN *)port;
/* assign */
- if (isdnport->p_m_remote_id)
- {
+ if (isdnport->p_m_remote_id) {
PERROR("join %d recevied bchannel request from remote, but channel is already assinged.\n", joinremote->j_serial);
break;
}
end_trace();
isdnport->p_m_remote_ref = joinremote->j_serial;
isdnport->p_m_remote_id = joinremote->j_remote_id;
- if (mISDNport && i>=0)
- {
+ if (mISDNport && i>=0) {
bchannel_event(mISDNport, i, B_EVENT_EXPORTREQUEST);
}
break;
case BCHANNEL_REMOVE_ACK:
/* find mISDNport for stack ID */
mISDNport = mISDNport_first;
- while(mISDNport)
- {
+ while(mISDNport) {
i = 0;
ii = mISDNport->b_num;
- while(i < ii)
- {
+ while(i < ii) {
if ((unsigned int)(mISDNport->portnum<<8)+i+1+(i>=15) == handle)
break;
i++;
break;
mISDNport = mISDNport->next;
}
- if (!mISDNport)
- {
+ if (!mISDNport) {
PERROR("received assign/remove ack for bchannel's handle=%x, but handle does not exist in any mISDNport structure.\n", handle);
break;
}
- if (type!=BCHANNEL_RELEASE)
- {
+ if (type!=BCHANNEL_RELEASE) {
/* ack */
chan_trace_header(mISDNport, mISDNport->b_port[i], "MESSAGE_BCHANNEL (from remote application)", DIRECTION_NONE);
add_trace("type", NULL, (type==BCHANNEL_ASSIGN_ACK)?"assign_ack":"remove_ack");
end_trace();
bchannel_event(mISDNport, i, (type==BCHANNEL_ASSIGN_ACK)?B_EVENT_EXPORTED:B_EVENT_IMPORTED);
- } else
- {
+ } else {
/* release */
isdnport = mISDNport->b_port[i];
chan_trace_header(mISDNport, isdnport, "MESSAGE_BCHANNEL (from remote application)", DIRECTION_NONE);
add_trace("type", NULL, "import request");
end_trace();
- if (isdnport)
- {
+ if (isdnport) {
isdnport->p_m_remote_ref = 0;
isdnport->p_m_remote_id = 0;
}
return(ret);
/* get elapsed */
- if (p_m_last_tv_sec)
- {
+ if (p_m_last_tv_sec) {
elapsed = 8000 * (now_tv.tv_sec - p_m_last_tv_sec)
+ 8 * (now_tv.tv_usec/1000 - p_m_last_tv_msec);
- } else
- {
+ } else {
/* set clock of first process ever in this instance */
p_m_last_tv_sec = now_tv.tv_sec;
p_m_last_tv_msec = now_tv.tv_usec/1000;
}
/* process only if we have a minimum of samples, to make packets not too small */
if (elapsed >= ISDN_TRANSMIT
- && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE)
- {
+ && p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE) {
/* set clock of last process! */
p_m_last_tv_sec = now_tv.tv_sec;
p_m_last_tv_msec = now_tv.tv_usec/1000;
/* to send data, tone must be active OR crypt messages must be on */
if ((p_tone_name[0] || p_m_crypt_msg_loops)
&& (p_m_load < ISDN_LOAD)
- && (p_state==PORT_STATE_CONNECT || p_m_mISDNport->tones))
- {
+ && (p_state==PORT_STATE_CONNECT || p_m_mISDNport->tones)) {
int tosend = ISDN_LOAD - p_m_load, length;
unsigned char buf[MISDN_HEADER_LEN+tosend];
struct mISDNhead *frm = (struct mISDNhead *)buf;
unsigned char *p = buf+MISDN_HEADER_LEN;
/* copy crypto loops */
- while (p_m_crypt_msg_loops && tosend)
- {
+ while (p_m_crypt_msg_loops && tosend) {
/* how much do we have to send */
length = p_m_crypt_msg_len - p_m_crypt_msg_current;
/* new position */
p_m_crypt_msg_current += length;
- if (p_m_crypt_msg_current == p_m_crypt_msg_len)
- {
+ if (p_m_crypt_msg_current == p_m_crypt_msg_len) {
/* next loop */
p_m_crypt_msg_current = 0;
p_m_crypt_msg_loops--;
}
/* copy tones */
- if (p_tone_name[0] && tosend)
- {
+ if (p_tone_name[0] && tosend) {
tosend -= read_audio(p, tosend);
}
/* send data */
- if (ISDN_LOAD - p_m_load - tosend > 0)
- {
+ if (ISDN_LOAD - p_m_load - tosend > 0) {
frm->prim = PH_DATA_REQ;
frm->id = 0;
ret = sendto(p_m_mISDNport->b_socket[p_m_b_index], buf, MISDN_HEADER_LEN+ISDN_LOAD-p_m_load-tosend, 0, NULL, 0);
// NOTE: deletion is done by the child class
/* handle timeouts */
- if (p_m_timeout)
- {
- if (p_m_timer+p_m_timeout < now_d)
- {
+ if (p_m_timeout) {
+ if (p_m_timer+p_m_timeout < now_d) {
PDEBUG(DEBUG_ISDN, "(%s) timeout after %d seconds detected (state=%d).\n", p_name, p_m_timeout, p_state);
p_m_timeout = 0;
/* send timeout to endpoint */
unsigned char *p;
int l;
- if (hh->prim == PH_CONTROL_IND)
- {
- if (len < 4)
- {
+ if (hh->prim == PH_CONTROL_IND) {
+ if (len < 4) {
PERROR("SHORT READ OF PH_CONTROL INDICATION\n");
return;
}
- if ((cont&(~DTMF_TONE_MASK)) == DTMF_TONE_VAL)
- {
+ if ((cont&(~DTMF_TONE_MASK)) == DTMF_TONE_VAL) {
chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
add_trace("DTMF", NULL, "%c", cont & DTMF_TONE_MASK);
end_trace();
message_put(message);
return;
}
- switch(cont)
- {
+ switch(cont) {
case DSP_BF_REJECT:
chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
add_trace("DSP-CRYPT", NULL, "error");
}
return;
}
- if (hh->prim == PH_CONTROL_IND)
- {
- switch(hh->id)
- {
+ if (hh->prim == PH_CONTROL_IND) {
+ switch(hh->id) {
default:
chan_trace_header(p_m_mISDNport, this, "BCHANNEL control", DIRECTION_IN);
add_trace("unknown", NULL, "0x%x", hh->id);
}
return;
}
- if (hh->prim == PH_DATA_REQ || hh->prim == DL_DATA_REQ)
- {
- if (!p_m_txdata)
- {
+ if (hh->prim == PH_DATA_REQ || hh->prim == DL_DATA_REQ) {
+ if (!p_m_txdata) {
/* if tx is off, it may happen that fifos send us pending informations, we just ignore them */
PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring tx data, because 'txdata' is turned off\n", p_name);
return;
record(data, len, 1); // from up
return;
}
- if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND)
- {
+ if (hh->prim != PH_DATA_IND && hh->prim != DL_DATA_IND) {
PERROR("Bchannel received unknown primitve: 0x%x\n", hh->prim);
return;
}
#endif
/* if rx is off, it may happen that fifos send us pending informations, we just ignore them */
- if (p_m_rxoff)
- {
+ if (p_m_rxoff) {
PDEBUG(DEBUG_BCHANNEL, "PmISDN(%s) ignoring data, because rx is turned off\n", p_name);
return;
}
record(data, len, 0); // from down
/* randomize and listen to crypt message if enabled */
- if (p_m_crypt_listen)
- {
+ if (p_m_crypt_listen) {
/* the noisy randomizer */
p = data;
l = len;
p = data;
/* send data to epoint */
- if (p_m_joindata && ACTIVE_EPOINT(p_epointlist)) /* only if we have an epoint object */
- {
+ if (p_m_joindata && ACTIVE_EPOINT(p_epointlist)) { /* only if we have an epoint object */
length_temp = len;
data_temp = p;
- while(length_temp)
- {
+ while(length_temp) {
message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DATA);
message->param.data.len = (length_temp>sizeof(message->param.data.data))?sizeof(message->param.data.data):length_temp;
memcpy(message->param.data.data, data_temp, message->param.data.len);
*/
void PmISDN::set_echotest(int echo)
{
- if (p_m_echo != echo)
- {
+ if (p_m_echo != echo) {
p_m_echo = echo;
PDEBUG(DEBUG_ISDN, "we set echo to echo=%d.\n", p_m_echo);
if (p_m_b_channel)
void PmISDN::set_tone(const char *dir, const char *tone)
{
int id = TONE_OFF;
+ int dsp = DSP_NONE;
+
+ /* if no directory is given (by extension), we use interface.conf or options.conf */
+ if (!dir || !dir[0]) {
+ if (p_m_mISDNport->ifport->tones_dir[0])
+ dir = p_m_mISDNport->ifport->tones_dir;
+ else if (options.tones_dir[0])
+ dir = options.tones_dir;
+ }
if (!tone)
tone = "";
PDEBUG(DEBUG_ISDN, "isdn port now plays tone:'%s'.\n", tone);
- if (!tone[0])
- {
+ if (!tone[0]) {
id = TONE_OFF;
goto setdsp;
}
+ /* check for dsp tones */
+ if (!strcmp(dir, "american"))
+ dsp = DSP_AMERICAN;
+ if (!strcmp(dir, "german"))
+ dsp = DSP_GERMAN;
+ if (!strcmp(dir, "oldgerman"))
+ dsp = DSP_OLDGERMAN;
+
/* check if we NOT really have to use a dsp-tone */
- if (!options.dsptones)
- {
+ if (dsp == DSP_NONE) {
nodsp:
if (p_m_tone)
if (p_m_b_index > -1)
- if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
- {
+ if (p_m_mISDNport->b_state[p_m_b_index] == B_STATE_ACTIVE && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
PDEBUG(DEBUG_ISDN, "we reset tone from id=%d to OFF.\n", p_m_tone);
ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], DSP_TONE_PATT_OFF, 0, "DSP-TONE", 0);
}
}
/* now we USE dsp-tone, convert name */
- if (!strcmp(tone, "dialtone"))
- {
- switch(options.dsptones) {
+ if (!strcmp(tone, "dialtone")) {
+ switch(dsp) {
case DSP_AMERICAN: id = TONE_AMERICAN_DIALTONE; break;
case DSP_GERMAN: id = TONE_GERMAN_DIALTONE; break;
case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALTONE; break;
}
- } else if (!strcmp(tone, "dialpbx"))
- {
- switch(options.dsptones) {
+ } else if (!strcmp(tone, "dialpbx")) {
+ switch(dsp) {
case DSP_AMERICAN: id = TONE_AMERICAN_DIALPBX; break;
case DSP_GERMAN: id = TONE_GERMAN_DIALPBX; break;
case DSP_OLDGERMAN: id = TONE_GERMAN_OLDDIALPBX; break;
}
- } else if (!strcmp(tone, "ringing"))
- {
- switch(options.dsptones) {
+ } else if (!strcmp(tone, "ringing")) {
+ switch(dsp) {
case DSP_AMERICAN: id = TONE_AMERICAN_RINGING; break;
case DSP_GERMAN: id = TONE_GERMAN_RINGING; break;
case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGING; break;
}
- } else if (!strcmp(tone, "ringpbx"))
- {
- switch(options.dsptones) {
+ } else if (!strcmp(tone, "ringpbx")) {
+ switch(dsp) {
case DSP_AMERICAN: id = TONE_AMERICAN_RINGPBX; break;
case DSP_GERMAN: id = TONE_GERMAN_RINGPBX; break;
case DSP_OLDGERMAN: id = TONE_GERMAN_OLDRINGPBX; break;
}
- } else if (!strcmp(tone, "busy"))
- {
+ } else if (!strcmp(tone, "busy")) {
busy:
- switch(options.dsptones) {
+ switch(dsp) {
case DSP_AMERICAN: id = TONE_AMERICAN_BUSY; break;
case DSP_GERMAN: id = TONE_GERMAN_BUSY; break;
case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
}
- } else if (!strcmp(tone, "release"))
- {
+ } else if (!strcmp(tone, "release")) {
hangup:
- switch(options.dsptones) {
+ switch(dsp) {
case DSP_AMERICAN: id = TONE_AMERICAN_HANGUP; break;
case DSP_GERMAN: id = TONE_GERMAN_HANGUP; break;
case DSP_OLDGERMAN: id = TONE_GERMAN_OLDHANGUP; break;
goto hangup;
else if (!strcmp(tone, "cause_11"))
goto busy;
- else if (!strcmp(tone, "cause_22"))
- {
- switch(options.dsptones) {
+ else if (!strcmp(tone, "cause_22")) {
+ switch(dsp) {
case DSP_AMERICAN: id = TONE_SPECIAL_INFO; break;
case DSP_GERMAN: id = TONE_GERMAN_GASSENBESETZT; break;
case DSP_OLDGERMAN: id = TONE_GERMAN_OLDBUSY; break;
goto nodsp;
setdsp:
- if (p_m_tone != id)
- {
+ if (p_m_tone != id) {
/* set new tone */
p_m_tone = id;
PDEBUG(DEBUG_ISDN, "we set tone to id=%d.\n", p_m_tone);
//extern struct lcr_msg *dddebug;
void PmISDN::message_mISDNsignal(unsigned int epoint_id, int message_id, union parameter *param)
{
- switch(param->mISDNsignal.message)
- {
+ switch(param->mISDNsignal.message) {
case mISDNSIGNAL_VOLUME:
- if (p_m_tx_gain != param->mISDNsignal.tx_gain)
- {
+ if (p_m_tx_gain != param->mISDNsignal.tx_gain) {
p_m_tx_gain = param->mISDNsignal.tx_gain;
PDEBUG(DEBUG_BCHANNEL, "we change tx-volume to shift=%d.\n", p_m_tx_gain);
if (p_m_b_index > -1)
ph_control(p_m_mISDNport, this, p_m_mISDNport->b_socket[p_m_b_index], DSP_VOL_CHANGE_TX, p_m_tx_gain, "DSP-TX_GAIN", p_m_tx_gain);
} else
PDEBUG(DEBUG_BCHANNEL, "we already have tx-volume shift=%d.\n", p_m_rx_gain);
- if (p_m_rx_gain != param->mISDNsignal.rx_gain)
- {
+ if (p_m_rx_gain != param->mISDNsignal.rx_gain) {
p_m_rx_gain = param->mISDNsignal.rx_gain;
PDEBUG(DEBUG_BCHANNEL, "we change rx-volume to shift=%d.\n", p_m_rx_gain);
if (p_m_b_index > -1)
case mISDNSIGNAL_CONF:
//if (dddebug) PDEBUG(DEBUG_ISDN, "dddebug = %d\n", dddebug->type);
//tone if (!p_m_tone && p_m_conf!=param->mISDNsignal.conf)
- if (p_m_conf != param->mISDNsignal.conf)
- {
+ if (p_m_conf != param->mISDNsignal.conf) {
p_m_conf = param->mISDNsignal.conf;
PDEBUG(DEBUG_BCHANNEL, "we change conference to conf=%d.\n", p_m_conf);
if (p_m_b_index > -1)
break;
case mISDNSIGNAL_JOINDATA:
- if (p_m_joindata != param->mISDNsignal.joindata)
- {
+ if (p_m_joindata != param->mISDNsignal.joindata) {
p_m_joindata = param->mISDNsignal.joindata;
PDEBUG(DEBUG_BCHANNEL, "we change to joindata=%d.\n", p_m_joindata);
} else
break;
case mISDNSIGNAL_DELAY:
- if (p_m_delay != param->mISDNsignal.delay)
- {
+ if (p_m_delay != param->mISDNsignal.delay) {
p_m_delay = param->mISDNsignal.delay;
PDEBUG(DEBUG_BCHANNEL, "we change delay mode to delay=%d.\n", p_m_delay);
if (p_m_b_index > -1)
{
struct lcr_msg *message;
- switch(param->crypt.type)
- {
+ switch(param->crypt.type) {
case CC_ACTBF_REQ: /* activate blowfish */
p_m_crypt = 1;
p_m_crypt_key_len = param->crypt.len;
- if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key))
- {
+ if (p_m_crypt_key_len > (int)sizeof(p_m_crypt_key)) {
PERROR("PmISDN(%s) key too long %d > %d\n", p_name, p_m_crypt_key_len, sizeof(p_m_crypt_key));
message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CRYPT);
message->param.crypt.type = CC_ERROR_IND;
case CR_MESSAGE_REQ: /* send message */
p_m_crypt_msg_len = cryptman_encode_bch(param->crypt.data, param->crypt.len, p_m_crypt_msg, sizeof(p_m_crypt_msg));
- if (!p_m_crypt_msg_len)
- {
+ if (!p_m_crypt_msg_len) {
PERROR("PmISDN(%s) message too long %d > %d\n", p_name, param->crypt.len-1, sizeof(p_m_crypt_msg));
break;
}
p_m_crypt_msg_loops = 6; /* enable */
#if 0
/* disable txmix, or we get corrupt data due to audio process */
- if (p_m_txmix && p_m_b_index>=0 && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT)
- {
+ if (p_m_txmix && p_m_b_index>=0 && p_m_mISDNport->b_mode[p_m_b_index] == B_MODE_TRANSPARENT) {
PDEBUG(DEBUG_BCHANNEL, "for sending CR_MESSAGE_REQ, we reset txmix from txmix=%d.\n", p_m_txmix);
ph_control(p_m_mISDNport, this, p_mISDNport->b_socket[p_m_b_index], DSP_MIX_OFF, 0, "DSP-TXMIX", 0);
}
if (Port::message_epoint(epoint_id, message_id, param))
return(1);
- switch(message_id)
- {
+ switch(message_id) {
case MESSAGE_DATA: /* tx-data from upper layer */
txfromup(param->data.data, param->data.len);
return(1);
/* process all ports */
mISDNport = mISDNport_first;
- while(mISDNport)
- {
+ while(mISDNport) {
/* process all bchannels */
i = 0;
- while(i < mISDNport->b_num)
- {
+ while(i < mISDNport->b_num) {
/* process timer events for bchannel handling */
- if (mISDNport->b_timer[i])
- {
+ if (mISDNport->b_timer[i]) {
if (mISDNport->b_timer[i] <= now_d)
bchannel_event(mISDNport, i, B_EVENT_TIMEOUT);
}
/* handle port of bchannel */
isdnport=mISDNport->b_port[i];
- if (isdnport)
- {
+ if (isdnport) {
/* call bridges in user space OR crypto OR recording */
- if (isdnport->p_m_joindata || isdnport->p_m_crypt_msg_loops || isdnport->p_m_crypt_listen || isdnport->p_record)
- {
+ if (isdnport->p_m_joindata || isdnport->p_m_crypt_msg_loops || isdnport->p_m_crypt_listen || isdnport->p_record) {
/* rx IS required */
- if (isdnport->p_m_rxoff)
- {
+ if (isdnport->p_m_rxoff) {
/* turn on RX */
isdnport->p_m_rxoff = 0;
PDEBUG(DEBUG_BCHANNEL, "%s: receive data is required, so we turn them on\n", __FUNCTION__);
ph_control(mISDNport, isdnport, mISDNport->b_socket[i], DSP_RECEIVE_ON, 0, "DSP-RXOFF", 0);
return(1);
}
- } else
- {
+ } else {
/* rx NOT required */
- if (!isdnport->p_m_rxoff)
- {
+ if (!isdnport->p_m_rxoff) {
/* turn off RX */
isdnport->p_m_rxoff = 1;
PDEBUG(DEBUG_BCHANNEL, "%s: receive data is not required, so we turn them off\n", __FUNCTION__);
}
}
/* recording */
- if (isdnport->p_record)
- {
+ if (isdnport->p_record) {
/* txdata IS required */
- if (!isdnport->p_m_txdata)
- {
+ if (!isdnport->p_m_txdata) {
/* turn on RX */
isdnport->p_m_txdata = 1;
PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is required, so we turn them on\n", __FUNCTION__);
ph_control(mISDNport, isdnport, mISDNport->b_socket[i], DSP_TXDATA_ON, 0, "DSP-TXDATA", 1);
return(1);
}
- } else
- {
+ } else {
/* txdata NOT required */
- if (isdnport->p_m_txdata)
- {
+ if (isdnport->p_m_txdata) {
/* turn off RX */
isdnport->p_m_txdata = 0;
PDEBUG(DEBUG_BCHANNEL, "%s: transmit data is not required, so we turn them off\n", __FUNCTION__);
}
/* handle message from bchannel */
- if (mISDNport->b_socket[i] > -1)
- {
+ if (mISDNport->b_socket[i] > -1) {
ret = recv(mISDNport->b_socket[i], buffer, sizeof(buffer), 0);
- if (ret >= (int)MISDN_HEADER_LEN)
- {
+ if (ret >= (int)MISDN_HEADER_LEN) {
work = 1;
- switch(hh->prim)
- {
+ switch(hh->prim) {
/* we don't care about confirms, we use rx data to sync tx */
case PH_DATA_CNF:
break;
default:
PERROR("child message not handled: prim(0x%x) socket(%d) msg->len(%d)\n", hh->prim, mISDNport->b_socket[i], ret-MISDN_HEADER_LEN);
}
- } else
- {
+ } else {
if (ret < 0 && errno != EWOULDBLOCK)
PERROR("Read from port %d, index %d failed with return code %d\n", mISDNport->portnum, i, ret);
}
}
/* handle queued up-messages (d-channel) */
- if (!mISDNport->gsm)
- {
- while ((mb = mdequeue(&mISDNport->upqueue)))
- {
+ if (!mISDNport->gsm) {
+ while ((mb = mdequeue(&mISDNport->upqueue))) {
l3m = &mb->l3;
- switch(l3m->type)
- {
+ switch(l3m->type) {
case MPH_ACTIVATE_IND:
- if (mISDNport->l1link != 1)
- {
+ if (mISDNport->l1link != 1) {
l1l2l3_trace_header(mISDNport, NULL, L1_ACTIVATE_IND, DIRECTION_IN);
end_trace();
mISDNport->l1link = 1;
break;
case MPH_DEACTIVATE_IND:
- if (mISDNport->l1link != 0)
- {
+ if (mISDNport->l1link != 0) {
l1l2l3_trace_header(mISDNport, NULL, L1_DEACTIVATE_IND, DIRECTION_IN);
end_trace();
mISDNport->l1link = 0;
case MPH_INFORMATION_IND:
PDEBUG(DEBUG_ISDN, "Received MPH_INFORMATION_IND for port %d (%s).\n", mISDNport->portnum, mISDNport->ifport->interface->name);
- switch (l3m->pid)
- {
+ switch (l3m->pid) {
case L1_SIGNAL_LOS_ON:
mISDNport->los = 1;
break;
mISDNport->l2link = 1;
if (l3m->pid < 128)
mISDNport->l2mask[l3m->pid >> 3] |= (1 << (l3m->pid & 7));
- if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127)
- {
- if (mISDNport->l2establish)
- {
+ if ((!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
+ if (mISDNport->l2establish) {
mISDNport->l2establish = 0;
PDEBUG(DEBUG_ISDN, "the link became active before l2establish timer expiry.\n");
}
case MT_L2RELEASE:
if (l3m->pid < 128)
mISDNport->l2mask[l3m->pid >> 3] &= ~(1 << (l3m->pid & 7));
- if (!mISDNport->l2establish)
- {
+ if (!mISDNport->l2establish) {
l1l2l3_trace_header(mISDNport, NULL, L2_RELEASE_IND, DIRECTION_IN);
add_trace("tei", NULL, "%d", l3m->pid);
end_trace();
if (!mISDNport->ntmode || mISDNport->ptp)
mISDNport->l2link = 0;
}
- if (!mISDNport->gsm && (!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127)
- {
- if (!mISDNport->l2establish && mISDNport->l2hold)
- {
+ if (!mISDNport->gsm && (!mISDNport->ntmode || mISDNport->ptp) && l3m->pid < 127) {
+ if (!mISDNport->l2establish && mISDNport->l2hold) {
PDEBUG(DEBUG_ISDN, "set timer and establish.\n");
time(&mISDNport->l2establish);
mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
#endif
/* layer 2 establish timer */
- if (mISDNport->l2establish)
- {
- if (now-mISDNport->l2establish > 5)
- {
+ if (mISDNport->l2establish) {
+ if (now-mISDNport->l2establish > 5) {
mISDNport->l2establish = 0;
- if (!mISDNport->gsm && mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode))
- {
+ if (!mISDNport->gsm && mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
PDEBUG(DEBUG_ISDN, "the L2 establish timer expired, we try to establish the link portnum=%d.\n", mISDNport->portnum);
mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
* we must check if we get a reply and we know that we lcr is currently
* locked.
*/
- if (cmd==MT_ASSIGN && (pid&MISDN_PID_CR_FLAG) && (pid>>16)==MISDN_CES_MASTER)
- {
+ if (cmd==MT_ASSIGN && (pid&MISDN_PID_CR_FLAG) && (pid>>16)==MISDN_CES_MASTER) {
/* let's do some checking if someone changes stack behaviour */
if (mt_assign_pid != 0)
FATAL("someone played with the mISDNuser stack. MT_ASSIGN not currently expected.\n");
return(0);
}
/* queue message, create, if required */
- if (!l3m)
- {
+ if (!l3m) {
l3m = alloc_l3_msg();
if (!l3m)
FATAL("No memory for layer 3 message\n");
int port = 0, ret;
/* resolve name */
- while (port < cnt)
- {
+ while (port < cnt) {
devinfo.id = port;
ret = ioctl(sock, IMGETDEVINFO, &devinfo);
if (ret < 0)
/* check port counts */
ret = ioctl(mISDNsocket, IMGETCOUNT, &cnt);
- if (ret < 0)
- {
+ if (ret < 0) {
fprintf(stderr, "Cannot get number of mISDN devices. (ioctl IMGETCOUNT failed ret=%d)\n", ret);
return(NULL);
}
- if (cnt <= 0)
- {
+ if (cnt <= 0) {
PERROR_RUNTIME("Found no card. Please be sure to load card drivers.\n");
return(NULL);
}
- if (port < 0)
- {
+ if (port < 0) {
port = mISDN_getportbyname(mISDNsocket, cnt, portname);
- if (port < 0)
- {
+ if (port < 0) {
if (gsm)
PERROR_RUNTIME("Port name '%s' not found, did you load loopback interface for GSM?.\n", portname);
else
}
// note: 'port' has still the port number
}
- if (port>cnt || port<0)
- {
+ if (port>cnt || port<0) {
PERROR_RUNTIME("Port (%d) given at 'ports' (options.conf) is out of existing port range (%d-%d)\n", port, 0, cnt);
return(NULL);
}
pri = bri = pots = nt = te = 0;
devinfo.id = port;
ret = ioctl(mISDNsocket, IMGETDEVINFO, &devinfo);
- if (ret < 0)
- {
+ if (ret < 0) {
PERROR_RUNTIME("Cannot get device information for port %d. (ioctl IMGETDEVINFO failed ret=%d)\n", port, ret);
return(NULL);
}
- if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0))
- {
+ if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0)) {
bri = 1;
te = 1;
}
- if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0))
- {
+ if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0)) {
bri = 1;
nt = 1;
}
- if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1))
- {
+ if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1)) {
pri = 1;
te = 1;
}
- if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1))
- {
+ if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1)) {
pri = 1;
nt = 1;
}
#ifdef ISDN_P_FXS
- if (devinfo.Dprotocols & (1 << ISDN_P_FXS))
- {
+ if (devinfo.Dprotocols & (1 << ISDN_P_FXS)) {
pots = 1;
te = 1;
}
#endif
#ifdef ISDN_P_FXO
- if (devinfo.Dprotocols & (1 << ISDN_P_FXO))
- {
+ if (devinfo.Dprotocols & (1 << ISDN_P_FXO)) {
pots = 1;
nt = 1;
}
#endif
- if (force_nt && !nt)
- {
+ if (force_nt && !nt) {
PERROR_RUNTIME("Port %d does not support NT-mode\n", port);
return(NULL);
}
- if (bri && pri)
- {
+ if (bri && pri) {
PERROR_RUNTIME("Port %d supports BRI and PRI?? What kind of controller is that?. (Can't use this!)\n", port);
return(NULL);
}
- if (pots && !bri && !pri)
- {
+ if (pots && !bri && !pri) {
PERROR_RUNTIME("Port %d supports POTS, LCR does not!\n", port);
return(NULL);
}
- if (!bri && !pri)
- {
+ if (!bri && !pri) {
PERROR_RUNTIME("Port %d does not support BRI nor PRI!\n", port);
return(NULL);
}
- if (!nt && !te)
- {
+ if (!nt && !te) {
PERROR_RUNTIME("Port %d does not support NT-mode nor TE-mode!\n", port);
return(NULL);
}
nt = 0;
/* check for double use of port */
- if (nt)
- {
+ if (nt) {
mISDNport = mISDNport_first;
- while(mISDNport)
- {
+ while(mISDNport) {
if (mISDNport->portnum == port)
break;
mISDNport = mISDNport->next;
}
- if (mISDNport)
- {
+ if (mISDNport) {
PERROR_RUNTIME("Port %d already in use by LCR. You can't use a NT port multiple times.\n", port);
return(NULL);
}
}
/* check for continous channelmap with no bchannel on slot 16 */
- if (test_channelmap(0, devinfo.channelmap))
- {
+ if (test_channelmap(0, devinfo.channelmap)) {
PERROR_RUNTIME("Port %d provides channel 0, but we cannot access it!\n", port);
return(NULL);
}
i = 1;
- while(i < (int)devinfo.nrbchan + 1)
- {
+ while(i < (int)devinfo.nrbchan + 1) {
if (i == 16) {
- if (test_channelmap(i, devinfo.channelmap))
- {
+ if (test_channelmap(i, devinfo.channelmap)) {
PERROR("Port %d provides bchannel 16. Pleas upgrade mISDN, if this port is mISDN loopback interface.\n", port);
return(NULL);
}
- } else
- {
- if (!test_channelmap(i, devinfo.channelmap))
- {
+ } else {
+ if (!test_channelmap(i, devinfo.channelmap)) {
PERROR_RUNTIME("Port %d has no channel on slot %d!\n", port, i);
return(NULL);
}
while(*mISDNportp)
mISDNportp = &((*mISDNportp)->next);
mISDNport = (struct mISDNport *)MALLOC(sizeof(struct mISDNport));
- if (gsm)
- {
+ if (gsm) {
/* gsm audio is always active */
mISDNport->l1link = 1;
mISDNport->l2link = 1;
- } else
- {
+ } else {
mISDNport->l1link = -1;
mISDNport->l2link = -1;
}
ptp = 1;
/* set l2hold */
- switch (l2hold)
- {
+ switch (l2hold) {
case -1: // off
l2hold = 0;
break;
if (l2hold) // supports layer 2 hold
prop |= (1 << MISDN_FLG_L2_HOLD);
/* open layer 3 and init upqueue */
- if (gsm)
- {
+ if (gsm) {
unsigned long on = 1;
struct sockaddr_mISDN addr;
- if (devinfo.nrbchan < 8)
- {
+ if (devinfo.nrbchan < 8) {
PERROR_RUNTIME("GSM port %d must have at least 8 b-channels.\n", port);
mISDNport_close(mISDNport);
return(NULL);
}
- if ((mISDNport->lcr_sock = socket(PF_ISDN, SOCK_DGRAM, ISDN_P_NT_S0)) < 0)
- {
+ if ((mISDNport->lcr_sock = socket(PF_ISDN, SOCK_DGRAM, ISDN_P_NT_S0)) < 0) {
PERROR_RUNTIME("GSM port %d failed to open socket.\n", port);
mISDNport_close(mISDNport);
return(NULL);
}
/* set nonblocking io */
- if (ioctl(mISDNport->lcr_sock, FIONBIO, &on) < 0)
- {
+ if (ioctl(mISDNport->lcr_sock, FIONBIO, &on) < 0) {
PERROR_RUNTIME("GSM port %d failed to set socket into nonblocking io.\n", port);
mISDNport_close(mISDNport);
return(NULL);
addr.family = AF_ISDN;
addr.dev = port;
addr.channel = 0;
- if (bind(mISDNport->lcr_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
- {
+ if (bind(mISDNport->lcr_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
PERROR_RUNTIME("GSM port %d failed to bind socket. (errno %d)\n", port, errno);
mISDNport_close(mISDNport);
return(NULL);
}
- } else
- {
+ } else {
/* queue must be initializes, because l3-thread may send messages during open_layer3() */
mqueue_init(&mISDNport->upqueue);
mISDNport->ml3 = open_layer3(port, protocol, prop , do_layer3, mISDNport);
- if (!mISDNport->ml3)
- {
+ if (!mISDNport->ml3) {
mqueue_purge(&mISDNport->upqueue);
PERROR_RUNTIME("open_layer3() failed for port %d\n", port);
start_trace(port,
mISDNport->l2hold = l2hold;
PDEBUG(DEBUG_ISDN, "Port has %d b-channels.\n", mISDNport->b_num);
i = 0;
- while(i < mISDNport->b_num)
- {
+ while(i < mISDNport->b_num) {
mISDNport->b_state[i] = B_STATE_IDLE;
mISDNport->b_socket[i] = -1;
i++;
}
/* if ptp, pull up the link */
- if (!mISDNport->gsm && mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode))
- {
+ if (!mISDNport->gsm && mISDNport->l2hold && (mISDNport->ptp || !mISDNport->ntmode)) {
mISDNport->ml3->to_layer3(mISDNport->ml3, MT_L2ESTABLISH, 0, NULL);
l1l2l3_trace_header(mISDNport, NULL, L2_ESTABLISH_REQ, DIRECTION_OUT);
add_trace("tei", NULL, "%d", 0);
/* remove all port instance that are linked to this mISDNport */
port = port_first;
- while(port)
- {
- if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN)
- {
+ while(port) {
+ if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN) {
isdnport = (class PmISDN *)port;
- if (isdnport->p_m_mISDNport)
- {
+ if (isdnport->p_m_mISDNport) {
PDEBUG(DEBUG_ISDN, "port %s uses mISDNport %d, destroying it.\n", isdnport->p_name, mISDNport->portnum);
delete isdnport;
}
}
/* only if we are already part of interface */
- if (mISDNport->ifport)
- {
+ if (mISDNport->ifport) {
start_trace(mISDNport->portnum,
mISDNport->ifport->interface,
NULL,
/* free bchannels */
i = 0;
- while(i < mISDNport->b_num)
- {
- if (mISDNport->b_socket[i] > -1)
- {
+ while(i < mISDNport->b_num) {
+ if (mISDNport->b_socket[i] > -1) {
_bchannel_destroy(mISDNport, i);
PDEBUG(DEBUG_BCHANNEL, "freeing %s port %d bchannel (index %d).\n", (mISDNport->ntmode)?"NT":"TE", mISDNport->portnum, i);
}
}
/* close layer 3, if open */
- if (!mISDNport->gsm && mISDNport->ml3)
- {
+ if (!mISDNport->gsm && mISDNport->ml3) {
close_layer3(mISDNport->ml3);
}
/* close gsm socket, if open */
- if (mISDNport->gsm && mISDNport->lcr_sock > -1)
- {
+ if (mISDNport->gsm && mISDNport->lcr_sock > -1) {
close(mISDNport->lcr_sock);
}
/* remove from list */
mISDNportp = &mISDNport_first;
- while(*mISDNportp)
- {
- if (*mISDNportp == mISDNport)
- {
+ while(*mISDNportp) {
+ if (*mISDNportp == mISDNport) {
*mISDNportp = (*mISDNportp)->next;
mISDNportp = NULL;
break;
* if transmit buffer in DSP module is empty,
* preload it to DSP_LOAD to prevent jitter gaps.
*/
- if (p_m_load==0 && ISDN_LOAD>0)
- {
+ if (p_m_load==0 && ISDN_LOAD>0) {
hh->prim = PH_DATA_REQ;
hh->id = 0;
memset(buf+MISDN_HEADER_LEN, (options.law=='a')?0x2a:0xff, ISDN_LOAD);
"tones_american", /* directory of tones */
"", /* directories of tones to fetch */
"", /* dummy caller id */
- 0, /* use tones by dsp.o */
0, /* by default use priority 0 */
"lcr@your.machine", /* source mail adress */
"/var/tmp", /* path of lock files */
SPRINT(filename, "%s/options.conf", CONFIG_DATA);
- if (!(fp=fopen(filename,"r")))
- {
+ if (!(fp=fopen(filename,"r"))) {
SPRINT(options_error, "Cannot open %s\n",filename);
return(0);
}
line=0;
- while((fgets(buffer,sizeof(buffer),fp)))
- {
+ while((fgets(buffer,sizeof(buffer),fp))) {
line++;
buffer[sizeof(buffer)-1]=0;
if (buffer[0]) buffer[strlen(buffer)-1]=0;
p=buffer;
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
option[0]=0;
i=0; /* read option */
- while(*p > 32)
- {
- if (i+1 >= sizeof(option))
- {
+ while(*p > 32) {
+ if (i+1 >= sizeof(option)) {
SPRINT(options_error, "Error in %s (line %d): option too long.\n",filename,line);
goto error;
}
option[i++] = *p++;
}
- while(*p <= 32) /* skip spaces */
- {
+ while(*p <= 32) { /* skip spaces */
if (*p == 0)
break;
p++;
}
param[0]=0;
- if (*p!=0 && *p!='#') /* param */
- {
+ if (*p!=0 && *p!='#') { /* param */
i=0; /* read param */
- while(*p > 31)
- {
- if (i+1 >= sizeof(param))
- {
+ while(*p > 31) {
+ if (i+1 >= sizeof(param)) {
SPRINT(options_error, "Error in %s (line %d): param too long.\n",filename,line);
goto error;
}
/* at this point we have option and param */
/* check option */
- if (!strcmp(option,"nt_if") || !strcmp(option,"te_if"))
- {
+ if (!strcmp(option,"nt_if") || !strcmp(option,"te_if")) {
SPRINT(options_error, "Error in %s (line %d): obsolete option %s. Use multiple 'port' options to define ports to use.\n",filename,line,option);
goto error;
} else
- if (!strcmp(option,"debug"))
- {
- if (param[0]==0)
- {
+ if (!strcmp(option,"debug")) {
+ if (param[0]==0) {
SPRINT(options_error, "Error in %s (line %d): parameter for option %s missing.\n",filename,line,option);
goto error;
}
options.deb = strtol(param, NULL, 0);
} else
- if (!strcmp(option,"log"))
- {
- if (param[0]==0)
- {
+ if (!strcmp(option,"log")) {
+ if (param[0]==0) {
SPRINT(options_error, "Error in %s (line %d): parameter for option %s missing.\n",filename,line, option);
goto error;
}
SCPY(options.log, param);
} else
- if (!strcmp(option,"alaw"))
- {
+ if (!strcmp(option,"alaw")) {
options.law = 'a';
} else
- if (!strcmp(option,"ulaw"))
- {
+ if (!strcmp(option,"ulaw")) {
options.law = 'u';
} else
- if (!strcmp(option,"tones_dir"))
- {
- if (param[0]==0)
- {
+ if (!strcmp(option,"tones_dir")) {
+ if (param[0]==0) {
SPRINT(options_error, "Error in %s (line %d): parameter for option %s missing.\n",filename,line,option);
goto error;
}
SCPY(options.tones_dir, param);
} else
- if (!strcmp(option,"fetch_tones"))
- {
- if (param[0]==0)
- {
+ if (!strcmp(option,"fetch_tones")) {
+ if (param[0]==0) {
SPRINT(options_error, "Error in %s (line %d): parameter for option %s missing.\n",filename,line,option);
goto error;
}
SCPY(options.fetch_tones, param);
} else
- if (!strcmp(option,"extensions_dir"))
- {
+ if (!strcmp(option,"extensions_dir")) {
// obsolete
} else
- if (!strcmp(option,"national"))
- {
+ if (!strcmp(option,"national")) {
SCPY(options.national, param);
} else
- if (!strcmp(option,"international"))
- {
+ if (!strcmp(option,"international")) {
SCPY(options.international, param);
} else
- if (!strcmp(option,"dummyid"))
- {
+ if (!strcmp(option,"dummyid")) {
SCPY(options.dummyid, param);
} else
- if (!strcmp(option,"dsptones"))
- {
- if (!strcasecmp(param, "american"))
- options.dsptones = DSP_AMERICAN;
- else if (!strcasecmp(param, "german"))
- options.dsptones = DSP_GERMAN;
- else if (!strcasecmp(param, "oldgerman"))
- options.dsptones = DSP_OLDGERMAN;
- else if (!strcasecmp(param, "none"))
- options.dsptones = DSP_NONE;
- else {
- SPRINT(options_error, "Error in %s (line %d): parameter for option %s missing.\n",filename,line,option);
- goto error;
- }
-
+ if (!strcmp(option,"dsptones")) {
+ SPRINT(options_error, "Error in %s (line %d): parameter 'dsptones' is obsolete. Just define the tones (american,german,oldgerman) at 'tones_dir' option.\n",filename,line,option);
+ goto error;
} else
- if (!strcmp(option,"schedule"))
- {
+ if (!strcmp(option,"schedule")) {
options.schedule = atoi(param);
- if (options.schedule < 0)
- {
+ if (options.schedule < 0) {
SPRINT(options_error, "Error in %s (line %d): parameter for option %s must be at least '0'.\n", filename,line,option);
goto error;
}
- if (options.schedule > 99)
- {
+ if (options.schedule > 99) {
SPRINT(options_error, "Error in %s (line %d): parameter for option %s must be '99' or less.\n", filename,line,option);
goto error;
}
} else
- if (!strcmp(option,"email"))
- {
- if (param[0]==0)
- {
+ if (!strcmp(option,"email")) {
+ if (param[0]==0) {
SPRINT(options_error, "Error in %s (line %d): parameter for option %s missing.\n", filename,line,option);
goto error;
}
SCPY(options.email, param);
} else
- if (!strcmp(option,"lock"))
- {
- if (param[0]==0)
- {
+ if (!strcmp(option,"lock")) {
+ if (param[0]==0) {
SPRINT(options_error, "Error in %s (line %d): parameter for option %s missing.\n",filename,line,option);
goto error;
}
SCPY(options.lock, param);
} else
- if (!strcmp(option,"socketrights"))
- {
+ if (!strcmp(option,"socketrights")) {
options.socketrights = strtol(param, NULL, 0);
} else
- if (!strcmp(option,"gsm"))
- {
+ if (!strcmp(option,"gsm")) {
options.gsm = 1;
- } else
- {
+ } else {
SPRINT(options_error, "Error in %s (line %d): wrong option keyword %s.\n", filename,line,option);
goto error;
}
}
-#if 0
- if (!options.dsptones)
- {
- SPRINT(options_error, "Error in %s (line %d): option 'dsptones' missing.\n", filename);
- goto error;
- }
-#endif
- if (!options.tones_dir[0])
- {
+ if (!options.tones_dir[0]) {
SPRINT(options_error, "Error in %s (line %d): option 'tones_dir' with parameter missing.\n", filename);
goto error;
}
char tones_dir[64]; /* directory of all tones/patterns */
char fetch_tones[256]; /* directories of tones to fetch */
char dummyid[32]; /* caller id for external calls if not available */
- int dsptones; /* tones will be generated via dsp.o 1=american 2=ger */
int schedule; /* run process in realtime @ given priority */
char email[128]; /* source email address */
char lock[128]; /* path of lock files */
temp = p_epointlist;
tempp = &p_epointlist;
- while(temp)
- {
+ while(temp) {
if (temp == epointlist)
break;
tempp = &temp->next;
temp = temp->next;
}
- if (temp == 0)
- {
+ if (temp == 0) {
PERROR("SOFTWARE ERROR: epointlist not in port's list.\n");
return;
}
temp = p_epointlist;
tempp = &p_epointlist;
- while(temp)
- {
+ while(temp) {
if (temp->epoint_id == epoint_id)
break;
tempp = &temp->next;
temp = temp->next;
}
- if (temp == 0)
- {
+ if (temp == 0) {
PERROR("epoint_id not in port's list.\n");
return;
}
/* initialize object */
if (settings)
memcpy(&p_settings, settings, sizeof(struct port_settings));
- else
- {
+ else {
memset(&p_settings, 0, sizeof(p_settings));
- SCPY(p_settings.tones_dir, options.tones_dir);
}
SCPY(p_name, portname);
- SCPY(p_tone_dir, p_settings.tones_dir); // just to be sure
+ p_tone_dir[0] = '\0';
p_type = type;
p_serial = port_serial++;
p_tone_fh = -1;
next = NULL;
temp = port_first;
tempp = &port_first;
- while(temp)
- {
+ while(temp) {
tempp = &temp->next;
temp = temp->next;
}
PDEBUG(DEBUG_PORT, "removing port of type %d, name '%s'\n", p_type, p_name);
/* disconnect port from endpoint */
- while(p_epointlist)
- {
+ while(p_epointlist) {
/* send disconnect */
message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
message->param.disconnectinfo.cause = 16;
/* remove port from chain */
temp=port_first;
tempp=&port_first;
- while(temp)
- {
+ while(temp) {
if (temp == this)
break;
tempp = &temp->next;
*tempp=this->next;
/* close open tones file */
- if (p_tone_fh >= 0)
- {
+ if (p_tone_fh >= 0) {
close(p_tone_fh);
p_tone_fh = -1;
fhuse--;
{
class Port *port = port_first;
- while(port)
- {
+ while(port) {
//printf("comparing: '%s' with '%s'\n", name, port->name);
if (port->p_serial == port_id)
return(port);
if (name == NULL)
name = "";
-#if 0
- /* if tones is jingle, store next tone */
- if ((p_tone_fh >= 0 || p_tone_fetched)
- && (!strcmp(p_tone_name, "left") || !strcmp(p_tone_name, "joined")))
- {
- SCPY(p_tone_dir, dir);
- SCPY(p_tone_name, name);
- return;
- }
-#endif
+ if (!dir && !dir[0])
+ dir = options.tones_dir; /* just in case we have no PmISDN instance */
/* no counter, no eof, normal speed */
p_tone_counter = 0;
p_tone_speed = 1;
p_tone_codec = CODEC_LAW;
- if (p_tone_fh >= 0)
- {
+ if (p_tone_fh >= 0) {
close(p_tone_fh);
p_tone_fh = -1;
fhuse--;
}
p_tone_fetched = NULL;
- if (name[0])
- {
- if (name[0] == '/')
- {
+ if (name[0]) {
+ if (name[0] == '/') {
SPRINT(p_tone_name, "%s", name);
p_tone_dir[0] = '\0';
- } else
- {
+ } else {
SCPY(p_tone_dir, dir);
SCPY(p_tone_name, name);
}
- } else
- {
+ } else {
p_tone_name[0]= '\0';
p_tone_dir[0]= '\0';
return;
return;
/* now we check if the cause exists, otherwhise we use error tone. */
- if ((p_tone_fetched=open_tone_fetched(p_tone_dir, p_tone_name, &p_tone_codec, 0, 0)))
- {
+ if ((p_tone_fetched=open_tone_fetched(p_tone_dir, p_tone_name, &p_tone_codec, 0, 0))) {
p_tone_fetched = NULL;
return;
}
SPRINT(filename, "%s_loop", p_tone_name);
- if ((p_tone_fetched=open_tone_fetched(p_tone_dir, filename, &p_tone_codec, 0, 0)))
- {
+ if ((p_tone_fetched=open_tone_fetched(p_tone_dir, filename, &p_tone_codec, 0, 0))) {
p_tone_fetched = NULL;
return;
}
SPRINT(filename, "%s/%s/%s", SHARE_DATA, p_tone_dir, p_tone_name);
- if ((fh=open_tone(filename, &p_tone_codec, 0, 0)) >= 0)
- {
+ if ((fh=open_tone(filename, &p_tone_codec, 0, 0)) >= 0) {
close(fh);
return;
}
SPRINT(filename, "%s/%s/%s_loop", SHARE_DATA, p_tone_dir, p_tone_name);
- if ((fh=open_tone(filename, &p_tone_codec, 0, 0)) >= 0)
- {
+ if ((fh=open_tone(filename, &p_tone_codec, 0, 0)) >= 0) {
close(fh);
return;
}
- if (!strcmp(name,"cause_00") || !strcmp(name,"cause_10"))
- {
+ if (!strcmp(name,"cause_00") || !strcmp(name,"cause_10")) {
PDEBUG(DEBUG_PORT, "PORT(%s) Given Cause 0x%s has no tone, using release tone\n", p_name, name+6);
SPRINT(p_tone_name,"release");
} else
- if (!strcmp(name,"cause_11"))
- {
+ if (!strcmp(name,"cause_11")) {
PDEBUG(DEBUG_PORT, "PORT(%s) Given Cause 0x%s has no tone, using busy tone\n", p_name, name+6);
SPRINT(p_tone_name,"busy");
- } else
- {
+ } else {
PDEBUG(DEBUG_PORT, "PORT(%s) Given Cause 0x%s has no tone, using error tone\n", p_name, name+6);
SPRINT(p_tone_name,"error");
}
p_tone_codec = CODEC_LAW;
p_tone_eof = 1;
- if (p_tone_fh >= 0)
- {
+ if (p_tone_fh >= 0) {
close(p_tone_fh);
p_tone_fh = -1;
fhuse--;
SPRINT(p_tone_name, name);
/* now we check if the cause exists, otherwhise we use error tone. */
- if (p_tone_dir[0])
- {
- if ((p_tone_fetched=open_tone_fetched(p_tone_dir, p_tone_name, &p_tone_codec, &p_tone_size, &p_tone_left)))
- {
+ if (p_tone_dir[0]) {
+ if ((p_tone_fetched=open_tone_fetched(p_tone_dir, p_tone_name, &p_tone_codec, &p_tone_size, &p_tone_left))) {
PDEBUG(DEBUG_PORT, "PORT(%s) opening fetched tone: %s\n", p_name, p_tone_name);
return;
}
SPRINT(filename, "%s/%s/%s", SHARE_DATA, p_tone_dir, p_tone_name);
- if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) >= 0)
- {
+ if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) >= 0) {
fhuse++;
PDEBUG(DEBUG_PORT, "PORT(%s) opening tone: %s\n", p_name, filename);
return;
}
- } else
- {
+ } else {
SPRINT(filename, "%s", p_tone_name);
- if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) >= 0)
- {
+ if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) >= 0) {
fhuse++;
PDEBUG(DEBUG_PORT, "PORT(%s) opening tone: %s\n", p_name, filename);
return;
p_tone_counter = 1;
/* seek */
- if (p_tone_name[0])
- {
+ if (p_tone_name[0]) {
/* send message with counter value */
- if (p_tone_size>=0 && ACTIVE_EPOINT(p_epointlist))
- {
+ if (p_tone_size>=0 && ACTIVE_EPOINT(p_epointlist)) {
message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_TONE_COUNTER);
message->param.counter.current = offset;
message->param.counter.max = p_tone_size;
return(0);
/* if the file pointer is not open, we open it */
- if (p_tone_fh<0 && p_tone_fetched==NULL)
- {
- if (p_tone_dir[0])
- {
+ if (p_tone_fh<0 && p_tone_fetched==NULL) {
+ if (p_tone_dir[0]) {
SPRINT(filename, "%s", p_tone_name);
/* if file does not exist */
- if (!(p_tone_fetched=open_tone_fetched(p_tone_dir, filename, &p_tone_codec, &p_tone_size, &p_tone_left)))
- {
+ if (!(p_tone_fetched=open_tone_fetched(p_tone_dir, filename, &p_tone_codec, &p_tone_size, &p_tone_left))) {
SPRINT(filename, "%s/%s/%s", SHARE_DATA, p_tone_dir, p_tone_name);
/* if file does not exist */
- if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) < 0)
- {
+ if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) < 0) {
PDEBUG(DEBUG_PORT, "PORT(%s) no tone: %s\n", p_name, filename);
goto try_loop;
}
fhuse++;
}
- } else
- {
+ } else {
SPRINT(filename, "%s", p_tone_name);
/* if file does not exist */
- if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) < 0)
- {
+ if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) < 0) {
PDEBUG(DEBUG_PORT, "PORT(%s) no tone: %s\n", p_name, filename);
goto try_loop;
}
read_more:
/* file descriptor is open read data */
tone_left_before = p_tone_left;
- if (p_tone_fh >= 0)
- {
+ if (p_tone_fh >= 0) {
l = read_tone(p_tone_fh, buffer, p_tone_codec, len, p_tone_size, &p_tone_left, p_tone_speed);
if (l<0 || l>len) /* paranoia */
l=0;
buffer += l;
len -= l;
}
- if (p_tone_fetched)
- {
+ if (p_tone_fetched) {
l = read_tone_fetched(&p_tone_fetched, buffer, len, p_tone_size, &p_tone_left, p_tone_speed);
if (l<0 || l>len) /* paranoia */
l=0;
}
/* if counter is enabled, we check if we have a change */
- if (p_tone_counter && p_tone_size>=0 && ACTIVE_EPOINT(p_epointlist))
- {
+ if (p_tone_counter && p_tone_size>=0 && ACTIVE_EPOINT(p_epointlist)) {
/* if we jumed to the next second */
- if (((p_tone_size-p_tone_left)/8000) != (p_tone_size-tone_left_before)/8000)
- {
+ if (((p_tone_size-p_tone_left)/8000) != (p_tone_size-tone_left_before)/8000) {
//printf("\nsize=%d left=%d\n\n",p_tone_size,p_tone_left);
struct lcr_msg *message;
message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_TONE_COUNTER);
if (len==0)
return(length-len);
- if (p_tone_fh >= 0)
- {
+ if (p_tone_fh >= 0) {
close(p_tone_fh);
p_tone_fh = -1;
fhuse--;
nodata=0;
/* if the file has 0-length */
- if (nodata>1)
- {
+ if (nodata>1) {
PDEBUG(DEBUG_PORT, "PORT(%s) 0-length loop: %s\n", p_name, filename);
p_tone_name[0]=0;
p_tone_dir[0]=0;
/* if eof is reached, or if the normal file cannot be opened, continue with the loop file if possible */
try_loop:
- if (p_tone_eof && ACTIVE_EPOINT(p_epointlist))
- {
+ if (p_tone_eof && ACTIVE_EPOINT(p_epointlist)) {
struct lcr_msg *message;
message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_TONE_EOF);
message_put(message);
}
- if (p_tone_dir[0])
- {
+ if (p_tone_dir[0]) {
/* if file does not exist */
SPRINT(filename, "%s_loop", p_tone_name);
- if (!(p_tone_fetched=open_tone_fetched(p_tone_dir, filename, &p_tone_codec, &p_tone_size, &p_tone_left)))
- {
+ if (!(p_tone_fetched=open_tone_fetched(p_tone_dir, filename, &p_tone_codec, &p_tone_size, &p_tone_left))) {
SPRINT(filename, "%s/%s/%s_loop", SHARE_DATA, p_tone_dir, p_tone_name);
/* if file does not exist */
- if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) < 0)
- {
+ if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) < 0) {
PDEBUG(DEBUG_PORT, "PORT(%s) no tone loop: %s\n",p_name, filename);
p_tone_dir[0] = '\0';
p_tone_name[0] = '\0';
}
fhuse++;
}
- } else
- {
+ } else {
SPRINT(filename, "%s_loop", p_tone_name);
/* if file does not exist */
- if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) < 0)
- {
+ if ((p_tone_fh=open_tone(filename, &p_tone_codec, &p_tone_size, &p_tone_left)) < 0) {
PDEBUG(DEBUG_PORT, "PORT(%s) no tone loop: %s\n",p_name, filename);
p_tone_dir[0] = '\0';
p_tone_name[0] = '\0';
int Port::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
{
/* check if we got audio data from one remote port */
- switch(message_id)
- {
+ switch(message_id) {
case MESSAGE_TONE: /* play tone */
PDEBUG(DEBUG_PORT, "PORT(%s) isdn port with (caller id %s) setting tone '%s' dir '%s'\n", p_name, p_callerinfo.id, param->tone.name, param->tone.dir);
set_tone(param->tone.dir,param->tone.name);
char dummyheader[8+4+8+sizeof(fmt)+8];
char filename[256];
- if (!extension)
- {
+ if (!extension) {
PERROR("Port(%d) not an extension\n", p_serial);
return(0);
}
SCPY(p_record_vbox_email, vbox_email);
p_record_vbox_email_file = vbox_email_file;
- if (p_record)
- {
+ if (p_record) {
PERROR("Port(%d) already recording\n", p_serial);
return(0);
}
SPRINT(filename, "%s/%s/vbox", EXTENSION_DATA, p_record_extension);
else
SPRINT(filename, "%s/%s/recordings", EXTENSION_DATA, p_record_extension);
- if (mkdir(filename, 0755) < 0)
- {
- if (errno != EEXIST)
- {
+ if (mkdir(filename, 0755) < 0) {
+ if (errno != EEXIST) {
PERROR("Port(%d) cannot create directory '%s'\n", p_serial, filename);
return(0);
}
UPRINT(strchr(filename,'\0'), "/announcement");
else
UPRINT(strchr(filename,'\0'), "/%04d-%02d-%02d_%02d%02d%02d", now_tm->tm_year+1900, now_tm->tm_mon+1, now_tm->tm_mday, now_tm->tm_hour, now_tm->tm_min, now_tm->tm_sec);
- if (vbox == 2)
- {
+ if (vbox == 2) {
p_record_vbox_year = now_tm->tm_year;
p_record_vbox_mon = now_tm->tm_mon;
p_record_vbox_mday = now_tm->tm_mday;
/* check, if file exists (especially when an extension calls the same extension) */
if (vbox != 1)
- if ((p_record = fopen(filename, "r")))
- {
+ if ((p_record = fopen(filename, "r"))) {
fclose(p_record);
SCAT(filename, "_2nd");
}
p_record = fopen(filename, "w");
- if (!p_record)
- {
+ if (!p_record) {
PERROR("Port(%d) cannot record because file cannot be opened '%s'\n", p_serial, filename);
return(0);
}
p_record_vbox = vbox;
p_record_skip = skip;
p_record_length = 0;
- switch(p_record_type)
- {
+ switch(p_record_type) {
case CODEC_MONO:
case CODEC_STEREO:
case CODEC_8BIT:
SCPY(number, p_dialinginfo.id);
SCPY(callerid, numberrize_callerinfo(callerinfo.id, callerinfo.ntype, options.national, options.international));
- if (callerid[0] == '\0')
- {
+ if (callerid[0] == '\0') {
if (callerinfo.present == INFO_PRESENT_RESTRICTED)
UCPY(callerid,"anonymous");
else
*(p++) = 'x';
i = 0;
ii = strlen(callerid);
- while(i < ii)
- {
+ while(i < ii) {
if (!strchr(valid_chars, callerid[i]))
callerid[i] = '_';
i++;
}
i = 0;
ii = strlen(number);
- while(i < ii)
- {
+ while(i < ii) {
if (!strchr(valid_chars, number[i]))
number[i] = '_';
i++;
}
/* mute */
- if (mute && p_record_type==CODEC_MONO)
- {
+ if (mute && p_record_type==CODEC_MONO) {
i = p_record_length;
if (i > mute)
i = mute;
p_record_length -= (i<<1);
}
/* add beep to the end of recording */
- if (beep && p_record_type==CODEC_MONO)
- {
+ if (beep && p_record_type==CODEC_MONO) {
i = 0;
- while(i < 256)
- {
+ while(i < 256) {
beep_mono[i] = (signed short)(sin((double)i / 5.688888888889 * 2.0 * 3.1415927) * 2000.0);
i++;
}
i = 0;
- while(i < beep)
- {
+ while(i < beep) {
fwrite(beep_mono, sizeof(beep_mono), 1, p_record);
i += sizeof(beep_mono);
p_record_length += sizeof(beep_mono);
}
/* complete header */
- switch(p_record_type)
- {
+ switch(p_record_type) {
case CODEC_MONO:
case CODEC_STEREO:
case CODEC_8BIT:
/* fmt */
fprintf(p_record, "fmt %c%c%c%c", (unsigned int)sizeof(fmt), 0, 0, 0);
- switch(p_record_type)
- {
+ switch(p_record_type) {
case CODEC_MONO:
fmt.stereo = 1;
fmt.channels = 1;
fduse--;
p_record = NULL;
- if (rename(p_record_filename, filename) < 0)
- {
+ if (rename(p_record_filename, filename) < 0) {
PERROR("Port(%d) cannot rename from '%s' to '%s'\n", p_serial, p_record_filename, filename);
return;
}
PDEBUG(DEBUG_PORT, "Port(%d) recording is written and renamed to '%s' and must have the following size:%lu raw:%lu samples:%lu\n", p_serial, filename, wsize+8, size, size>>1);
- if (p_record_vbox == 2)
- {
+ if (p_record_vbox == 2) {
SPRINT(indexname, "%s/%s/vbox/index", EXTENSION_DATA, p_record_extension);
- if ((fp = fopen(indexname,"a")))
- {
+ if ((fp = fopen(indexname,"a"))) {
fduse++;
/* remove path from file name */
fclose(fp);
fduse--;
- } else
- {
+ } else {
PERROR("Port(%d) cannot open index file '%s' to append.\n", p_serial, indexname);
}
/* send email with sample*/
- if (p_record_vbox_email[0])
- {
+ if (p_record_vbox_email[0]) {
send_mail(p_record_vbox_email_file?filename:(char *)"", callerid, callerinfo.extension, callerinfo.name, p_record_vbox_email, p_record_vbox_year, p_record_vbox_mon, p_record_vbox_mday, p_record_vbox_hour, p_record_vbox_min, p_record_extension);
}
}
return;
/* skip data from local caller (dtmf input) */
- if (p_record_skip && !dir_fromup)
- {
+ if (p_record_skip && !dir_fromup) {
/* more to skip than we have */
- if (p_record_skip > length)
- {
+ if (p_record_skip > length) {
p_record_skip -= length;
return;
}
//PDEBUG(DEBUG_PORT, "record(data,%d,%d): free=%d, p_record_buffer_dir=%d, p_record_buffer_readp=%d, p_record_buffer_writep=%d.\n", length, dir_fromup, free, p_record_buffer_dir, p_record_buffer_readp, p_record_buffer_writep);
/* the buffer stores the same data stream */
- if (dir_fromup == p_record_buffer_dir)
- {
+ if (dir_fromup == p_record_buffer_dir) {
same_again:
//printf("same free=%d length=%d\n", free, length);
/* first write what we can to the buffer */
- while(free && length)
- {
+ while(free && length) {
p_record_buffer[p_record_buffer_writep] = audio_law_to_s32[*data++];
p_record_buffer_writep = (p_record_buffer_writep + 1) & RECORD_BUFFER_MASK;
free--;
if (!length)
return;
/* still data left, buffer is full, so we need to write a chunk to file */
- switch(p_record_type)
- {
+ switch(p_record_type) {
case CODEC_MONO:
s = (signed short *)write_buffer;
i = 0;
- while(i < 256)
- {
+ while(i < 256) {
*s++ = p_record_buffer[p_record_buffer_readp];
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
i++;
case CODEC_STEREO:
s = (signed short *)write_buffer;
- if (p_record_buffer_dir)
- {
+ if (p_record_buffer_dir) {
i = 0;
- while(i < 256)
- {
+ while(i < 256) {
*s++ = 0; /* nothing from down */
*s++ = p_record_buffer[p_record_buffer_readp];
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
i++;
}
- } else
- {
+ } else {
i = 0;
- while(i < 256)
- {
+ while(i < 256) {
*s++ = p_record_buffer[p_record_buffer_readp];
*s++ = 0; /* nothing from up */
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
case CODEC_8BIT:
d = write_buffer;
i = 0;
- while(i < 256)
- {
+ while(i < 256) {
*d++ = ((unsigned short)(p_record_buffer[p_record_buffer_readp]+0x8000)) >> 8;
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
i++;
case CODEC_LAW:
d = write_buffer;
i = 0;
- while(i < 256)
- {
+ while(i < 256) {
*d++ = audio_s16_to_law[p_record_buffer[p_record_buffer_readp] & 0xffff];
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
i++;
different_again:
/* if buffer empty, change it */
- if (p_record_buffer_readp == p_record_buffer_writep)
- {
+ if (p_record_buffer_readp == p_record_buffer_writep) {
p_record_buffer_dir = dir_fromup;
goto same_again;
}
//PDEBUG(DEBUG_PORT, "record(data,%d,%d): free=%d, p_record_buffer_dir=%d, p_record_buffer_readp=%d, p_record_buffer_writep=%d: mixing %d bytes.\n", length, dir_fromup, free, p_record_buffer_dir, p_record_buffer_readp, p_record_buffer_writep, ii);
/* write data mixed with the buffer */
- switch(p_record_type)
- {
+ switch(p_record_type) {
case CODEC_MONO:
s = (signed short *)write_buffer;
i = 0;
- while(i < ii)
- {
+ while(i < ii) {
sample = p_record_buffer[p_record_buffer_readp]
+ audio_law_to_s32[*data++];
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
case CODEC_STEREO:
s = (signed short *)write_buffer;
- if (p_record_buffer_dir)
- {
+ if (p_record_buffer_dir) {
i = 0;
- while(i < ii)
- {
+ while(i < ii) {
*s++ = audio_law_to_s32[*data++];
*s++ = p_record_buffer[p_record_buffer_readp];
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
i++;
}
- } else
- {
+ } else {
i = 0;
- while(i < ii)
- {
+ while(i < ii) {
*s++ = p_record_buffer[p_record_buffer_readp];
*s++ = audio_law_to_s32[*data++];
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
case CODEC_8BIT:
d = write_buffer;
i = 0;
- while(i < ii)
- {
+ while(i < ii) {
sample = p_record_buffer[p_record_buffer_readp]
+ audio_law_to_s32[*data++];
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
case CODEC_LAW:
d = write_buffer;
i = 0;
- while(i < ii)
- {
+ while(i < ii) {
sample = p_record_buffer[p_record_buffer_readp]
+ audio_law_to_s32[*data++];
p_record_buffer_readp = (p_record_buffer_readp + 1) & RECORD_BUFFER_MASK;
projects / lcr.git / commitdiff