/*****************************************************************************\
** **
-** PBX4Linux **
+** LCR **
** **
**---------------------------------------------------------------------------**
** Copyright: Andreas Eversberg **
e_match_timeout = 0;
e_match_to_action = NULL;
e_select = 0;
- e_extdialing = e_dialinginfo.number;
+ e_extdialing = e_dialinginfo.id;
// e_knocking = 0;
// e_knocktime = 0;
e_hold = 0;
temp = temp->next;
}
if (temp == 0)
- {
- PERROR("error: endpoint not in endpoint's list, exitting.\n");
- exit(-1);
- }
+ FATAL("Endpoint not in endpoint's list.\n");
*tempp = next;
}
*/
void EndpointAppPBX::trace_header(char *name, int direction)
{
- char msgtext[sizeof(trace.name)];
+ struct trace _trace;
+
+ char msgtext[sizeof(_trace.name)];
SCPY(msgtext, name);
/* init trace with given values */
- start_trace(e_serial,
+ start_trace(0,
NULL,
- nationalize(e_callerinfo.id, e_callerinfo.ntype),
- e_dialinginfo.number,
+ numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype),
+ e_dialinginfo.id,
direction,
CATEGORY_EP,
- e_serial,
+ ea_endpoint->ep_serial,
msgtext);
}
/* 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)
+void EndpointAppPBX::screen(int out, char *id, int idsize, int *type, int *present, struct interface *interface)
{
- struct interface *interface;
-
- interface = interface_first;
- while(interface)
- {
- if (!strcmp(e_callerinfo.interface, interface->name))
+ 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)
{
- break;
+ 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';
}
- interface = interface->next;
}
-add logging
- if (interface)
+
+ /* check screen list */
+ if (out)
+ ifscreen = interface->ifscreen_out;
+ else
+ ifscreen = interface->ifscreen_in;
+ while (ifscreen)
{
- /* screen incoming caller id */
- if (!out)
+ if (ifscreen->match_type==-1 || ifscreen->match_type==*type)
+ if (ifscreen->match_present==-1 || ifscreen->match_present==*present)
{
- /* check for MSN numbers, use first MSN if no match */
- msn1 = NULL;
- ifmsn = interface->ifmsn;
- while(ifmns)
+ if (strchr(ifscreen->match,'%'))
{
- if (!msn1)
- msn1 = ifmns->msn;
- if (!strcmp(ifmns->mns, id))
- {
+ if (!strncmp(ifscreen->match, id, strchr(ifscreen->match,'%')-ifscreen->match))
+ break;
+ } else
+ {
+ if (!strcmp(ifscreen->match, id))
break;
- }
- ifmsn = ifmsn->next;
}
- if (!ifmns && mns1) // not in list, first msn given
- UNCPY(id, msn1, idsize);
- id[idsize-1] = '\0';
}
-
- /* check screen list */
- if (out)
- iscreen = interface->ifscreen_out;
- else
- iscreen = interface->ifscreen_in;
- while (ifscreen)
+ ifscreen = ifscreen->next;
+ }
+ if (ifscreen) // match
+ {
+ trace_header("SCREEN (found in list)", out?DIRECTION_OUT:DIRECTION_IN);
+ switch(*type)
{
- if (ifcreen->match_type==-1 || ifscreen->match_type==*type)
- if (ifcreen->match_present==-1 || ifscreen->match_present==*present)
+ 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)
{
- if (strchr(ifcreen->match_id,'%'))
- {
- if (!strncmp(ifscreen->match_id, id, strchr(ifscreen->match_id,'%')-ifscreen->match_id))
- break;
- } else
- {
- if (!strcmp(ifscreen->match_id, id))
- break;
- }
+ 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;
}
- ifscreen = ifscreen->next;
}
- if (ifscreen) // match
+ if (ifscreen->result_present != -1)
{
- if (ifscren->result_type != -1)
- *type = ifscreen->result_type;
- if (ifscren->result_present != -1)
- *present = ifscreen->result_present;
- if (strchr(ifscreen->match_id,'%'))
+ *present = ifscreen->result_present;
+ switch(*present)
{
- SCPY(suffix, strchr(ifscreen->match_id,'%') - ifscreen->match_id + id);
- UNCPY(id, ifscreen->result_id);
- id[idsize-1] = '\0';
- if (strchr(ifscreen->result_id,'%'))
- {
- *strchr(ifscreen->result_id,'%') = '\0';
- UNCAT(id, suffix, idsize);
- id[idsize-1] = '\0';
- }
- } else
+ 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,'%'))
{
- UNCPY(id, ifscreen->result_id, idsize);
+ *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();
}
}
struct port_list *portlist;
struct message *message;
char cause[16];
- class Call *call;
/* message to test call */
admin_call_response(e_adminid, ADMIN_CALL_RELEASE, "", callcause, calllocation, 0);
PDEBUG(DEBUG_EPOINT, "EPOINT(%d): do pending release (callcause %d location %d)\n", ea_endpoint->ep_serial, callcause, calllocation);
if (ea_endpoint->ep_call_id)
{
- call = find_call_id(ea_endpoint->ep_call_id);
- if (call)
- call->release(ea_endpoint->ep_serial, 0, calllocation, callcause);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_RELEASE);
+ message->param.disconnectinfo.cause = callcause;
+ message->param.disconnectinfo.location = calllocation;
+ message_put(message);
+ ea_endpoint->ep_call_id = 0;
}
- ea_endpoint->ep_call_id = 0;
e_call_pattern = 0;
#if 0
if (release != RELEASE_PORT_CALLONLY)
e_match_timeout = 0;
e_match_to_action = NULL;
//e_select = 0;
- e_extdialing = e_dialinginfo.number;
+ e_extdialing = e_dialinginfo.id;
e_connectedmode = 0;
e_dtmf = 0;
e_dtmf_time = 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.number, e_ext.number);
+ 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;
{
if (e_cbto[0])
{
- SCPY(e_dialinginfo.number, e_cbto);
+ SCPY(e_dialinginfo.id, e_cbto);
} else
{
/* numberrize caller id and use it to dial to the callback */
- SCPY(e_dialinginfo.number, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype));
+ SCPY(e_dialinginfo.id, numberrize_callerinfo(e_callerinfo.id,e_callerinfo.ntype));
}
e_dialinginfo.itype = INFO_ITYPE_ISDN;
e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) preparing callback to external: %s\n", ea_endpoint->ep_serial, e_dialinginfo.number);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) preparing callback to external: %s\n", ea_endpoint->ep_serial, e_dialinginfo.id);
}
return;
}
/* 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, int port_type, char *id, int *ntype, int *present, int *screen, char *voip, char *intern, char *name)
+void apply_callerid_restriction(int anon_ignore, char *id, int *ntype, int *present, int *screen, char *extension, char *name)
{
- PDEBUG(DEBUG_EPOINT, "id='%s' ntype=%d present=%d screen=%d voip='%s' intern='%s' name='%s'\n", (id)?id:"NULL", (ntype)?*ntype:-1, (present)?*present:-1, (screen)?*screen:-1, (voip)?voip:"NULL", (intern)?intern:"NULL", (name)?name:"NULL");
+ 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");
/* caller id is not restricted, so we do nothing */
if (*present != INFO_PRESENT_RESTRICTED)
return;
/* only extensions are restricted */
- if (!intern)
+ if (!extension)
return;
- if (!intern[0])
+ if (!extension[0])
return;
/* if we enabled anonymouse ignore */
// maybe we should not make voip address anonymous
// if (voip)
// voip[0] = '\0';
-// maybe it's no fraud to present internal id
-// if (intern)
-// intern[0] = '\0';
+// maybe it's no fraud to present extension id
+// if (extension)
+// extension[0] = '\0';
if (name)
name[0] = '\0';
}
/* used display message to display callerid as available */
-char *EndpointAppPBX::apply_callerid_display(char *id, int itype, int ntype, int present, int screen, char *voip, char *intern, char *name)
+char *EndpointAppPBX::apply_callerid_display(char *id, int itype, int ntype, int present, int screen, char *extension, char *name)
{
static char display[81];
display[0] = '\0';
char *cid = numberrize_callerinfo(id, ntype);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) id='%s' itype=%d ntype=%d present=%d screen=%d voip='%s' intern='%s' name='%s'\n", ea_endpoint->ep_serial, (id)?id:"NULL", itype, ntype, present, screen, (voip)?voip:"NULL", (intern)?intern:"NULL", (name)?name:"NULL");
+ 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");
if (!id)
id = "";
- if (!voip)
- voip = "";
- if (!intern)
- intern = "";
+ if (!extension)
+ extension = "";
if (!name)
name = "";
/* 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 (intern[0] && e_ext.display_int)
+ if (extension[0] && e_ext.display_int)
{
if (!display[0])
- SCAT(display, intern);
+ SCAT(display, extension);
if (display[0])
SCAT(display, " ");
if (itype == INFO_ITYPE_VBOX)
}
/* external caller id */
- if (!intern[0] && !voip[0] && e_ext.display_ext)
+ if (!extension[0] && e_ext.display_ext)
{
if (!display[0])
{
}
}
- /* voip caller id */
- if (voip[0] && e_ext.display_voip)
- {
- if (!display[0] && cid[0])
- SCAT(display, cid);
- if (display[0])
- SCAT(display, " ");
- SCAT(display, voip);
- }
-
/* display if callerid is anonymouse but available due anon-ignore */
if (e_ext.display_anon && present==INFO_PRESENT_RESTRICTED)
{
* if no ifname was given, any interface that is not an extension
* will be searched.
*/
-static struct mISDNport *EndpointAppPBX::hunt_port(char *ifname, int *channel)
+struct mISDNport *EndpointAppPBX::hunt_port(char *ifname, int *channel)
{
struct interface *interface;
+ struct interface_port *ifport, *ifport_start;
+ struct select_channel *selchannel;
struct mISDNport *mISDNport;
+ int index, i;
interface = interface_first;
/* first find the given interface or, if not given, one with no extension */
checknext:
if (!interface)
- return(null);
+ return(NULL);
/* check for given interface */
if (ifname)
trace_header("CHANNEL SELECTION (found interface)", DIRECTION_NONE);
add_trace("interface", NULL, "%s", ifname);
end_trace();
- goto found;
+ goto foundif;
}
} else
trace_header("CHANNEL SELECTION (found non extension interface)", DIRECTION_NONE);
add_trace("interface", NULL, "%s", interface->name);
end_trace();
- goto found;
+ goto foundif;
}
}
interface = interface->next;
goto checknext;
+foundif:
/* see if interface has ports */
if (!interface->ifport)
}
/* select port by algorithm */
- ifport_start = interface->port;
+ ifport_start = interface->ifport;
index = 0;
if (interface->hunt == HUNT_ROUNDROBIN)
{
while(ifport_start->next && index<interface->hunt_next)
{
ifport_start = ifport_start->next;
- i++;
+ index++;
}
trace_header("CHANNEL SELECTION (starting round-robin)", DIRECTION_NONE);
add_trace("port", NULL, "%d", ifport_start->portnum);
}
mISDNport = ifport->mISDNport;
-#warning admin block auch bei incomming calls
-#warning calls releasen, wenn port entfernt wird, geblockt wird
/* see if port is administratively blocked */
if (ifport->block)
{
goto portbusy;
}
- /* see if link is up */
+ /* see if link is up on PTP*/
if (mISDNport->ptp && !mISDNport->l2link)
{
trace_header("CHANNEL SELECTION (port is ptp with layer 2 down, skipping)", DIRECTION_NONE);
/* check for channel form selection list */
*channel = 0;
- selchannel = ifport->selchannel;
+ selchannel = ifport->out_channel;
while(selchannel)
{
switch(selchannel->channel)
{
case CHANNEL_FREE: /* free channel */
- if (mISDNport->b_inuse >= mISDNport->b_num)
+ if (mISDNport->b_reserved >= mISDNport->b_num)
break; /* all channel in use or reserverd */
/* find channel */
i = 0;
break;
case CHANNEL_ANY: /* don't ask for channel */
- if (mISDNport->b_inuse >= mISDNport->b_num)
+ if (mISDNport->b_reserved >= mISDNport->b_num)
{
break; /* all channel in use or reserverd */
}
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
end_trace();
- *channel = SEL_CHANNEL_ANY;
+ *channel = CHANNEL_ANY;
break;
case CHANNEL_NO: /* call waiting */
add_trace("port", NULL, "%d", ifport->portnum);
add_trace("position", NULL, "%d", index);
end_trace();
- *channel = SEL_CHANNEL_NO;
+ *channel = CHANNEL_NO;
break;
default:
class EndpointAppPBX *atemp;
// char allowed_ports[256];
// char exten[256];
- int i, ii;
- int use;
char ifname[sizeof(e_ext.interfaces)],
number[256];
struct port_settings port_settings;
int channel = 0;
+ int earlyb;
/* create settings for creating port */
memset(&port_settings, 0, sizeof(port_settings));
/* FALL THROUGH !!!! */
case INFO_ITYPE_VBOX:
/* get dialed extension's info */
-// SCPY(exten, e_dialinginfo.number);
+// SCPY(exten, e_dialinginfo.id);
// if (strchr(exten, ','))
// *strchr(exten, ',') = '\0';
// if (!read_extension(&e_ext, exten))
- if (!read_extension(&e_ext, e_dialinginfo.number))
+ if (!read_extension(&e_ext, e_dialinginfo.id))
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) extension %s not configured\n", ea_endpoint->ep_serial, e_dialinginfo.number);
+ 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, call, port */
return; /* must exit here */
}
/* call to all internal interfaces */
p = e_ext.interfaces;
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) generating multiple calls for extension %s to interfaces %s\n", ea_endpoint->ep_serial, e_dialinginfo.number, p);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) generating multiple calls for extension %s to interfaces %s\n", ea_endpoint->ep_serial, e_dialinginfo.id, p);
while(*p)
{
ifname[0] = '\0';
continue;
}
/* creating INTERNAL port */
- SPRINT(portname, "%s-%d-out", mISDNport->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);
+ 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);
if (!port)
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) port '%s' failed to create\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- goto check_anycall_intern;
- }
+ FATAL("No memory for DSS1 Port instance\n");
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) got port %s\n", ea_endpoint->ep_serial, port->p_name);
memset(&dialinginfo, 0, sizeof(dialinginfo));
- SCPY(dialinginfo.number, e_dialinginfo.number);
+ SCPY(dialinginfo.id, e_dialinginfo.id);
dialinginfo.itype = INFO_ITYPE_ISDN_EXTENSION;
dialinginfo.ntype = e_dialinginfo.ntype;
/* create port_list relation */
- portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->is_earlyb);
+ portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->earlyb);
if (!portlist)
{
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
}
// dss1 = (class Pdss1 *)port;
/* message */
-//printf("INTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.number);
+//printf("INTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
//terminal SCPY(message->param.setup.from_terminal, e_ext.number);
-//terminal if (e_dialinginfo.number)
-//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.number);
+//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, port->p_type, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.voip, message->param.setup.callerinfo.intern, message->param.setup.callerinfo.name);
- apply_callerid_restriction(e_ext.anon_ignore, port->p_type, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, NULL, message->param.setup.redirinfo.voip, message->param.setup.redirinfo.intern, 0);
+ 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);
/* 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.voip, message->param.setup.callerinfo.intern, message->param.setup.callerinfo.name));
+ 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.ntype = INFO_NTYPE_UNKNOWN;
}
/* use internal caller id */
- if (e_callerinfo.intern[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.intern);
+ SCPY(message->param.setup.callerinfo.id, e_callerinfo.extension);
message->param.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
}
message_put(message);
cfu_only: /* entry point for cfu */
cfb_only: /* entry point for cfb */
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.number, p);
+ 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)
{
- /* only if vbox should be dialed, and terminal is given */
earlyb = 0;
+ /* only if vbox should be dialed, and terminal is given */
if (!strcmp(p, "vbox") && e_ext.number[0])
{
/* go to the end of p */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) answering machine\n", ea_endpoint->ep_serial);
/* alloc port */
if (!(port = new VBoxPort(PORT_TYPE_VBOX_OUT, &port_settings)))
- {
- PERROR("EPOINT(%d) no mem for port\n", ea_endpoint->ep_serial);
- break;
- }
+ 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
SCCAT(cfp, *p++);
if (*p == ',')
p++;
- hier auch wie oben
/* external call */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cfp external %s\n", ea_endpoint->ep_serial, cfp);
/* hunt for mISDNport and create Port */
- mISDNport = mISDNport_first;
- port = NULL;
- while(mISDNport)
- {
- /* check for external or given interface */
- if (((!e_dialinginfo.interfaces[0])&&mISDNport->iftype==IF_EXTERN) || !strcmp(mISDNport->interface_name, e_dialinginfo.interfaces))
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) interface '%s' found\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- cause = CAUSE_NOCHANNEL; /* when failing: out of channels */
- /* if PTP, skip all down links */
- if (mISDNport->ptp && !mISDNport->l2link)
- {
- trace_header("INTERFACE (layer 2 is down)", DIRECTION_NONE);
- add_trace("interface", NULL, "%s", mISDNport->interface_name);
- end_trace();
- mISDNport = mISDNport->next;
- continue;
- }
- /* if no channel is available */
- if (mISDNport->multilink || !mISDNport->ntmode || mISDNport->ptp)
- {
- use = 0;
- i = 0;
- ii = mISDNport->b_num;
- while(i < ii)
- {
- if (mISDNport->b_state[i])
- use++;
- i++;
- }
- if (use >= mISDNport->b_num)
- {
- trace_header("INTERFACE (no free channel)", DIRECTION_NONE);
- add_trace("interface", NULL, "%s", mISDNport->interface_name);
- end_trace();
- mISDNport = mISDNport->next;
- continue;
- }
- }
- /* found interface */
- trace_header("INTERFACE (found)", DIRECTION_NONE);
- add_trace("interface", NULL, "%s", mISDNport->interface_name);
- end_trace();
- break;
- }
- mISDNport = mISDNport->next;
- }
+ mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
if (mISDNport)
{
/* creating EXTERNAL port*/
- SPRINT(portname, "%s-%d-out", mISDNport->interface_name, mISDNport->portnum);
- port = new Pdss1((mISDNport->ntmode)?PORT_TYPE_DSS1_NT_OUT:PORT_TYPE_DSS1_TE_OUT, mISDNport, portname, &port_settings);
- earlyb = mISDNport->is_earlyb;
+ SPRINT(portname, "%s-%d-out", mISDNport->ifport->interface->name, mISDNport->portnum);
+ if (!(port = new Pdss1((mISDNport->ntmode)?PORT_TYPE_DSS1_NT_OUT:PORT_TYPE_DSS1_TE_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force)))
+ FATAL("No memory for DSS1 Port instance\n");
+ earlyb = mISDNport->earlyb;
} else
{
port = NULL;
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) found or created port %s\n", ea_endpoint->ep_serial, port->p_name);
memset(&dialinginfo, 0, sizeof(dialinginfo));
- SCPY(dialinginfo.number, cfp);
- dialinginfo.itype = INFO_ITYPE_EXTERN;
+ SCPY(dialinginfo.id, cfp);
+ dialinginfo.itype = INFO_ITYPE_ISDN;
dialinginfo.ntype = e_dialinginfo.ntype;
portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, earlyb);
if (!portlist)
delete port;
goto check_anycall_intern;
}
-//printf("EXTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.number);
+//printf("EXTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
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.intern, e_ext.number);
+ SCPY(message->param.setup.callerinfo.extension, e_ext.number);
message->param.setup.callerinfo.ntype = e_ext.callerid_type;
message->param.setup.callerinfo.present = e_ext.callerid_present;
}
memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
//terminal SCPY(message->param.setup.from_terminal, e_ext.number);
-//terminal if (e_dialinginfo.number)
-//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.number);
+//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, port->p_type, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.voip, message->param.setup.callerinfo.intern, message->param.setup.callerinfo.name);
- apply_callerid_restriction(e_ext.anon_ignore, port->p_type, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, NULL, message->param.setup.redirinfo.voip, message->param.setup.redirinfo.intern, 0);
+ 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);
/* 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.voip, message->param.setup.callerinfo.intern, message->param.setup.callerinfo.name));
+ 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);
logmessage(message);
anycall = 1;
/* *********************** external call */
default:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing external: '%s'\n", ea_endpoint->ep_serial, e_dialinginfo.number);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing external: '%s'\n", ea_endpoint->ep_serial, e_dialinginfo.id);
/* call to extenal interfaces */
- p = e_dialinginfo.number;
+ p = e_dialinginfo.id;
do
{
number[0] = '\0';
/* found number */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) calling to number '%s' interface '%s'\n", ea_endpoint->ep_serial, number, e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
/* hunt for mISDNport and create Port */
- mISDNport = mISDNport_first;
- port = NULL;
- while(mISDNport)
- {
- /* check for external or given interface */
- if ((!e_dialinginfo.interfaces[0]&&mISDNport->iftype==IF_EXTERN) || !strcmp(mISDNport->interface_name, e_dialinginfo.interfaces))
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) interface '%s' found\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- cause = CAUSE_NOCHANNEL; /* when failing: out of channels */
- /* if PTP, skip all down links */
- if (mISDNport->ptp && !mISDNport->l2link)
- {
- trace_header("INTERFACE (layer 2 is down)", DIRECTION_NONE);
- add_trace("interface", NULL, "%s", mISDNport->interface_name);
- end_trace();
- mISDNport = mISDNport->next;
- continue;
- }
- /* if no channel is available */
- if (mISDNport->multilink || !mISDNport->ntmode || mISDNport->ptp)
- {
- use = 0;
- i = 0;
- ii = mISDNport->b_num;
- while(i < ii)
- {
- if (mISDNport->b_state[i])
- use++;
- i++;
- }
- if (use >= mISDNport->b_num)
- {
- trace_header("INTERFACE (no free channel)", DIRECTION_NONE);
- add_trace("interface", NULL, "%s", mISDNport->interface_name);
- end_trace();
- mISDNport = mISDNport->next;
- continue;
- }
- }
- /* found interface */
- trace_header("INTERFACE (found)", DIRECTION_NONE);
- add_trace("interface", NULL, "%s", mISDNport->interface_name);
- end_trace();
- break;
- }
- mISDNport = mISDNport->next;
- }
+ /* hunt for mISDNport and create Port */
+ mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
if (!mISDNport)
{
trace_header("INTERFACE (too busy)", DIRECTION_NONE);
goto check_anycall_extern;
}
/* creating EXTERNAL port*/
- SPRINT(portname, "%s-%d-out", mISDNport->interface_name, mISDNport->portnum);
- port = new Pdss1((mISDNport->ntmode)?PORT_TYPE_DSS1_NT_OUT:PORT_TYPE_DSS1_TE_OUT, mISDNport, portname, &port_settings);
- if (!port)
- {
- PERROR("EPOINT(%d) no memory for external port, exitting\n", ea_endpoint->ep_serial);
- exit(-1);
- }
+ SPRINT(portname, "%s-%d-out", mISDNport->ifport->interface->name, mISDNport->portnum);
+ if (!(port = new Pdss1((mISDNport->ntmode)?PORT_TYPE_DSS1_NT_OUT:PORT_TYPE_DSS1_TE_OUT, mISDNport, portname, &port_settings, channel, mISDNport->ifport->channel_force)))
+ FATAL("No memory for DSS1 Port instance\n");
+ earlyb = mISDNport->earlyb;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) created port %s\n", ea_endpoint->ep_serial, port->p_name);
memset(&dialinginfo, 0, sizeof(dialinginfo));
- SCPY(dialinginfo.number, number);
- dialinginfo.itype = INFO_ITYPE_EXTERN;
+ SCPY(dialinginfo.id, number);
+ dialinginfo.itype = INFO_ITYPE_ISDN;
dialinginfo.ntype = e_dialinginfo.ntype;
- portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->is_earlyb);
+ portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->earlyb);
if (!portlist)
{
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
goto check_anycall_extern;
}
// dss1 = (class Pdss1 *)port;
-//printf("EXTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.number);
+//printf("EXTERNAL caller=%s,id=%s,dial=%s\n", param.setup.networkid, param.setup.callerinfo.id, param.setup.dialinginfo.id);
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_SETUP);
memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
- SCPY(message->param.setup.dialinginfo.number, number);
+ SCPY(message->param.setup.dialinginfo.id, number);
memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
//terminal SCPY(message->param.setup.from_terminal, e_ext.number);
-//terminal if (e_dialinginfo.number)
-//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.number);
+//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, port->p_type, message->param.setup.callerinfo.id, &message->param.setup.callerinfo.ntype, &message->param.setup.callerinfo.present, &message->param.setup.callerinfo.screen, message->param.setup.callerinfo.voip, message->param.setup.callerinfo.intern, message->param.setup.callerinfo.name);
- apply_callerid_restriction(e_ext.anon_ignore, port->p_type, message->param.setup.redirinfo.id, &message->param.setup.redirinfo.ntype, &message->param.setup.redirinfo.present, NULL, message->param.setup.redirinfo.voip, message->param.setup.redirinfo.intern, 0);
+ 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);
/* 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.voip, message->param.setup.callerinfo.intern, message->param.setup.callerinfo.name));
+ 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);
logmessage(message);
anycall = 1;
e_action = NULL;
new_state(EPOINT_STATE_IN_OVERLAP);
e_connectedmode = 1;
- SCPY(e_dialinginfo.number, e_ext.prefix);
- e_extdialing = e_dialinginfo.number;
+ SCPY(e_dialinginfo.id, e_ext.prefix);
+ e_extdialing = e_dialinginfo.id;
e_call_pattern = 0;
- if (e_dialinginfo.number[0])
+ if (e_dialinginfo.id[0])
{
set_tone(ea_endpoint->ep_portlist, "dialing");
process_dialing();
{
struct message *message;
char buffer[256];
- char extension[32];
- char extension1[32];
- char *p;
int writeext; /* flags need to write extension after modification */
class Port *port;
+ struct interface *interface;
portlist->port_type = param->setup.port_type;
memcpy(&e_callerinfo, ¶m->setup.callerinfo, sizeof(e_callerinfo));
memcpy(&e_capainfo, ¶m->setup.capainfo, sizeof(e_capainfo));
e_dtmf = param->setup.dtmf;
- /* screen by interface */
- if (e_callerinfo.interface[0])
+ /* screen incoming caller id */
+ interface = interface_first;
+ while(interface)
{
- /* screen incoming caller id */
- screen(0, e_callerinfo.id, sizeof(e_callerinfo.id), &e_callerinfo.ntype, &e_callerinfo.present);
+ if (!strcmp(e_callerinfo.interface, interface->name))
+ {
+ break;
+ }
+ interface = interface->next;
}
-colp, outclip, outcolp
+ if (interface)
+ screen(0, e_callerinfo.id, sizeof(e_callerinfo.id), &e_callerinfo.ntype, &e_callerinfo.present, interface);
/* process extension */
- if (e_callerinfo.itype == INFO_ITYPE_INTERN)
+ 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.intern, e_callerinfo.id);
- SCPY(e_ext.number, e_callerinfo.intern);
+ SCPY(e_callerinfo.extension, e_callerinfo.id);
+ SCPY(e_ext.number, e_callerinfo.extension);
SCPY(e_extension_interface, e_callerinfo.interface);
} else
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call is external or voip\n", ea_endpoint->ep_serial);
}
trace_header("SETUP", DIRECTION_IN);
- if (e_callerinfo.intern[0])
- add_trace("extension", NULL, "%s", e_callerinfo.intern);
+ if (e_callerinfo.extension[0])
+ add_trace("extension", NULL, "%s", e_callerinfo.extension);
add_trace("caller id", "number", "%s", numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype));
if (e_callerinfo.present == INFO_PRESENT_RESTRICTED)
add_trace("caller id", "present", "restricted");
if (e_redirinfo.present == INFO_PRESENT_RESTRICTED)
add_trace("redir'ing", "present", "restricted");
}
- if (e_dialinginfo.number)
- add_trace("dialing", "number", "%s", e_dialinginfo.number));
+ if (e_dialinginfo.id)
+ add_trace("dialing", "number", "%s", e_dialinginfo.id);
end_trace();
- if (e_callerinfo.itype == INFO_ITYPE_INTERN)
+ 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);
}
writeext = 0;
- /* put prefix (next) in front of e_dialinginfo.number */
+ /* put prefix (next) in front of e_dialinginfo.id */
if (e_ext.next[0])
{
- SPRINT(buffer, "%s%s", e_ext.next, e_dialinginfo.number);
- SCPY(e_dialinginfo.number, buffer);
+ 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])
{
- SPRINT(buffer, "%s%s", e_ext.prefix, e_dialinginfo.number);
- SCPY(e_dialinginfo.number, buffer);
+ SPRINT(buffer, "%s%s", e_ext.prefix, e_dialinginfo.id);
+ SCPY(e_dialinginfo.id, buffer);
}
- /* screen caller id */
+ /* screen caller id by extension's config */
e_callerinfo.screen = INFO_SCREEN_NETWORK;
if (e_ext.name[0])
SCPY(e_callerinfo.name, e_ext.name);
write_extension(&e_ext, e_ext.number);
/* set volume of rx and tx */
- if (param->setup.callerinfo.itype == INFO_ITYPE_INTERN)
+ if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
if (e_ext.txvol!=256 || e_ext.rxvol!=256)
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_mISDNSIGNAL);
if (e_ruleset)
e_rule = e_ruleset->rule_first;
e_action = NULL;
- e_extdialing = e_dialinginfo.number;
+ e_extdialing = e_dialinginfo.id;
new_state(EPOINT_STATE_IN_SETUP);
- if (e_dialinginfo.number[0])
+ if (e_dialinginfo.id[0])
{
set_tone(portlist, "dialing");
} else
void EndpointAppPBX::port_information(struct port_list *portlist, int message_type, union parameter *param)
{
trace_header("INFORMATION", DIRECTION_IN);
- add_trace("dialing", NULL, "%s", param->information.number);
+ add_trace("dialing", NULL, "%s", param->information.id);
if (param->information.sending_complete)
add_trace("complete", NULL, NULL);
end_trace();
/* 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.number, e_ext.number, e_callerinfo.id);
+ 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);
e_dtmf = 0;
}
if (e_action->index == ACTION_VBOX_PLAY)
{
/* concat dialing string */
- SCAT(e_dialinginfo.number, param->information.number);
+ SCAT(e_dialinginfo.id, param->information.id);
process_dialing();
return;
}
/* keypad when disconnect but in connected mode */
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.number);
+ 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.number[0] == '0')
+ if (param->information.id[0] == '0')
{
hookflash();
}
/* keypad when connected */
if (e_state == EPOINT_STATE_CONNECT && e_ext.keypad)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad information received during connect: %s.\n", ea_endpoint->ep_serial, param->information.number);
+ 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.number[0] == '0')
+ if (param->information.id[0] == '0')
{
hookflash();
}
- if (param->information.number[0])
- keypad_function(param->information.number[0]);
+ 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);
return;
}
- if (!param->information.number[0])
+ if (!param->information.id[0])
return;
- if (e_dialinginfo.number[0]=='\0' && !e_action)
+ if (e_dialinginfo.id[0]=='\0' && !e_action)
{
set_tone(portlist, "dialing");
}
set_tone(portlist, "dialing");
}
/* concat dialing string */
- SCAT(e_dialinginfo.number, param->information.number);
+ SCAT(e_dialinginfo.id, param->information.id);
process_dialing();
}
if (e_action->index == ACTION_VBOX_PLAY)
{
/* concat dialing string */
- if (strlen(e_dialinginfo.number)+1 < sizeof(e_dialinginfo.number))
+ if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id))
{
- e_dialinginfo.number[strlen(e_dialinginfo.number)+1] = '\0';
- e_dialinginfo.number[strlen(e_dialinginfo.number)] = param->dtmf;
+ e_dialinginfo.id[strlen(e_dialinginfo.id)+1] = '\0';
+ e_dialinginfo.id[strlen(e_dialinginfo.id)] = param->dtmf;
process_dialing();
}
/* continue to process *X# sequences */
/* dialing using dtmf digit */
if (e_state==EPOINT_STATE_IN_OVERLAP)// && e_state==e_connectedmode)
{
- if (e_dialinginfo.number[0]=='\0' && !e_action)
+ if (e_dialinginfo.id[0]=='\0' && !e_action)
{
set_tone(portlist, "dialing");
}
/* concat dialing string */
- if (strlen(e_dialinginfo.number)+1 < sizeof(e_dialinginfo.number))
+ if (strlen(e_dialinginfo.id)+1 < sizeof(e_dialinginfo.id))
{
- e_dialinginfo.number[strlen(e_dialinginfo.number)+1] = '\0';
- e_dialinginfo.number[strlen(e_dialinginfo.number)] = param->dtmf;
+ e_dialinginfo.id[strlen(e_dialinginfo.id)+1] = '\0';
+ e_dialinginfo.id[strlen(e_dialinginfo.id)] = param->dtmf;
process_dialing();
}
}
/* 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);
- SCPY(message->param.information.number, e_dialing_queue);
+ SCPY(message->param.information.id, e_dialing_queue);
message->param.information.ntype = INFO_NTYPE_UNKNOWN;
message_put(message);
logmessage(message);
e_dialing_queue[0] = '\0';
}
/* check if pattern is available */
- if (!ea_endpoint->ep_portlist->next && portlist->earlyb) /* 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_call_id, EPOINT_TO_CALL, MESSAGE_PATTERN);
end_trace();
e_state = EPOINT_STATE_OUT_PROCEEDING;
/* check if pattern is availatle */
- if (!ea_endpoint->ep_portlist->next && (portlist->earlyb || 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_call_id, EPOINT_TO_CALL, MESSAGE_PATTERN);
end_trace();
new_state(EPOINT_STATE_OUT_ALERTING);
/* check if pattern is available */
- if (!ea_endpoint->ep_portlist->next && (portlist->earlyb || 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_call_id, EPOINT_TO_CALL, MESSAGE_PATTERN);
unsigned long port_id = portlist->port_id;
struct port_list *tportlist;
class Port *port;
+ struct interface *interface;
/* signal to call tool */
admin_call_response(e_adminid, ADMIN_CALL_CONNECT, numberrize_callerinfo(param->connectinfo.id,param->connectinfo.ntype), 0, 0, 0);
memcpy(&e_connectinfo, ¶m->connectinfo, sizeof(e_connectinfo));
trace_header("CONNECT", DIRECTION_IN);
- if (e_connectinfo.intern[0])
- add_trace("extension", NULL, "%s", e_connectinfo.intern);
+ if (e_connectinfo.extension[0])
+ add_trace("extension", NULL, "%s", e_connectinfo.extension);
add_trace("connect id", "number", "%s", numberrize_callerinfo(e_connectinfo.id, e_connectinfo.ntype));
if (e_connectinfo.present == INFO_PRESENT_RESTRICTED)
add_trace("connect id", "present", "restricted");
if (tportlist->port_id == port_id) /* if the first portlist is the calling one, the second must be a different one */
tportlist = tportlist->next;
if (tportlist->port_id == port_id)
- {
- PERROR("EPOINT(%d) software error: this should not happen since the portlist list must not have two links to the same port - exitting.\n");
- exit(-1);
- }
+ FATAL("EPOINT(%d) this should not happen since the portlist list must not have two links to the same port - exitting.\n");
message = message_create(ea_endpoint->ep_serial, tportlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
- message->param.disconnectinfo.cause = 26; /* non selected user clearing */
+ message->param.disconnectinfo.cause = CAUSE_NONSELECTED; /* non selected user clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message_put(message);
logmessage(message);
e_start = now;
- /* screen by interface */
- if (e_callerinfo.interface[0])
+ /* screen incoming connected id */
+ interface = interface_first;
+ while(interface)
{
- /* screen incoming caller id */
- screen(0, e_connectinfo.id, sizeof(e_connectinfo.id), &e_connectinfo.ntype, &e_connectinfo.present);
+ if (!strcmp(e_connectinfo.interface, interface->name))
+ {
+ break;
+ }
+ interface = interface->next;
}
+ if (interface)
+ screen(0, e_connectinfo.id, sizeof(e_connectinfo.id), &e_connectinfo.ntype, &e_connectinfo.present, interface);
/* screen connected name */
if (e_ext.name[0])
SCPY(e_connectinfo.name, e_ext.name);
/* add internal id to colp */
- SCPY(e_connectinfo.intern, e_ext.number);
+ SCPY(e_connectinfo.extension, e_ext.number);
/* we store the connected port number */
- SCPY(e_extension_interface, e_connectinfo.interfaces);
+ 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)
{
SCPY(e_connectinfo.id, e_ext.callerid);
- SCPY(e_connectinfo.intern, e_ext.number);
- e_connectinfo.itype = INFO_ITYPE_INTERN;
+ 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;
}
port = find_port_id(portlist->port_id);
if (port)
{
- SCPY(e_connectinfo.id, nationalize_callerinfo(port->p_dialinginfo.number, &e_connectinfo.ntype));
+ SCPY(e_connectinfo.id, nationalize_callerinfo(port->p_dialinginfo.id, &e_connectinfo.ntype));
e_connectinfo.present = INFO_PRESENT_ALLOWED;
}
}
/* put prefix in front of e_cbdialing */
SPRINT(buffer, "%s%s", e_ext.prefix, e_cbdialing);
- SCPY(e_dialinginfo.number, buffer);
- e_dialinginfo.itype = INFO_ITYPE_EXTERN;
+ SCPY(e_dialinginfo.id, buffer);
+ e_dialinginfo.itype = INFO_ITYPE_ISDN;
e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
/* use caller id (or if exist: id_next_call) for this call */
e_callerinfo.screen = INFO_SCREEN_NETWORK;
- SCPY(e_callerinfo.intern, e_ext.number);
+ SCPY(e_callerinfo.extension, e_ext.number);
if (e_ext.id_next_call_present >= 0)
{
SCPY(e_callerinfo.id, e_ext.id_next_call);
e_action = &action_password_write;
e_match_timeout = 0;
e_match_to_action = NULL;
- e_dialinginfo.number[0] = '\0';
- e_extdialing = strchr(e_dialinginfo.number, '\0');
+ e_dialinginfo.id[0] = '\0';
+ e_extdialing = strchr(e_dialinginfo.id, '\0');
e_password_timeout = now+20;
process_dialing();
} else
if (e_ruleset)
e_rule = e_ruleset->rule_first;
e_action = NULL;
- e_extdialing = e_dialinginfo.number;
- if (e_dialinginfo.number[0])
+ e_extdialing = e_dialinginfo.id;
+ if (e_dialinginfo.id[0])
{
set_tone(portlist, "dialing");
process_dialing();
/* signal to call tool */
admin_call_response(e_adminid, (message_type==MESSAGE_DISCONNECT)?ADMIN_CALL_DISCONNECT:ADMIN_CALL_RELEASE, "", param->disconnectinfo.cause, param->disconnectinfo.location, 0);
- trace_header((message_type==MESSAGE_DISCONNECT)?"DISCONNECT":"RELEASE", DIRECTION_IN);
+ trace_header((message_type==MESSAGE_DISCONNECT)?(char *)"DISCONNECT":(char *)"RELEASE", DIRECTION_IN);
add_trace("cause", "value", "%d", param->disconnectinfo.cause);
add_trace("cause", "location", "%d", param->disconnectinfo.location);
end_trace();
/* collect cause */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) current multipoint cause %d location %d, received cause %d location %d.\n", ea_endpoint->ep_serial, e_multipoint_cause, e_multipoint_location, param->disconnectinfo.cause, param->disconnectinfo.location);
- if (param->disconnectinfo.cause == CAUSE_REJECTED) /* call rejected */
- {
- e_multipoint_cause = CAUSE_REJECTED;
- e_multipoint_location = param->disconnectinfo.location;
- } else
- if (param->disconnectinfo.cause==CAUSE_NORMAL && e_multipoint_cause!=CAUSE_REJECTED) /* reject via hangup */
- {
- e_multipoint_cause = CAUSE_NORMAL;
- e_multipoint_location = param->disconnectinfo.location;
- } else
- if (param->disconnectinfo.cause==CAUSE_BUSY && e_multipoint_cause!=CAUSE_REJECTED && e_multipoint_cause!=CAUSE_NORMAL) /* busy */
- {
- e_multipoint_cause = CAUSE_BUSY;
- e_multipoint_location = param->disconnectinfo.location;
- } else
- if (param->disconnectinfo.cause==CAUSE_OUTOFORDER && e_multipoint_cause!=CAUSE_BUSY && e_multipoint_cause!=CAUSE_REJECTED && e_multipoint_cause!=CAUSE_NORMAL) /* no L1 */
- {
- e_multipoint_cause = CAUSE_OUTOFORDER;
- e_multipoint_location = param->disconnectinfo.location;
- } else
- if (param->disconnectinfo.cause!=CAUSE_NOUSER && e_multipoint_cause!=CAUSE_OUTOFORDER && e_multipoint_cause!=CAUSE_BUSY && e_multipoint_cause!=CAUSE_REJECTED && e_multipoint_cause!=CAUSE_NORMAL) /* anything but not 18 */
- {
- e_multipoint_cause = param->disconnectinfo.cause;
- e_multipoint_location = param->disconnectinfo.location;
- }
+ collect_cause(&e_multipoint_cause, &e_multipoint_location, param->disconnectinfo.cause, param->disconnectinfo.location);
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 */
portlist = portlist->next;
}
if (!portlist)
- {
- PERROR("EPOINT(%d) software error: no portlist related to the calling port.\n", ea_endpoint->ep_serial);
- exit(-1);
- }
+ FATAL("EPOINT(%d) no portlist related to the calling port.\n", ea_endpoint->ep_serial);
if (message_type != MESSAGE_RELEASE)
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_RELEASE);
ea_endpoint->free_portlist(portlist);
return; /* one relation removed */
}
- if (e_multipoint_cause)
- {
- cause = e_multipoint_cause;
- location = e_multipoint_location;
- } else
+ if (e_state == EPOINT_STATE_CONNECT)
{
+ /* use cause from port after connect */
cause = param->disconnectinfo.cause;
location = param->disconnectinfo.location;
+ } else
+ {
+ /* use multipoint cause if no connect yet */
+ cause = e_multipoint_cause;
+ location = e_multipoint_location;
}
e_cfnr_call = e_cfnr_release = 0;
int haspatterns = 0;
/* check if pattern is available */
if (ea_endpoint->ep_portlist)
- if (!ea_endpoint->ep_portlist->next && ea_endpoint->ep_portlist->earlyb)
-#warning wie ist das bei einem asterisk, gibts auch tones?
- if (callpbx_countrelations(ea_endpoint->ep_call_id)==2 // we must count relations, in order not to disturb the conference ; NOTE:
+ if (!ea_endpoint->ep_portlist->next && ea_endpoint->ep_portlist->early_b)
+ if (callpbx_countrelations(ea_endpoint->ep_call_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)
case INFO_NOTIFY_REMOTE_RETRIEVAL:
case INFO_NOTIFY_USER_RESUMED:
/* set volume of rx and tx */
- if (param->setup.callerinfo.itype == INFO_ITYPE_INTERN)
+ if (param->setup.callerinfo.itype == INFO_ITYPE_ISDN_EXTENSION)
if (e_ext.txvol!=256 || e_ext.rxvol!=256)
if (portlist)
{
{
struct port_list *portlist;
struct message *message;
- class Port *port;
portlist = ea_endpoint->ep_portlist;
while(portlist)
switch(message_type)
{
case MESSAGE_DATA: /* data from port */
- /* send back to source for recording */
- if (port_id)
- {
- message = message_create(ea_endpoint->ep_serial, port_id, EPOINT_TO_PORT, message_type);
- memcpy(&message->param, param, sizeof(union parameter));
- message_put(message);
- }
-
/* check if there is a call */
if (!ea_endpoint->ep_call_id)
break;
/* continue if only one portlist */
if (ea_endpoint->ep_portlist->next != NULL)
break;
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, message_type);
- memcpy(&message->param, param, sizeof(union parameter));
- message_put(message);
+ /* forward message */
+ message_forward(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, param);
break;
case MESSAGE_TONE_EOF: /* tone is end of file */
/* 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.number);
+ 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)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in idle state.\n", ea_endpoint->ep_serial);
/* PORT sends INFORMATION message */
case MESSAGE_INFORMATION: /* additional digits received */
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call dialing more=%s (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->information.number, e_ext.number, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming call dialing more=%s (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->information.id, e_ext.number, e_callerinfo.id);
port_information(portlist, message_type, param);
break;
void EndpointAppPBX::call_connect(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *message;
+ struct interface *interface;
new_state(EPOINT_STATE_CONNECT);
// UCPY(e_call_tone, "");
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
memcpy(&message->param, param, sizeof(union parameter));
- /* screen by interface */
- if (e_connectinfo.interface[0])
+ /* screen incoming caller id */
+ interface = interface_first;
+ while(interface)
{
- /* screen incoming caller id */
- screen(1, e_connectinfo.id, sizeof(e_connectinfo.id), &e_connectinfo.ntype, &e_connectinfo.present);
+ if (!strcmp(e_connectinfo.interface, interface->name))
+ {
+ break;
+ }
+ interface = interface->next;
}
- memcpy(&message->param.connnectinfo, e_connectinfo);
+ 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])
}
/* use internal caller id */
- if (e_ext.number[0] && e_connectinfo.intern[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.intern);
+ SCPY(message->param.connectinfo.id, e_connectinfo.extension);
message->param.connectinfo.ntype = INFO_NTYPE_UNKNOWN;
}
/* handle restricted caller ids */
- apply_callerid_restriction(e_ext.anon_ignore, portlist->port_type, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.voip, message->param.connectinfo.intern, message->param.connectinfo.name);
+ 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);
/* 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.voip, message->param.connectinfo.intern, message->param.connectinfo.name));
+ 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)
void EndpointAppPBX::call_setup(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *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
{
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.number,param->setup.dialinginfo.number,strlen(e_dialinginfo.number)))
+ 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 */
/* if we have a pending redial, so we just adjust the dialing number */
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.number);
+ 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 (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.number);
- SCAT(e_dialing_queue, param->setup.dialinginfo.number + strlen(e_dialinginfo.number));
+ 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
{
/* 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.number, param->setup.dialinginfo.number, param->setup.dialinginfo.number+strlen(e_dialinginfo.number));
+ 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);
- SCPY(message->param.information.number, param->setup.dialinginfo.number + strlen(e_dialinginfo.number));
+ SCPY(message->param.information.id, param->setup.dialinginfo.id + strlen(e_dialinginfo.id));
message->param.information.ntype = INFO_NTYPE_UNKNOWN;
message_put(message);
logmessage(message);
return;
}
/* if an internal extension is dialed, copy that number */
- if (param->setup.dialinginfo.itype==INFO_ITYPE_INTERN || param->setup.dialinginfo.itype==INFO_ITYPE_VBOX)
- SCPY(e_ext.number, param->setup.dialinginfo.number);
+ 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])
{
memcpy(&e_redirinfo, ¶m->setup.redirinfo, sizeof(e_redirinfo));
memcpy(&e_capainfo, ¶m->setup.capainfo, sizeof(e_capainfo));
- /* screen by interface */
- if (e_callerinfo.interface[0])
+ /* screen incoming caller id */
+ interface = interface_first;
+ while(interface)
{
- /* screen incoming caller id */
- screen(1, e_callerinfo.id, sizeof(e_callerinfo.id), &e_callerinfo.ntype, &e_callerinfo.present);
+ 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)
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, portlist->port_type, message->param.notifyinfo.id, &message->param.notifyinfo.ntype, &message->param.notifyinfo.present, NULL, message->param.notifyinfo.voip, message->param.notifyinfo.intern, 0);
+ 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);
/* 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.voip, message->param.notifyinfo.intern, NULL));
+ 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);
logmessage(message);
portlist = portlist->next;
portlist = ea_endpoint->ep_portlist;
/* send MESSAGE_DATA to port */
- if (call_id == ea_endpoint->ep_call_id)
+ if (message_type == MESSAGE_DATA)
{
- if (message_type == MESSAGE_DATA)
+ if (call_id == ea_endpoint->ep_call_id) // still linked with call
{
/* skip if no port relation */
if (!portlist)
/* skip if more than one port relation */
if (portlist->next)
return;
- /* send audio data to port */
- message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_DATA);
- memcpy(&message->param, param, sizeof(union parameter));
- message_put(message);
+ /* forward audio data to port */
+ message_forward(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, param);
return;
}
}
/* CALL 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.number);
+ 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);
call_information(portlist, message_type, param);
break;
/* CALL 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.intern, param->setup.callerinfo.id, param->setup.dialinginfo.number, param->setup.dialinginfo.itype);
+ 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);
call_setup(portlist, message_type, param);
return;
break;
/* now we send a release to the ringing endpoint */
message = message_create(ea_endpoint->ep_call_id, eapp->ea_endpoint->ep_serial, CALL_TO_EPOINT, MESSAGE_RELEASE);
- message->param.disconnectinfo.cause = 26; /* non selected user clearing */
+ message->param.disconnectinfo.cause = CAUSE_NONSELECTED; /* non selected user clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message_put(message);
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, ea_endpoint->ep_portlist->port_type, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.voip, message->param.connectinfo.intern, message->param.connectinfo.name);
+ 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);
/* 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.voip, message->param.connectinfo.intern, message->param.connectinfo.name));
+ 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);
/* we send a connect to the audio path (not for vbox) */
message_put(message);
/* beeing paranoid, we make call update */
- callpbx->c_mixer = 1;
+ callpbx->c_updatebridge = 1;
if (options.deb & DEBUG_EPOINT)
{
{
/* detach other endpoint on hold */
*other_relation_pointer = other_relation->next;
- memset(other_relation, 0, sizeof(struct call_relation));
- free(other_relation);
+ FREE(other_relation, sizeof(struct call_relation));
cmemuse--;
other_relation = *other_relation_pointer;
other_eapp->ea_endpoint->ep_call_id = NULL;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d)d-call completely removed!\n");
/* mixer must update */
- our_callpbx->c_mixer = 1; /* update mixer flag */
+ our_callpbx->c_updatebridge = 1; /* update mixer flag */
/* we send a retrieve to that endpoint */
// mixer will update the hold-state of the call and send it to the endpoints is changes
void EndpointAppPBX::logmessage(struct message *message)
{
- class Port *port;
- class Pdss1 *pdss1;
char *logtext = "unknown";
char buffer[64];
{
case MESSAGE_SETUP:
trace_header("SETUP", DIRECTION_OUT);
- if (message->param.setup.callerinfo.intern[0])
- add_trace("extension", NULL, "%s", message->param.setup.callerinfo.intern);
+ if (message->param.setup.callerinfo.extension[0])
+ add_trace("extension", NULL, "%s", message->param.setup.callerinfo.extension);
add_trace("caller id", "number", "%s", numberrize_callerinfo(message->param.setup.callerinfo.id, message->param.setup.callerinfo.ntype));
if (message->param.setup.callerinfo.present == INFO_PRESENT_RESTRICTED)
add_trace("caller id", "present", "restricted");
- if (message->param.setup.redirinfo.number[0])
+ if (message->param.setup.redirinfo.id[0])
{
add_trace("redir'ing", "number", "%s", numberrize_callerinfo(message->param.setup.redirinfo.id, message->param.setup.redirinfo.ntype));
if (message->param.setup.redirinfo.present == INFO_PRESENT_RESTRICTED)
add_trace("redir'ing", "present", "restricted");
}
- if (message->param.setup.dialinginfo.number[0])
- add_trace("dialing", NULL, "%s", message->param.setup.dialinginfo.number);
+ if (message->param.setup.dialinginfo.id[0])
+ add_trace("dialing", NULL, "%s", message->param.setup.dialinginfo.id);
end_trace();
break;
case MESSAGE_CONNECT:
trace_header("CONNECT", DIRECTION_OUT);
- if (message->param.connectinfo.intern[0])
- add_trace("extension", NULL, "%s", message->param.connectinfo.intern);
+ if (message->param.connectinfo.extension[0])
+ add_trace("extension", NULL, "%s", message->param.connectinfo.extension);
add_trace("connect id", "number", "%s", numberrize_callerinfo(message->param.connectinfo.id, message->param.connectinfo.ntype));
if (message->param.connectinfo.present == INFO_PRESENT_RESTRICTED)
add_trace("connect id", "present", "restricted");
trace_header("NOTIFY", DIRECTION_OUT);
if (message->param.notifyinfo.notify)
add_trace("indicator", NULL, "%s", logtext);
- if (message->param.notifyinfo.number[0])
+ if (message->param.notifyinfo.id[0])
{
add_trace("redir'on", "number", "%s", numberrize_callerinfo(message->param.notifyinfo.id, message->param.notifyinfo.ntype));
if (message->param.notifyinfo.present == INFO_PRESENT_RESTRICTED)
case MESSAGE_INFORMATION:
trace_header("INFORMATION", DIRECTION_OUT);
- add_trace("dialing", NULL, "%s", message->param.information.number);
+ add_trace("dialing", NULL, "%s", message->param.information.id);
end_trace();
break;