\*****************************************************************************/
-#include <stdio.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <poll.h>
#include "main.h"
class EndpointAppPBX *apppbx_first = NULL;
/*
* EndpointAppPBX constructor
*/
-EndpointAppPBX::EndpointAppPBX(class Endpoint *epoint) : EndpointApp(epoint)
+EndpointAppPBX::EndpointAppPBX(class Endpoint *epoint, int origin) : EndpointApp(epoint, origin)
{
class EndpointAppPBX **apppointer;
/* initialize */
memset(&e_ext, 0, sizeof(struct extension));
+ // *************** NOTE: also change value in read_extension() **************
e_ext.rights = 4; /* international */
- e_ext.rxvol = e_ext.txvol = 256;
+ e_ext.rx_gain = e_ext.tx_gain = 0;
e_state = EPOINT_STATE_IDLE;
e_ext.number[0] = '\0';
e_extension_interface[0] = '\0';
memset(&e_redirinfo, 0, sizeof(struct redir_info));
memset(&e_capainfo, 0, sizeof(struct capa_info));
e_start = e_stop = 0;
-// e_origin = 0;
+ e_origin = origin;
e_ruleset = ruleset_main;
if (e_ruleset)
e_rule = e_ruleset->rule_first;
e_cfnr_release = 0;
e_cfnr_call = 0;
e_password_timeout = 0;
- e_multipoint_cause = CAUSE_NOUSER;
- e_multipoint_location = LOCATION_PRIVATE_LOCAL;
+ e_multipoint_cause = 0;
+ e_multipoint_location = 0;
e_dialing_queue[0] = '\0';
e_crypt = CRYPT_OFF;
e_crypt_state = CM_ST_NULL;
/* init trace with given values */
start_trace(0,
NULL,
- numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype),
+ numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype, options.national, options.international),
e_dialinginfo.id,
direction,
CATEGORY_EP,
}
-/* screen caller id
- * out==0: incomming caller id, out==1: outgoing caller id
- */
-void EndpointAppPBX::screen(int out, char *id, int idsize, int *type, int *present, struct interface *interface)
-{
- char *msn1;
- struct interface_msn *ifmsn;
- struct interface_screen *ifscreen;
- char suffix[64];
-
- /* screen incoming caller id */
- if (!out)
- {
- /* check for MSN numbers, use first MSN if no match */
- msn1 = NULL;
- ifmsn = interface->ifmsn;
- while(ifmsn)
- {
- if (!msn1)
- msn1 = ifmsn->msn;
- if (!strcmp(ifmsn->msn, id))
- {
- break;
- }
- ifmsn = ifmsn->next;
- }
- if (ifmsn)
- {
- trace_header("SCREEN (found in list)", DIRECTION_IN);
- add_trace("msn", NULL, "%s", id);
- end_trace();
- }
- if (!ifmsn && msn1) // not in list, first msn given
- {
- trace_header("SCREEN (not found in list)", DIRECTION_IN);
- add_trace("msn", "given", "%s", id);
- add_trace("msn", "used", "%s", msn1);
- end_trace();
- UNCPY(id, msn1, idsize);
- id[idsize-1] = '\0';
- }
- }
-
- /* check screen list */
- if (out)
- ifscreen = interface->ifscreen_out;
- else
- ifscreen = interface->ifscreen_in;
- 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 (!strncmp(ifscreen->match, id, strchr(ifscreen->match,'%')-ifscreen->match))
- break;
- } else
- {
- if (!strcmp(ifscreen->match, id))
- break;
- }
- }
- ifscreen = ifscreen->next;
- }
- if (ifscreen) // match
- {
- trace_header("SCREEN (found in list)", out?DIRECTION_OUT:DIRECTION_IN);
- switch(*type)
- {
- case INFO_NTYPE_UNKNOWN:
- add_trace("given", "type", "unknown");
- break;
- case INFO_NTYPE_SUBSCRIBER:
- add_trace("given", "type", "subscriber");
- break;
- case INFO_NTYPE_NATIONAL:
- add_trace("given", "type", "national");
- break;
- case INFO_NTYPE_INTERNATIONAL:
- add_trace("given", "type", "international");
- break;
- }
- switch(*present)
- {
- case INFO_PRESENT_ALLOWED:
- add_trace("given", "present", "allowed");
- break;
- case INFO_PRESENT_RESTRICTED:
- add_trace("given", "present", "restricted");
- break;
- case INFO_PRESENT_NOTAVAIL:
- add_trace("given", "present", "not available");
- break;
- }
- add_trace("given", "id", "%s", id[0]?id:"<empty>");
- if (ifscreen->result_type != -1)
- {
- *type = ifscreen->result_type;
- switch(*type)
- {
- case INFO_NTYPE_UNKNOWN:
- add_trace("used", "type", "unknown");
- break;
- case INFO_NTYPE_SUBSCRIBER:
- add_trace("used", "type", "subscriber");
- break;
- case INFO_NTYPE_NATIONAL:
- add_trace("used", "type", "national");
- break;
- case INFO_NTYPE_INTERNATIONAL:
- add_trace("used", "type", "international");
- break;
- }
- }
- if (ifscreen->result_present != -1)
- {
- *present = ifscreen->result_present;
- switch(*present)
- {
- case INFO_PRESENT_ALLOWED:
- add_trace("used", "present", "allowed");
- break;
- case INFO_PRESENT_RESTRICTED:
- add_trace("used", "present", "restricted");
- break;
- case INFO_PRESENT_NOTAVAIL:
- add_trace("used", "present", "not available");
- break;
- }
- }
- if (strchr(ifscreen->match,'%'))
- {
- SCPY(suffix, strchr(ifscreen->match,'%') - ifscreen->match + id);
- UNCPY(id, ifscreen->result, idsize);
- id[idsize-1] = '\0';
- if (strchr(ifscreen->result,'%'))
- {
- *strchr(ifscreen->result,'%') = '\0';
- UNCAT(id, suffix, idsize);
- id[idsize-1] = '\0';
- }
- } else
- {
- UNCPY(id, ifscreen->result, idsize);
- id[idsize-1] = '\0';
- }
- add_trace("used", "id", "%s", id[0]?id:"<empty>");
- end_trace();
- }
-}
-
/* release join and port (as specified)
*/
void EndpointAppPBX::release(int release, int joinlocation, int joincause, int portlocation, int portcause)
{
struct port_list *portlist;
- struct message *message;
+ struct lcr_msg *message;
char cause[16];
/* message to test call */
e_dtmf_last = 0;
e_cfnr_release = 0;
e_cfnr_call = 0;
- e_multipoint_cause = CAUSE_NOUSER;
- e_multipoint_location = LOCATION_PRIVATE_LOCAL;
+ e_multipoint_cause = 0;
+ e_multipoint_location = 0;
e_dialing_queue[0] = '\0';
e_crypt = 0;
e_crypt_state = CM_ST_NULL;
} else
{
/* numberrize caller id and use it to dial to the callback */
- SCPY(e_dialinginfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype));
+ SCPY(e_dialinginfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype, options.national, options.international));
}
e_dialinginfo.itype = INFO_ITYPE_ISDN;
e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
/* cancel callerid if restricted, unless anon-ignore is enabled at extension or port is of type external (so called police gets caller id :)*/
-void apply_callerid_restriction(int anon_ignore, char *id, int *ntype, int *present, int *screen, char *extension, char *name)
+void apply_callerid_restriction(struct extension *ext, char *id, int *ntype, int *present, int *screen, char *extension, char *name)
{
PDEBUG(DEBUG_EPOINT, "id='%s' ntype=%d present=%d screen=%d extension='%s' name='%s'\n", (id)?id:"NULL", (ntype)?*ntype:-1, (present)?*present:-1, (screen)?*screen:-1, (extension)?extension:"NULL", (name)?name:"NULL");
return;
/* only extensions are restricted */
- if (!extension)
- return;
- if (!extension[0])
+ if (!ext->number[0])
return;
/* if we enabled anonymouse ignore */
- if (anon_ignore)
+ if (ext->anon_ignore)
return;
/* else we remove the caller id */
static char display[81];
display[0] = '\0';
- char *cid = numberrize_callerinfo(id, ntype);
+ char *cid = numberrize_callerinfo(id, ntype, options.national, options.international);
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) id='%s' itype=%d ntype=%d present=%d screen=%d extension='%s' name='%s'\n", ea_endpoint->ep_serial, (id)?id:"NULL", itype, ntype, present, screen, (extension)?extension:"NULL", (name)?name:"NULL");
void EndpointAppPBX::notify_active(void)
{
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
int notify = 0;
switch(e_tx_state)
/* set tone pattern for port */
void EndpointAppPBX::set_tone(struct port_list *portlist, char *tone)
{
- struct message *message;
+ struct lcr_msg *message;
if (!tone)
tone = "";
/* store for suspended processes */
SCPY(e_tone, tone);
- if (!portlist)
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no endpoint to notify tone.\n", ea_endpoint->ep_serial);
- return;
- }
if (e_join_pattern /* pattern are provided */
&& !(e_ext.own_setup && e_state == EPOINT_STATE_IN_SETUP)
SCPY(message->param.tone.name, tone);
message_put(message);
logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
+ } else
+ {
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no port to notify tone.\n", ea_endpoint->ep_serial);
+ return;
}
}
}
/* see if link is up on PTP*/
- if (mISDNport->ptp && !mISDNport->l2link)
+ if (mISDNport->l2hold && !mISDNport->l2link)
{
- trace_header("CHANNEL SELECTION (port is ptp with layer 2 down, skipping)", DIRECTION_NONE);
+ trace_header("CHANNEL SELECTION (port holds layer 2, but layer 2 is down, skipping)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
end_trace();
}
i++;
}
+ if (*channel)
+ break;
+ trace_header("CHANNEL SELECTION (no channel is 'free')", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport->portnum);
+ add_trace("position", NULL, "%d", index);
+ end_trace();
break;
case CHANNEL_ANY: /* don't ask for channel */
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);
+ add_trace("total", NULL, "%d", mISDNport->b_num);
+ add_trace("reserved", NULL, "%d", mISDNport->b_reserved);
+ end_trace();
break; /* all channel in use or reserverd */
}
- trace_header("CHANNEL SELECTION (using 'any channel')", DIRECTION_NONE);
+ trace_header("CHANNEL SELECTION (using 'any' channel)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
end_trace();
break;
case CHANNEL_NO: /* call waiting */
- trace_header("CHANNEL SELECTION (using 'no channel', call-waiting)", DIRECTION_NONE);
+ trace_header("CHANNEL SELECTION (using 'no' channel, call-waiting)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
end_trace();
default:
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);
+ add_trace("channel", NULL, "%d", selchannel->channel);
+ end_trace();
break; /* invalid channels */
+ }
i = selchannel->channel-1-(selchannel->channel>=17);
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);
+ add_trace("channel", NULL, "%d", selchannel->channel);
+ add_trace("channels", NULL, "%d", mISDNport->b_num);
+ end_trace();
break; /* channel not in port */
+ }
if (mISDNport->b_port[i] == NULL)
{
*channel = selchannel->channel;
class Port *port;
// class pdss1 *pdss1;
struct port_list *portlist;
- struct message *message;
+ struct lcr_msg *message;
int anycall = 0;
int cause = CAUSE_RESSOURCEUNAVAIL;
char *p;
SCPY(port_settings.tones_dir, e_ext.tones_dir);
else
SCPY(port_settings.tones_dir, options.tones_dir);
- port_settings.tout_setup = e_ext.tout_setup;
- port_settings.tout_dialing = e_ext.tout_dialing;
- port_settings.tout_proceeding = e_ext.tout_proceeding;
- port_settings.tout_alerting = e_ext.tout_alerting;
- port_settings.tout_disconnect = e_ext.tout_disconnect;
-// port_settings.tout_hold = e_ext.tout_hold;
-// port_settings.tout_park = e_ext.tout_park;
port_settings.no_seconds = e_ext.no_seconds;
/* 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 */
goto check_anycall_intern;
}
/* directory.list */
- if (e_callerinfo.id[0] && (e_ext.centrex || e_ext.display_name))
+ if (e_callerinfo.id[0] && e_ext.display_name)
{
dirname = parse_directory(e_callerinfo.id, e_callerinfo.ntype);
if (dirname)
//terminal if (e_dialinginfo.id)
//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
/* handle restricted caller ids */
- apply_callerid_restriction(e_ext.anon_ignore, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
- apply_callerid_restriction(e_ext.anon_ignore, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
+ apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
+ apply_callerid_restriction(&e_ext, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
/* display callerid if desired for extension */
SCPY(message->param.setup.callerinfo.display, apply_callerid_display(message->param.setup.callerinfo.id, message->param.setup.callerinfo.itype, message->param.setup.callerinfo.ntype, message->param.setup.callerinfo.present, message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name));
//printf("\n\ndisplay = %s\n\n\n",message->param.setup.callerinfo.display);
/* use cnip, if enabld */
- if (!e_ext.centrex)
- message->param.setup.callerinfo.name[0] = '\0';
+ // 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])
{
SCPY(message->param.setup.callerinfo.id, e_ext.clip_prefix);
- SCAT(message->param.setup.callerinfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype));
+ 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;
}
/* use internal caller id */
//terminal if (e_dialinginfo.id)
//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
/* handle restricted caller ids */
- apply_callerid_restriction(e_ext.anon_ignore, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
- apply_callerid_restriction(e_ext.anon_ignore, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
+ apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
+ apply_callerid_restriction(&e_ext, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
/* display callerid if desired for extension */
SCPY(message->param.setup.callerinfo.display, apply_callerid_display(message->param.setup.callerinfo.id, message->param.setup.callerinfo.itype, message->param.setup.callerinfo.ntype, message->param.setup.callerinfo.present, message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name));
message_put(message);
//terminal if (e_dialinginfo.id)
//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.id);
/* handle restricted caller ids */
- apply_callerid_restriction(e_ext.anon_ignore, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
- apply_callerid_restriction(e_ext.anon_ignore, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
+ apply_callerid_restriction(&e_ext, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name);
+ apply_callerid_restriction(&e_ext, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, 0, message->param.setup.redirinfo.extension, NULL);
/* display callerid if desired for extension */
SCPY(message->param.setup.callerinfo.display, apply_callerid_display(message->param.setup.callerinfo.id, message->param.setup.callerinfo.itype, message->param.setup.callerinfo.ntype, message->param.setup.callerinfo.present, message->param.setup.callerinfo.screen, message->param.setup.callerinfo.extension, message->param.setup.callerinfo.name));
message_put(message);
{
e_redial = 0;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current action timed out.\n", ea_endpoint->ep_serial);
- e_multipoint_cause = CAUSE_NOUSER;
- e_multipoint_location = LOCATION_PRIVATE_LOCAL;
+ e_multipoint_cause = 0;
+ e_multipoint_location = 0;
new_state(EPOINT_STATE_IN_OVERLAP);
e_join_pattern = 0;
process_dialing();
if (e_cfnr_release)
{
struct port_list *portlist;
- struct message *message;
+ struct lcr_msg *message;
if (now >= e_cfnr_release)
{
}
/* dialtone after pressing the hash key */
process_hangup(e_join_cause, e_join_location);
- e_multipoint_cause = CAUSE_NOUSER;
- e_multipoint_location = LOCATION_PRIVATE_LOCAL;
+ e_multipoint_cause = 0;
+ e_multipoint_location = 0;
port = find_port_id(ea_endpoint->ep_portlist->port_id);
if (port)
{
/* port MESSAGE_SETUP */
void EndpointAppPBX::port_setup(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
char buffer[256];
int writeext; /* flags need to write extension after modification */
class Port *port;
memcpy(&e_redirinfo, ¶m->setup.redirinfo, sizeof(e_redirinfo));
memcpy(&e_capainfo, ¶m->setup.capainfo, sizeof(e_capainfo));
e_dtmf = param->setup.dtmf;
-
/* screen incoming caller id */
interface = interface_first;
while(interface)
interface = interface->next;
}
if (interface)
- screen(0, e_callerinfo.id, sizeof(e_callerinfo.id), &e_callerinfo.ntype, &e_callerinfo.present, interface);
+ do_screen(0, e_callerinfo.id, sizeof(e_callerinfo.id), &e_callerinfo.ntype, &e_callerinfo.present, interface);
/* process extension */
if (e_callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
/* set volume of rx and tx */
if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
- if (e_ext.txvol!=256 || e_ext.rxvol!=256)
+ 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.rxvol = e_ext.txvol;
- message->param.mISDNsignal.txvol = e_ext.rxvol;
+ message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
+ message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
message_put(message);
}
/* turn off dtmf detection, in case dtmf is sent with keypad information */
if (e_dtmf)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) received dialing information, so dtmf is now disabled, to prevent double detection by keypad+dtmf.\n", ea_endpoint->ep_serial, param->information.id, e_ext.number, e_callerinfo.id);
+ trace_header("DTMF (disabling due to keypad)", DIRECTION_IN);
+ end_trace();
e_dtmf = 0;
}
}
/* keypad when connected */
- if (e_state == EPOINT_STATE_CONNECT && e_ext.keypad)
+ if (e_state == EPOINT_STATE_CONNECT)
{
- 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 (e_ext.keypad)
{
- hookflash();
+ 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')
+ {
+ hookflash();
+ }
+ if (param->information.id[0])
+ keypad_function(param->information.id[0]);
+ } else
+ {
+ if (e_ext.number[0])
+ trace_header("KEYPAD (not enabled by extension's settings)", DIRECTION_IN);
+ else
+ trace_header("KEYPAD (not enabled for external interfaces)", DIRECTION_IN);
+ end_trace();
}
- if (param->information.id[0])
- keypad_function(param->information.id[0]);
return;
}
if (e_state != EPOINT_STATE_IN_OVERLAP)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in overlap, or connect state.\n", ea_endpoint->ep_serial);
+ if (e_ext.number[0])
+ trace_header("KEYPAD (ignored, not connected and not dialing)", DIRECTION_IN);
+ else
+ trace_header("KEYPAD (not enabled for external interfaces)", DIRECTION_IN);
+ end_trace();
return;
}
if (!param->information.id[0])
/* port MESSAGE_DTMF */
void EndpointAppPBX::port_dtmf(struct port_list *portlist, int message_type, union parameter *param)
{
- trace_header("DTMF", DIRECTION_IN);
- add_trace("digit", NULL, "%c", param->dtmf);
- end_trace();
/* only if dtmf detection is enabled */
if (!e_dtmf)
{
- PDEBUG(DEBUG_EPOINT, "dtmf detection is disabled\n");
+ trace_header("DTMF (disabled)", DIRECTION_IN);
+ end_trace();
return;
}
+ trace_header("DTMF", DIRECTION_IN);
+ add_trace("digit", NULL, "%c", param->dtmf);
+ end_trace();
#if 0
NOTE: vbox is now handled due to overlap state
/* port MESSAGE_OVERLAP */
void EndpointAppPBX::port_overlap(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
/* port MESSAGE_PROCEEDING */
void EndpointAppPBX::port_proceeding(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
/* port MESSAGE_ALERTING */
void EndpointAppPBX::port_alerting(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
/* port MESSAGE_CONNECT */
void EndpointAppPBX::port_connect(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
char buffer[256];
unsigned long port_id = portlist->port_id;
struct port_list *tportlist;
logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
/* signal to call tool */
- admin_call_response(e_adminid, ADMIN_CALL_CONNECT, numberrize_callerinfo(param->connectinfo.id,param->connectinfo.ntype), 0, 0, 0);
+ admin_call_response(e_adminid, ADMIN_CALL_CONNECT, numberrize_callerinfo(param->connectinfo.id,param->connectinfo.ntype, options.national, options.international), 0, 0, 0);
memcpy(&e_connectinfo, ¶m->connectinfo, sizeof(e_connectinfo));
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing all other ports (start)\n", ea_endpoint->ep_serial);
interface = interface->next;
}
if (interface)
- screen(0, e_connectinfo.id, sizeof(e_connectinfo.id), &e_connectinfo.ntype, &e_connectinfo.present, interface);
+ do_screen(0, e_connectinfo.id, sizeof(e_connectinfo.id), &e_connectinfo.ntype, &e_connectinfo.present, interface);
/* screen connected name */
if (e_ext.name[0])
new_state(EPOINT_STATE_CONNECT);
/* set volume of rx and tx */
- if (e_ext.txvol!=256 || e_ext.rxvol!=256)
+ 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.rxvol = e_ext.txvol;
- message->param.mISDNsignal.txvol = e_ext.rxvol;
+ message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
+ message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
message_put(message);
}
e_cfnr_call = e_cfnr_release = 0;
if (e_ext.number[0])
e_dtmf = 1; /* allow dtmf */
-// if (call_countrelations(ea_endpoint->ep_join_id) == 2)
+
+ /* 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)
{
- /* 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)
+ e_connectinfo.present = INFO_PRESENT_NOTAVAIL;
+ if (portlist->port_type==PORT_TYPE_DSS1_TE_OUT || portlist->port_type==PORT_TYPE_DSS1_NT_OUT) /* external extension answered */
{
- e_connectinfo.present = INFO_PRESENT_NOTAVAIL;
- if (portlist->port_type==PORT_TYPE_DSS1_TE_OUT || portlist->port_type==PORT_TYPE_DSS1_NT_OUT) /* external extension answered */
+ port = find_port_id(portlist->port_id);
+ if (port)
{
- port = find_port_id(portlist->port_id);
- if (port)
- {
- SCPY(e_connectinfo.id, nationalize_callerinfo(port->p_dialinginfo.id, &e_connectinfo.ntype));
- e_connectinfo.present = INFO_PRESENT_ALLOWED;
- }
+ SCPY(e_connectinfo.id, nationalize_callerinfo(port->p_dialinginfo.id, &e_connectinfo.ntype, options.national, options.international));
+ e_connectinfo.present = INFO_PRESENT_ALLOWED;
}
}
- 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);
}
+
+ /* send connect to join */
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 = CHANNEL_STATE_CONNECT;
message_put(message);
/* port MESSAGE_DISCONNECT MESSAGE_RELEASE */
void EndpointAppPBX::port_disconnect_release(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
char buffer[256];
unsigned long port_id = portlist->port_id;
int cause,
} else
{
/* use multipoint cause if no connect yet */
- cause = e_multipoint_cause;
- location = e_multipoint_location;
+ if (e_multipoint_cause)
+ {
+ cause = e_multipoint_cause;
+ location = e_multipoint_location;
+ } else
+ {
+ cause = CAUSE_NOUSER;
+ location = LOCATION_PRIVATE_LOCAL;
+ }
}
e_cfnr_call = e_cfnr_release = 0;
/* process hangup */
process_hangup(e_join_cause, e_join_location);
e_multipoint_cause = 0;
- e_multipoint_location = LOCATION_PRIVATE_LOCAL;
+ e_multipoint_location = 0;
if (message_type == MESSAGE_DISCONNECT)
{
{
logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
- struct message *message;
+ struct lcr_msg *message;
char *logtext = "";
char buffer[64];
/* signal to call tool */
- admin_call_response(e_adminid, ADMIN_CALL_NOTIFY, numberrize_callerinfo(param->notifyinfo.id,param->notifyinfo.ntype), 0, 0, param->notifyinfo.notify);
+ 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)
{
e_rx_state = track_notify(e_rx_state, param->notifyinfo.notify);
case INFO_NOTIFY_USER_RESUMED:
/* set volume of rx and tx */
if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
- if (e_ext.txvol!=256 || e_ext.rxvol!=256)
+ if (e_ext.tx_gain!=0 || e_ext.rx_gain!=0)
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.rxvol = e_ext.txvol;
- message->param.mISDNsignal.txvol = e_ext.rxvol;
+ message->param.mISDNsignal.rx_gain = e_ext.tx_gain;
+ message->param.mISDNsignal.tx_gain = e_ext.rx_gain;
message_put(message);
}
/* set current tone */
{
logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
- struct message *message;
+ struct lcr_msg *message;
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_FACILITY);
memcpy(&message->param.facilityinfo, ¶m->facilityinfo, sizeof(struct facility_info));
void EndpointAppPBX::ea_message_port(unsigned long port_id, int message_type, union parameter *param)
{
struct port_list *portlist;
- struct message *message;
+ struct lcr_msg *message;
portlist = ea_endpoint->ep_portlist;
while(portlist)
port_resume(portlist, message_type, param);
break;
+#if 0
+ /* port assigns bchannel */
+ case MESSAGE_BCHANNEL: /* bchannel assignment messafe */
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received bchannel message %d from port.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->bchannel.type);
+ /* only one port is expected to be connected to bchannel */
+ message = message_forward(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, param);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_IN);
+ break;
+#endif
+
+
default:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received a wrong message: %d\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, message);
}
/* join MESSAGE_INFORMATION */
void EndpointAppPBX::join_information(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
e_overlap = 1;
/* join MESSAGE_FACILITY */
void EndpointAppPBX::join_facility(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
- if (!e_ext.facility)
+ if (!e_ext.facility && e_ext.number[0])
{
return;
}
/* join MESSAGE_MORE */
void EndpointAppPBX::join_overlap(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
new_state(EPOINT_STATE_IN_OVERLAP);
}
if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL)
{
- set_tone(portlist, "dialtone");
+ if (e_dialinginfo.id[0])
+ set_tone(portlist, "dialing");
+ else
+ set_tone(portlist, "dialtone");
return;
}
if (e_ext.number[0])
/* join MESSAGE_PROCEEDING */
void EndpointAppPBX::join_proceeding(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
new_state(EPOINT_STATE_IN_PROCEEDING);
/* join MESSAGE_ALERTING */
void EndpointAppPBX::join_alerting(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
new_state(EPOINT_STATE_IN_ALERTING);
/* join MESSAGE_CONNECT */
void EndpointAppPBX::join_connect(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
- struct interface *interface;
+ struct lcr_msg *message;
new_state(EPOINT_STATE_CONNECT);
// UCPY(e_join_tone, "");
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
memcpy(&message->param, param, sizeof(union parameter));
- /* screen incoming caller id */
- interface = interface_first;
- while(interface)
- {
- if (!strcmp(e_connectinfo.interface, interface->name))
- {
- break;
- }
- interface = interface->next;
- }
- if (interface)
- screen(1, e_connectinfo.id, sizeof(e_connectinfo.id), &e_connectinfo.ntype, &e_connectinfo.present, interface);
- memcpy(&message->param.connectinfo, &e_connectinfo, sizeof(e_connectinfo));
/* screen clip if prefix is required */
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));
+ SCAT(message->param.connectinfo.id, numberrize_callerinfo(e_connectinfo.id,e_connectinfo.ntype, options.national, options.international));
message->param.connectinfo.ntype = INFO_NTYPE_UNKNOWN;
}
}
/* handle restricted caller ids */
- apply_callerid_restriction(e_ext.anon_ignore, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name);
+ apply_callerid_restriction(&e_ext, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name);
/* display callerid if desired for extension */
SCPY(message->param.connectinfo.display, apply_callerid_display(message->param.connectinfo.id, message->param.connectinfo.itype, message->param.connectinfo.ntype, message->param.connectinfo.present, message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name));
/* use conp, if enabld */
- if (!e_ext.centrex)
- message->param.connectinfo.name[0] = '\0';
+// if (!e_ext.centrex)
+// message->param.connectinfo.name[0] = '\0';
/* send connect */
message_put(message);
}
/* join MESSAGE_DISCONNECT MESSAGE_RELEASE */
-void EndpointAppPBX::join_disconnect_release(struct port_list *portlist, int message_type, union parameter *param)
+void EndpointAppPBX::join_disconnect_release(int message_type, union parameter *param)
{
char cause[16];
- struct message *message;
+ struct lcr_msg *message;
+ struct port_list *portlist = NULL;
/* be sure that we are active */
if (e_state==EPOINT_STATE_IN_OVERLAP)
{
new_state(EPOINT_STATE_IN_PROCEEDING);
- if (portlist)
+ if (ea_endpoint->ep_portlist)
{
- message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
+ 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, portlist->port_id, DIRECTION_OUT);
+ logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
}
/* caused the error, that the first knock sound was not there */
/* set_tone(portlist, "proceeding"); */
/* send display of powerdialing */
if (e_ext.display_dialing)
{
+ portlist = ea_endpoint->ep_portlist;
while (portlist)
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
}
/* send disconnect message */
SCPY(e_tone, cause);
+ portlist = ea_endpoint->ep_portlist;
while(portlist)
{
set_tone(portlist, cause);
/* join MESSAGE_SETUP */
void EndpointAppPBX::join_setup(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
- struct interface *interface;
+ struct lcr_msg *message;
+// struct interface *interface;
/* if we already in setup state, we just update the dialing with new digits */
if (e_state == EPOINT_STATE_OUT_SETUP
memcpy(&e_redirinfo, ¶m->setup.redirinfo, sizeof(e_redirinfo));
memcpy(&e_capainfo, ¶m->setup.capainfo, sizeof(e_capainfo));
- /* screen incoming caller id */
- interface = interface_first;
- while(interface)
- {
- if (!strcmp(e_callerinfo.interface, interface->name))
- {
- break;
- }
- interface = interface->next;
- }
- if (interface)
- screen(1, e_callerinfo.id, sizeof(e_callerinfo.id), &e_callerinfo.ntype, &e_callerinfo.present, interface);
-
/* process (voice over) data calls */
if (e_ext.datacall && e_capainfo.bearer_capa!=INFO_BC_SPEECH && e_capainfo.bearer_capa!=INFO_BC_AUDIO)
{
/* join MESSAGE_mISDNSIGNAL */
void EndpointAppPBX::join_mISDNsignal(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
while(portlist)
{
/* join MESSAGE_NOTIFY */
void EndpointAppPBX::join_notify(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ struct lcr_msg *message;
int new_state;
if (param->notifyinfo.notify)
/* unhold if */
if (new_state!=NOTIFY_STATE_HOLD && new_state!=NOTIFY_STATE_SUSPEND)
{
- while(portlist)
+ if (!strcmp(e_tone, "hold")) // don't interrupt other tones
{
- set_tone(portlist, "");
- portlist = portlist->next;
+ while(portlist)
+ {
+ set_tone(portlist, "");
+ portlist = portlist->next;
+ }
}
portlist = ea_endpoint->ep_portlist;
e_hold = 0;
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 */
- apply_callerid_restriction(e_ext.anon_ignore, message->param.notifyinfo.id, &message->param.notifyinfo.ntype, &message->param.notifyinfo.present, 0, message->param.notifyinfo.extension, NULL);
+ apply_callerid_restriction(&e_ext, message->param.notifyinfo.id, &message->param.notifyinfo.ntype, &message->param.notifyinfo.present, 0, message->param.notifyinfo.extension, NULL);
/* display callerid if desired for extension */
SCPY(message->param.notifyinfo.display, apply_callerid_display(message->param.notifyinfo.id, message->param.notifyinfo.itype, message->param.notifyinfo.ntype, message->param.notifyinfo.present, 0, message->param.notifyinfo.extension, NULL));
message_put(message);
}
}
-/* call sends messages to the endpoint
+/* JOIN sends messages to the endpoint
*/
void EndpointAppPBX::ea_message_join(unsigned long join_id, int message_type, union parameter *param)
{
struct port_list *portlist;
- struct message *message;
+ struct lcr_msg *message;
if (!join_id)
{
- PERROR("EPOINT(%d) error: call == NULL.\n", ea_endpoint->ep_serial);
+ PERROR("EPOINT(%d) error: JOIN == NULL.\n", ea_endpoint->ep_serial);
return;
}
/* send MESSAGE_DATA to port */
if (message_type == MESSAGE_DATA)
{
- if (join_id == ea_endpoint->ep_join_id) // still linked with call
+ if (join_id == ea_endpoint->ep_join_id) // still linked with JOIN
{
/* skip if no port relation */
if (!portlist)
}
}
-// PDEBUG(DEBUG_EPOINT, "EPOINT(%d) received message %d for active call (terminal %s, caller id %s state=%d)\n", ea_endpoint->ep_serial, message, e_ext.number, e_callerinfo.id, e_state);
+// 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)
{
- /* CALL SENDS CRYPT message */
+ /* 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);
+ set_tone(portlist, param->tone.name);
+ break;
+
+ /* JOIN SENDS CRYPT message */
case MESSAGE_CRYPT:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received crypt message: '%d'\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->crypt.type);
join_crypt(portlist, message_type, param);
break;
- /* CALL sends INFORMATION message */
+ /* JOIN sends INFORMATION message */
case MESSAGE_INFORMATION:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received more digits: '%s'\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->information.id);
join_information(portlist, message_type, param);
break;
- /* CALL sends FACILITY message */
+ /* JOIN sends FACILITY message */
case MESSAGE_FACILITY:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received facility\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
join_facility(portlist, message_type, param);
break;
- /* CALL sends OVERLAP message */
+ /* JOIN sends OVERLAP message */
case MESSAGE_OVERLAP:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received 'more info available'\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_IN_SETUP
join_overlap(portlist, message_type, param);
break;
- /* CALL sends PROCEEDING message */
+ /* 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)
join_proceeding(portlist, message_type, param);
break;
- /* CALL sends ALERTING message */
+ /* JOIN sends ALERTING message */
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
join_alerting(portlist, message_type, param);
break;
- /* CALL sends CONNECT message */
+ /* JOIN sends CONNECT message */
case MESSAGE_CONNECT:
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
join_connect(portlist, message_type, param);
break;
- /* CALL sends DISCONNECT/RELEASE message */
- case MESSAGE_DISCONNECT: /* call disconnect */
- case MESSAGE_RELEASE: /* call releases */
+ /* JOIN sends DISCONNECT/RELEASE message */
+ case MESSAGE_DISCONNECT: /* JOIN disconnect */
+ case MESSAGE_RELEASE: /* JOIN releases */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received %s with cause %d location %d\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, (message_type==MESSAGE_DISCONNECT)?"disconnect":"release", param->disconnectinfo.cause, param->disconnectinfo.location);
- join_disconnect_release(portlist, message_type, param);
+ join_disconnect_release(message_type, param);
break;
- /* CALL sends SETUP message */
+ /* JOIN sends SETUP message */
case MESSAGE_SETUP:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint received setup from terminal='%s',id='%s' to id='%s' (dialing itype=%d)\n", ea_endpoint->ep_serial, param->setup.callerinfo.extension, param->setup.callerinfo.id, param->setup.dialinginfo.id, param->setup.dialinginfo.itype);
join_setup(portlist, message_type, param);
- return;
break;
- /* CALL sends special mISDNSIGNAL message */
+ /* JOIN sends special mISDNSIGNAL message */
case MESSAGE_mISDNSIGNAL: /* isdn message to port */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received mISDNsignal message.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
join_mISDNsignal(portlist, message_type, param);
break;
- /* CALL has pattern available */
+#warning was ist hiermit
+#if 0
+ /* JOIN requests bchannel */
+ case MESSAGE_BCHANNEL: /* indicates the need of own bchannel access */
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received bchannel assignment %d from join.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->bchannel.type);
+ /* only one port is expected to be connected to bchannel */
+ if (!portlist)
+ break;
+ if (portlist->next)
+ break;
+ e_join_pattern = 1;
+ SCPY(e_tone, "");
+ set_tone(portlist, NULL);
+ message = message_forward(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, param);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
+ break;
+#endif
+
+ /* 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)
}
break;
- /* CALL has no pattern available */
+ /* 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)
break;
#if 0
- /* CALL (dunno at the moment) */
+ /* JOIN (dunno at the moment) */
case MESSAGE_REMOTE_AUDIO:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received audio remote request.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
break;
#endif
- /* CALL sends a notify message */
+ /* JOIN sends a notify message */
case MESSAGE_NOTIFY:
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received notify.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
join_notify(portlist, message_type, param);
void EndpointAppPBX::pick_join(char *extensions)
{
- struct message *message;
+ struct lcr_msg *message;
struct port_list *portlist;
class Port *port;
class EndpointAppPBX *eapp, *found;
message->param.connectinfo.itype = eapp->e_callerinfo.itype;
message->param.connectinfo.ntype = eapp->e_callerinfo.ntype;
/* handle restricted caller ids */
- apply_callerid_restriction(e_ext.anon_ignore, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name);
+ apply_callerid_restriction(&e_ext, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name);
/* display callerid if desired for extension */
SCPY(message->param.connectinfo.display, apply_callerid_display(message->param.connectinfo.id, message->param.connectinfo.itype, message->param.connectinfo.ntype, message->param.connectinfo.present, message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name));
message_put(message);
*/
void EndpointAppPBX::join_join(void)
{
- struct message *message;
+ struct lcr_msg *message;
struct join_relation *our_relation, *other_relation;
struct join_relation **our_relation_pointer, **other_relation_pointer;
class Join *our_join, *other_join;
{
if (other_relation->epoint_id == other_eapp->ea_endpoint->ep_serial)
{
- /* detach other endpoint on hold */
+ /* detach other endpoint on hold */
*other_relation_pointer = other_relation->next;
FREE(other_relation, sizeof(struct join_relation));
cmemuse--;
other_relation = *other_relation_pointer;
- other_eapp->ea_endpoint->ep_join_id = NULL;
+ other_eapp->ea_endpoint->ep_join_id = 0;
continue;
}
add_trace("from", NULL, "CH(%lu)", port_id);
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));
+ 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)
{
case INFO_PRESENT_RESTRICTED:
}
if (param->setup.redirinfo.id[0])
{
- add_trace("redir'ing", "number", "%s", numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype));
+ 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)
{
case INFO_PRESENT_RESTRICTED:
add_trace("from", NULL, "CH(%lu)", port_id);
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));
+ add_trace("connect id", "number", "%s", numberrize_callerinfo(param->connectinfo.id, param->connectinfo.ntype, options.national, options.international));
switch(param->connectinfo.present)
{
case INFO_PRESENT_RESTRICTED:
add_trace("cause", "location", "3-Transit");
break;
case LOCATION_PUBLIC_REMOTE:
- add_trace("cause", "location", "4-Remote-PBX");
+ add_trace("cause", "location", "4-Remote-Exchange");
break;
case LOCATION_PRIVATE_REMOTE:
- add_trace("cause", "location", "5-Remote-Exchange");
+ add_trace("cause", "location", "5-Remote-PBX");
break;
case LOCATION_INTERNATIONAL:
add_trace("cause", "location", "7-International-Exchange");
add_trace("indicator", NULL, "%s", logtext);
if (param->notifyinfo.id[0])
{
- add_trace("redir'on", "number", "%s", numberrize_callerinfo(param->notifyinfo.id, param->notifyinfo.ntype));
+ add_trace("redir'on", "number", "%s", numberrize_callerinfo(param->notifyinfo.id, param->notifyinfo.ntype, options.national, options.international));
switch(param->notifyinfo.present)
{
case INFO_PRESENT_RESTRICTED:
end_trace();
break;
+#if 0
+ case MESSAGE_BCHANNEL:
+ trace_header("BCHANNEL", dir);
+ switch(param->bchannel.type)
+ {
+ case BCHANNEL_REQUEST:
+ add_trace("type", NULL, "request");
+ break;
+ case BCHANNEL_ASSIGN:
+ add_trace("type", NULL, "assign");
+ break;
+ case BCHANNEL_ASSIGN_ACK:
+ add_trace("type", NULL, "assign_ack");
+ break;
+ case BCHANNEL_REMOVE:
+ add_trace("type", NULL, "remove");
+ break;
+ case BCHANNEL_REMOVE_ACK:
+ add_trace("type", NULL, "remove_ack");
+ break;
+ }
+ if (param->bchannel.addr)
+ add_trace("address", NULL, "%x", param->bchannel.addr);
+ end_trace();
+ break;
+#endif
+
default:
PERROR("EPOINT(%d) message not of correct type (%d)\n", ea_endpoint->ep_serial, message_type);
}
void EndpointAppPBX::message_disconnect_port(struct port_list *portlist, int cause, int location, char *display)
{
- struct message *message;
+ struct lcr_msg *message;
if (!portlist)
return;