/*****************************************************************************\
** **
-** PBX4Linux **
+** Linux Call Router **
** **
**---------------------------------------------------------------------------**
** Copyright: Andreas Eversberg **
#include <poll.h>
#include "main.h"
-
class EndpointAppPBX *apppbx_first = NULL;
/*
e_ext.rights = 4; /* international */
e_ext.rxvol = e_ext.txvol = 256;
e_state = EPOINT_STATE_IDLE;
- e_terminal[0] = '\0';
- e_terminal_interface[0] = '\0';
+ e_ext.number[0] = '\0';
+ e_extension_interface[0] = '\0';
memset(&e_callerinfo, 0, sizeof(struct caller_info));
memset(&e_dialinginfo, 0, sizeof(struct dialing_info));
memset(&e_connectinfo, 0, sizeof(struct connect_info));
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;
-// e_call_tone[0] = e_hold_tone[0] = '\0';
- e_call_pattern /*= e_hold_pattern*/ = 0;
+// e_join_tone[0] = e_hold_tone[0] = '\0';
+ e_join_pattern /*= e_hold_pattern*/ = 0;
e_redial = 0;
e_tone[0] = '\0';
e_adminid = 0; // will be set, if call was initiated via admin socket
e_vbox[0] = '\0';
e_tx_state = NOTIFY_STATE_ACTIVE;
e_rx_state = NOTIFY_STATE_ACTIVE;
- e_call_cause = e_call_location = 0;
+ e_join_cause = e_join_location = 0;
/*********************************
*********************************
********* ATTENTION *************
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;
}
+/*
+ * trace header for application
+ */
+void EndpointAppPBX::trace_header(char *name, int direction)
+{
+ struct trace _trace;
+
+ char msgtext[sizeof(_trace.name)];
+
+ SCPY(msgtext, name);
+
+ /* init trace with given values */
+ start_trace(0,
+ NULL,
+ numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype),
+ e_dialinginfo.id,
+ direction,
+ CATEGORY_EP,
+ ea_endpoint->ep_serial,
+ msgtext);
+}
+
+
EPOINT_STATE_NAMES
/* set new endpoint state
*/
void EndpointAppPBX::new_state(int state)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) new state %s --> %s\n", ea_endpoint->ep_serial, state_name[e_state], state_name[state]);
+#if 0
+ if (e_state != state)
+ {
+ trace_header("NEW STATE", DIRECTION_NONE);
+ add_trace("state", "old", "%s", state_name[e_state]);
+ add_trace("state", "new", "%s", state_name[state]);
+ end_trace();
+ }
+#endif
e_state = state;
}
/* 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();
}
}
-/* release call and port (as specified)
+/* release join and port (as specified)
*/
-void EndpointAppPBX::release(int release, int calllocation, int callcause, int portlocation, int portcause)
+void EndpointAppPBX::release(int release, int joinlocation, int joincause, int portlocation, int portcause)
{
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);
+ admin_call_response(e_adminid, ADMIN_CALL_RELEASE, "", joincause, joinlocation, 0);
/* if a release is pending */
- if (release==RELEASE_CALL || release==RELEASE_ALL || release==RELEASE_PORT_CALLONLY)
+ if (release==RELEASE_JOIN || release==RELEASE_ALL || release==RELEASE_PORT_JOINONLY)
{
- 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)
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d): do pending release (joincause %d location %d)\n", ea_endpoint->ep_serial, joincause, joinlocation);
+ if (ea_endpoint->ep_join_id)
{
- 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_join_id, EPOINT_TO_JOIN, MESSAGE_RELEASE);
+ message->param.disconnectinfo.cause = joincause;
+ message->param.disconnectinfo.location = joinlocation;
+ message_put(message);
+ ea_endpoint->ep_join_id = 0;
}
- ea_endpoint->ep_call_id = 0;
- e_call_pattern = 0;
+ e_join_pattern = 0;
#if 0
- if (release != RELEASE_PORT_CALLONLY)
+ if (release != RELEASE_PORT_JOINONLY)
{
if (e_hold_id)
- call_release(e_hold_id, ea_endpoint->ep_serial, 1, calllocation, callcause);
+ join_release(e_hold_id, ea_endpoint->ep_serial, 1, joinlocation, joincause);
e_hold_id = 0;
}
#endif
}
- if (release==RELEASE_ALL || release==RELEASE_PORT_CALLONLY)
+ if (release==RELEASE_ALL || release==RELEASE_PORT_JOINONLY)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) do pending release (portcause %d portlocation)\n", ea_endpoint->ep_serial, portcause, portlocation);
while((portlist = ea_endpoint->ep_portlist))
message->param.disconnectinfo.cause = portcause;
message->param.disconnectinfo.location = portlocation;
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
ea_endpoint->free_portlist(portlist);
}
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;
e_vbox[0] = '\0';
e_tx_state = NOTIFY_STATE_ACTIVE;
e_rx_state = NOTIFY_STATE_ACTIVE;
- e_call_cause = e_call_location = 0;
+ e_join_cause = e_join_location = 0;
e_rule_nesting = 0;
/* the caller info of the callback user */
memcpy(&e_callbackinfo, &e_callerinfo, sizeof(e_callbackinfo));
memset(&e_dialinginfo, 0, sizeof(e_dialinginfo));
/* create dialing by callerinfo */
- if (e_terminal[0] && e_terminal_interface[0])
+ if (e_ext.number[0] && e_extension_interface[0])
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) preparing callback to internal: %s interface %s\n", ea_endpoint->ep_serial, e_terminal, e_terminal_interface);
+ 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_terminal);
- SCPY(e_dialinginfo.interfaces, e_terminal_interface);
+ SCPY(e_dialinginfo.id, e_ext.number);
+ SCPY(e_dialinginfo.interfaces, e_extension_interface);
e_dialinginfo.itype = INFO_ITYPE_ISDN_EXTENSION;
e_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
} else
{
if (e_cbto[0])
{
- 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)
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
message->param.notifyinfo.notify = notify;
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
portlist = portlist->next;
}
}
{
/* we must be in a call, in order to send messages to the call */
- if (e_terminal[0] == '\0')
+ if (e_ext.number[0] == '\0')
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) IGNORING keypad received not from extension.\n", ea_endpoint->ep_serial);
return;
{
/* join conference */
case '3':
- if (ea_endpoint->ep_call_id == 0)
+ if (ea_endpoint->ep_join_id == 0)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) keypad received during connect but not during a call.\n", ea_endpoint->ep_serial);
break;
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join call with call on hold\n", ea_endpoint->ep_serial);
- join_call();
+ join_join();
break;
/* crypt shared */
return;
}
- if (e_call_pattern /* pattern are provided */
+ if (e_join_pattern /* pattern are provided */
&& !(e_ext.own_setup && e_state == EPOINT_STATE_IN_SETUP)
&& !(e_ext.own_setup && e_state == EPOINT_STATE_IN_OVERLAP)
&& !(e_ext.own_proceeding && e_state == EPOINT_STATE_IN_PROCEEDING)
SCPY(message->param.tone.dir, e_ext.tones_dir[0]?e_ext.tones_dir:options.tones_dir);
SCPY(message->param.tone.name, tone);
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
}
* 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)
if (!strcasecmp(interface->name, ifname))
{
/* found explicit interface */
- printlog("%3d interface %s found as given\n", ea_endpoint->ep_serial, ifname);
- goto found;
+ trace_header("CHANNEL SELECTION (found interface)", DIRECTION_NONE);
+ add_trace("interface", NULL, "%s", ifname);
+ end_trace();
+ goto foundif;
}
} else
if (!interface->extension)
{
/* found non extension */
- printlog("%3d interface %s found, that is not an extension\n", ea_endpoint->ep_serial, interface->name);
- goto found;
+ trace_header("CHANNEL SELECTION (found non extension interface)", DIRECTION_NONE);
+ add_trace("interface", NULL, "%s", interface->name);
+ end_trace();
+ goto foundif;
}
}
interface = interface->next;
goto checknext;
+foundif:
/* see if interface has ports */
if (!interface->ifport)
{
/* no ports */
- printlog("%3d interface %s has no active ports, skipping.\n", ea_endpoint->ep_serial, interface->name);
+ trace_header("CHANNEL SELECTION (interface has no active ports, skipping)", DIRECTION_NONE);
+ add_trace("interface", NULL, "%s", interface->name);
+ end_trace();
interface = interface->next;
goto checknext;
}
/* 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++;
}
- printlog("%3d starting with port#%d position %d (round-robin)\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
+ trace_header("CHANNEL SELECTION (starting round-robin)", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport_start->portnum);
+ add_trace("position", NULL, "%d", index);
+ end_trace();
}
/* loop ports */
/* see if port is available */
if (!ifport->mISDNport)
{
- printlog("%3d port#%d position %d is not available, skipping.\n", ea_endpoint->ep_serial, ifport->portnum, index);
+ trace_header("CHANNEL SELECTION (port not available, skipping)", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport->portnum);
+ add_trace("position", NULL, "%d", index);
+ end_trace();
goto portbusy;
}
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)
{
- printlog("%3d port#%d position %d is administratively blocked, skipping.\n", ea_endpoint->ep_serial, ifport->portnum, index);
+ trace_header("CHANNEL SELECTION (port blocked by admin, skipping)", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport->portnum);
+ add_trace("position", NULL, "%d", index);
+ end_trace();
goto portbusy;
}
- /* see if link is up */
+ /* see if link is up on PTP*/
if (mISDNport->ptp && !mISDNport->l2link)
{
- printlog("%3d port#%d position %d is ptp but layer 2 is down.\n", ea_endpoint->ep_serial, ifport->portnum, index);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) skipping because it is PTP with L2 down\n", ea_endpoint->ep_serial);
+ trace_header("CHANNEL SELECTION (port is ptp with layer 2 down, skipping)", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport->portnum);
+ add_trace("position", NULL, "%d", index);
+ end_trace();
goto portbusy;
}
/* 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;
if (mISDNport->b_port[i] == NULL)
{
*channel = i+1+(i>=15);
- printlog("%3d port#%d position %d selecting free channel %d\n", ea_endpoint->ep_serial, ifport->portnum, index, *channel);
+ trace_header("CHANNEL SELECTION (selecting free channel)", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport->portnum);
+ add_trace("position", NULL, "%d", index);
+ add_trace("channel", NULL, "%d", *channel);
+ end_trace();
break;
}
i++;
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 */
}
- printlog("%3d port#%d position %d using with 'any channel'\n", ea_endpoint->ep_serial, ifport->portnum, index);
- *channel = SEL_CHANNEL_ANY;
+ trace_header("CHANNEL SELECTION (using 'any channel')", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport->portnum);
+ add_trace("position", NULL, "%d", index);
+ end_trace();
+ *channel = CHANNEL_ANY;
break;
case CHANNEL_NO: /* call waiting */
- printlog("%3d port#%d position %d using with 'no channel'\n", ea_endpoint->ep_serial, ifport->portnum, index);
- *channel = SEL_CHANNEL_NO;
+ 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();
+ *channel = CHANNEL_NO;
break;
default:
if (mISDNport->b_port[i] == NULL)
{
*channel = selchannel->channel;
- printlog("%3d port#%d position %d selecting given channel %d\n", ea_endpoint->ep_serial, ifport->portnum, index, *channel);
+ trace_header("CHANNEL SELECTION (selecting given channel)", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport->portnum);
+ add_trace("position", NULL, "%d", index);
+ add_trace("channel", NULL, "%d", *channel);
+ end_trace();
break;
}
break;
return(mISDNport);
}
- printlog("%3d port#%d position %d skipping, because no channel found.\n", ea_endpoint->ep_serial, ifport->portnum, index);
+ trace_header("CHANNEL SELECTION (skipping, no channel found)", DIRECTION_NONE);
+ add_trace("port", NULL, "%d", ifport->portnum);
+ add_trace("position", NULL, "%d", index);
+ end_trace();
portbusy:
/* go next port, until all ports are checked */
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));
while(atemp)
{
if (atemp != this)
- if (!strcmp(atemp->e_terminal, e_terminal))
+ if (!strcmp(atemp->e_ext.number, e_ext.number))
break;
atemp = atemp->next;
}
if (atemp)
{
PERROR("EPOINT(%d) noknocking and currently a call\n", ea_endpoint->ep_serial);
- release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_BUSY, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYSPE_ call, port */
+ release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_BUSY, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYSPE_ join, port */
return; /* must exit here */
}
}
/* 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);
- release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_OUTOFORDER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, call, port */
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) extension %s not configured\n", ea_endpoint->ep_serial, e_dialinginfo.id);
+ release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_OUTOFORDER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
return; /* must exit here */
}
{
if (checkapp != this) /* any other endpoint except our own */
{
- if (!strcmp(checkapp->e_terminal, e_terminal))
+ if (!strcmp(checkapp->e_ext.number, e_ext.number))
{
/* present to forwarded party */
if (e_ext.anon_ignore && e_callerinfo.id[0])
/* 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 joins for extension %s to interfaces %s\n", ea_endpoint->ep_serial, e_dialinginfo.id, p);
while(*p)
{
ifname[0] = '\0';
mISDNport = hunt_port(ifname, &channel);
if (!mISDNport)
{
- printlog("%3d endpoint INTERFACE '%s' not found or busy\n", ea_endpoint->ep_serial, ifname);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) given interface: '%s' not found or too busy to accept calls.\n", ea_endpoint->ep_serial, e_ext.interfaces);
+ trace_header("INTERFACE (not found or busy)", DIRECTION_NONE);
+ add_trace("interface", NULL, "%s", ifname);
+ end_trace();
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_terminal);
-//terminal if (e_dialinginfo.number)
-//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.number);
+//terminal SCPY(message->param.setup.from_terminal, e_ext.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);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
anycall = 1;
}
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;
- if (!strcmp(p, "vbox") && e_terminal[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 */
p += strlen(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_terminal); /* cfp or any other direct forward/vbox */
+ UCPY(cfp, e_ext.number); /* cfp or any other direct forward/vbox */
} else
{
cfp[0] = '\0';
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)
- {
- printlog("%3d endpoint INTERFACE Layer 2 of interface '%s' is down.\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) skipping because it is PTP with L2 down\n", ea_endpoint->ep_serial);
- 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)
- {
- printlog("%3d endpoint INTERFACE Interface '%s' has no free channel.\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) skipping because it is not single link port_list NT-modem OR no channel available.\n", ea_endpoint->ep_serial);
- mISDNport = mISDNport->next;
- continue;
- }
- }
- /* found interface */
- printlog("%3d endpoint INTERFACE Interface '%s' found for external call.\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- 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;
- printlog("%3d endpoint INTERFACE External interface not found or busy.\n", ea_endpoint->ep_serial);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) given interface: '%s' too busy to accept calls.\n", ea_endpoint->ep_serial, e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
+ trace_header("INTERFACE (too busy)", DIRECTION_NONE);
+ add_trace("interface", NULL, "%s", e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
+ end_trace();
}
}
if (!port)
}
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_terminal);
+ 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_terminal);
-//terminal if (e_dialinginfo.number)
-//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.number);
+//terminal SCPY(message->param.setup.from_terminal, e_ext.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);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
anycall = 1;
}
/* now we have all ports created */
if (!anycall)
{
- printlog("%3d endpoint INTERFACE No port or no parallel forwarding defined. Nothing to call to.\n", ea_endpoint->ep_serial);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no port or no cfp defined for extension, nothing to dial.\n", ea_endpoint->ep_serial);
- if (!ea_endpoint->ep_call_id)
+ trace_header("INTERFACE (no extension's interface)", DIRECTION_NONE);
+ end_trace();
+ if (!ea_endpoint->ep_join_id)
break;
- release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, cause, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, call, port */
+ release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, cause, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
return; /* must exit here */
}
break;
/* *********************** 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)
- {
- printlog("%3d endpoint INTERFACE Layer 2 of interface '%s' is down.\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) skipping because it is PTP with L2 down\n", ea_endpoint->ep_serial);
- 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)
- {
- printlog("%3d endpoint INTERFACE Interface '%s' has no free channel.\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) skipping because it is not single link port_list NT-modem OR no channel available.\n", ea_endpoint->ep_serial);
- mISDNport = mISDNport->next;
- continue;
- }
- }
- /* found interface */
- printlog("%3d endpoint INTERFACE Interface '%s' found for external call.\n", ea_endpoint->ep_serial, mISDNport->interface_name);
- break;
- }
- mISDNport = mISDNport->next;
- }
+ /* hunt for mISDNport and create Port */
+ mISDNport = hunt_port(e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:NULL, &channel);
if (!mISDNport)
{
- printlog("%3d endpoint INTERFACE External interface not found or busy.\n", ea_endpoint->ep_serial);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) given interface: '%s' too busy to accept calls.\n", ea_endpoint->ep_serial, e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
+ trace_header("INTERFACE (too busy)", DIRECTION_NONE);
+ add_trace("interface", NULL, "%s", e_dialinginfo.interfaces[0]?e_dialinginfo.interfaces:"any interface");
+ end_trace();
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)
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no external port available\n", ea_endpoint->ep_serial);
- goto check_anycall_extern;
- }
+ 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_terminal);
-//terminal if (e_dialinginfo.number)
-//terminal SCPY(message->param.setup.to_terminal, e_dialinginfo.number);
+//terminal SCPY(message->param.setup.from_terminal, e_ext.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);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
anycall = 1;
} while(*p);
/* now we have all ports created */
if (!anycall)
{
- printlog("%3d endpoint INTERFACE No free port found for making any call.\n", ea_endpoint->ep_serial);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no port found which is idle for at least one number\n", ea_endpoint->ep_serial);
- if (!ea_endpoint->ep_call_id)
+ trace_header("INTERFACE (no free ports found)", DIRECTION_NONE);
+ end_trace();
+ if (!ea_endpoint->ep_join_id)
break;
- release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOCHANNEL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, call, port */
+ release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOCHANNEL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
return; /* must exit here */
}
break;
e_multipoint_cause = CAUSE_NOUSER;
e_multipoint_location = LOCATION_PRIVATE_LOCAL;
new_state(EPOINT_STATE_IN_OVERLAP);
- e_call_pattern = 0;
+ e_join_pattern = 0;
process_dialing();
return(1); /* we must exit, because our endpoint might be gone */
} else
message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
ea_endpoint->free_portlist(portlist);
}
/* put on hold */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_HOLD;
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
+ message->param.audiopath = CHANNEL_STATE_HOLD;
message_put(message);
/* indicate no patterns */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_NOPATTERN);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
message_put(message);
- /* set setup state, since we have no response from the new call */
+ /* set setup state, since we have no response from the new join */
new_state(EPOINT_STATE_OUT_SETUP);
}
} else
e_rule = e_ruleset->rule_first;
e_action = NULL;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) password timeout %s\n", ea_endpoint->ep_serial, e_extdialing);
- printlog("%3d endpoint PASSWORD timeout\n", ea_endpoint->ep_serial);
+ trace_header("PASSWORD timeout", DIRECTION_NONE);
+ end_trace();
e_connectedmode = 0;
e_dtmf = 0;
new_state(EPOINT_STATE_OUT_DISCONNECT);
notify_active();
e_tx_state = NOTIFY_STATE_ACTIVE;
- printlog("%3d endpoint HOOKFLASH\n", ea_endpoint->ep_serial);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dtmf hookflash detected.\n", ea_endpoint->ep_serial);
+ trace_header("HOOKFLASH DTMF", DIRECTION_NONE);
+ end_trace();
if (ea_endpoint->ep_use > 1)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot hooflash while child process is running.\n", ea_endpoint->ep_serial);
return;
}
/* dialtone after pressing the hash key */
- process_hangup(e_call_cause, e_call_location);
+ process_hangup(e_join_cause, e_join_location);
e_multipoint_cause = CAUSE_NOUSER;
e_multipoint_location = LOCATION_PRIVATE_LOCAL;
port = find_port_id(ea_endpoint->ep_portlist->port_id);
{
port->set_echotest(0);
}
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
- release(RELEASE_CALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, call, port */
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
}
e_ruleset = ruleset_main;
if (e_ruleset)
e_action = NULL;
new_state(EPOINT_STATE_IN_OVERLAP);
e_connectedmode = 1;
- SCPY(e_dialinginfo.number, e_ext.prefix);
- e_extdialing = e_dialinginfo.number;
- e_call_pattern = 0;
- if (e_dialinginfo.number[0])
+ SCPY(e_dialinginfo.id, e_ext.prefix);
+ e_extdialing = e_dialinginfo.id;
+ e_join_pattern = 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;
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
portlist->port_type = param->setup.port_type;
memcpy(&e_callerinfo, ¶m->setup.callerinfo, sizeof(e_callerinfo));
memcpy(&e_dialinginfo, ¶m->setup.dialinginfo, sizeof(e_dialinginfo));
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_terminal, e_callerinfo.intern);
- SCPY(e_terminal_interface, e_callerinfo.interface);
+ 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);
}
- printlog("%3d incoming %s='%s'%s%s%s%s dialing='%s'\n",
- ea_endpoint->ep_serial,
- (e_callerinfo.intern[0])?"SETUP from extension":"SETUP from extern",
- (e_callerinfo.intern[0])?e_callerinfo.intern:e_callerinfo.id,
- (e_callerinfo.present==INFO_PRESENT_RESTRICTED)?" anonymous":"",
- (e_redirinfo.id[0])?"redirected='":"",
- e_redirinfo.id,
- (e_redirinfo.id[0])?"'":"",
- e_dialinginfo.number
- );
- 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_terminal);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call from extension '%s'\n", ea_endpoint->ep_serial, e_ext.number);
/* get extension's info about caller */
- if (!read_extension(&e_ext, e_terminal))
+ if (!read_extension(&e_ext, e_ext.number))
{
/* extension doesn't exist */
- printlog("%3d endpoint EXTENSION '%s' doesn't exist, please check or create.\n", ea_endpoint->ep_serial, e_callerinfo.id);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) rejecting call from not existing extension: '%s'\n", ea_endpoint->ep_serial, e_terminal);
+ trace_header("EXTENSION (not created)", DIRECTION_IN);
+ add_trace("extension", NULL, "%s", e_ext.number);
+ end_trace();
message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
new_state(EPOINT_STATE_OUT_DISCONNECT);
set_tone(portlist, "cause_80"); /* pbx cause: extension not authorized */
- e_terminal[0] = '\0'; /* no terminal */
+ e_ext.number[0] = '\0'; /* no terminal */
return;
}
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);
/* extension is written */
if (writeext)
- write_extension(&e_ext, e_terminal);
+ 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_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO))
{
/* check if we are a terminal */
- if (e_terminal[0] == '\0')
+ if (e_ext.number[0] == '\0')
PERROR("Port(%d) cannot record because we are not a terminal\n", ea_endpoint->ep_serial);
else
{
port = find_port_id(portlist->port_id);
if (port)
- port->open_record(e_ext.record, 0, 0, e_terminal, e_ext.anon_ignore, "", 0);
+ port->open_record(e_ext.record, 0, 0, e_ext.number, e_ext.anon_ignore, "", 0);
}
}
} else
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call from external port\n", ea_endpoint->ep_serial);
/* no terminal identification */
- e_terminal[0] = '\0';
- e_terminal_interface[0] = '\0';
+ e_ext.number[0] = '\0';
+ e_extension_interface[0] = '\0';
memset(&e_ext, 0, sizeof(e_ext));
e_ext.rights = 4; /* right to dial internat */
}
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
{
- if (e_terminal[0])
+ if (e_ext.number[0])
set_tone(portlist, "dialpbx");
else
set_tone(portlist, "dialtone");
new_state(EPOINT_STATE_IN_OVERLAP);
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_OVERLAP);
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
}
/* port MESSAGE_INFORMATION */
void EndpointAppPBX::port_information(struct port_list *portlist, int message_type, union parameter *param)
{
- printlog("%3d incoming INFORMATION information='%s'\n",
- ea_endpoint->ep_serial,
- param->information.number
- );
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
e_overlap = 1;
/* 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_terminal, 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();
}
/* port MESSAGE_DTMF */
void EndpointAppPBX::port_dtmf(struct port_list *portlist, int message_type, union parameter *param)
{
- printlog("%3d incoming DTMF digit='%c'\n",
- ea_endpoint->ep_serial,
- param->dtmf
- );
+ trace_header("DTMF", DIRECTION_IN);
+ add_trace("digit", NULL, "%c", param->dtmf);
+ end_trace();
/* only if dtmf detection is enabled */
if (!e_dtmf)
{
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();
}
}
{
struct message *message;
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
/* signal to call tool */
admin_call_response(e_adminid, ADMIN_CALL_SETUP_ACK, "", 0, 0, 0);
- printlog("%3d incoming SETUP ACKNOWLEDGE\n",
- ea_endpoint->ep_serial
- );
if (e_dialing_queue[0] && portlist)
{
/* send what we have not dialed yet, because we had no setup complete */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing pending digits: '%s'\n", ea_endpoint->ep_serial, e_dialing_queue);
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
- 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);
+ logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
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);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
message_put(message);
/* connect audio, if not already */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
} else
{
/* indicate no patterns */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_NOPATTERN);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
message_put(message);
/* disconnect audio, if not already */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_HOLD;
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
+ message->param.audiopath = CHANNEL_STATE_HOLD;
message_put(message);
}
new_state(EPOINT_STATE_OUT_OVERLAP);
- /* if we are in a call */
- if (ea_endpoint->ep_call_id)
+ /* if we are in a join */
+ if (ea_endpoint->ep_join_id)
{
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, message_type);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
memcpy(&message->param, param, sizeof(union parameter));
message_put(message);
}
{
struct message *message;
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
/* signal to call tool */
admin_call_response(e_adminid, ADMIN_CALL_PROCEEDING, "", 0, 0, 0);
- printlog("%3d incoming PROCEEDING\n",
- ea_endpoint->ep_serial
- );
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);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
message_put(message);
/* connect audio, if not already */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
} else
{
/* indicate no patterns */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_NOPATTERN);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
message_put(message);
/* disconnect audio, if not already */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_HOLD;
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
+ message->param.audiopath = CHANNEL_STATE_HOLD;
message_put(message);
}
/* if we are in a call */
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, message_type);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
memcpy(&message->param, param, sizeof(union parameter));
message_put(message);
}
{
struct message *message;
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
/* signal to call tool */
admin_call_response(e_adminid, ADMIN_CALL_ALERTING, "", 0, 0, 0);
- printlog("%3d incoming ALERTING\n",
- ea_endpoint->ep_serial
- );
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);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
message_put(message);
/* connect audio, if not already */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
} else
{
/* indicate no patterns */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_NOPATTERN);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOPATTERN);
message_put(message);
/* disconnect audio, if not already */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_HOLD;
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
+ message->param.audiopath = CHANNEL_STATE_HOLD;
message_put(message);
}
/* if we are in a call */
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, message_type);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
memcpy(&message->param, param, sizeof(union parameter));
message_put(message);
}
unsigned long port_id = portlist->port_id;
struct port_list *tportlist;
class Port *port;
+ struct interface *interface;
+
+ 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);
memcpy(&e_connectinfo, ¶m->connectinfo, sizeof(e_connectinfo));
- printlog("%3d incoming CONNECT id='%s'%s\n",
- ea_endpoint->ep_serial,
- (e_connectinfo.intern[0])?e_connectinfo.intern:e_connectinfo.id,
- (e_connectinfo.present==INFO_PRESENT_RESTRICTED)?" anonymous":""
- );
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing all other ports (start)\n", ea_endpoint->ep_serial);
while(ea_endpoint->ep_portlist->next) /* as long as we have at least two ports */
{
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);
+ logmessage(message->type, &message->param, tportlist->port_id, DIRECTION_OUT);
ea_endpoint->free_portlist(tportlist);
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing all other ports (end)\n", ea_endpoint->ep_serial);
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_terminal);
+ SCPY(e_connectinfo.extension, e_ext.number);
/* we store the connected port number */
- SCPY(e_terminal_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_terminal);
- 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;
}
}
e_cfnr_call = e_cfnr_release = 0;
- if (e_terminal[0])
+ if (e_ext.number[0])
e_dtmf = 1; /* allow dtmf */
-// if (call_countrelations(ea_endpoint->ep_call_id) == 2)
+// 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 */
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;
}
}
}
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, message_type);
+ 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);
}
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
} else if (!e_adminid)
{
/* callback */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have a callback, so we create a call with cbcaller: \"%s\".\n", ea_endpoint->ep_serial, e_cbcaller);
- SCPY(e_terminal, e_cbcaller);
+ SCPY(e_ext.number, e_cbcaller);
new_state(EPOINT_STATE_IN_OVERLAP);
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) callback from extension '%s'\n", ea_endpoint->ep_serial, e_terminal);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) callback from extension '%s'\n", ea_endpoint->ep_serial, e_ext.number);
/* get extension's info about terminal */
- if (!read_extension(&e_ext, e_terminal))
+ if (!read_extension(&e_ext, e_ext.number))
{
/* extension doesn't exist */
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) rejecting callback from not existing extension: '%s'\n", ea_endpoint->ep_serial, e_terminal);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) rejecting callback from not existing extension: '%s'\n", ea_endpoint->ep_serial, e_ext.number);
message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
new_state(EPOINT_STATE_OUT_DISCONNECT);
set_tone(portlist, "cause_80"); /* pbx cause: extension not authorized */
/* 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_terminal);
+ 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_callerinfo.ntype = e_ext.id_next_call_type;
e_ext.id_next_call_present = -1;
/* extension is written */
- write_extension(&e_ext, e_terminal);
+ write_extension(&e_ext, e_ext.number);
} else
{
SCPY(e_callerinfo.id, e_ext.callerid);
e_dtmf = 1;
/* check if caller id is NOT authenticated */
- if (!parse_callbackauth(e_terminal, &e_callbackinfo))
+ if (!parse_callbackauth(e_ext.number, &e_callbackinfo))
{
/* make call state to enter password */
new_state(EPOINT_STATE_IN_OVERLAP);
e_action = &action_password_write;
e_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();
}
/* start recording if enabled, not when answering machine answers */
- if (param->connectinfo.itype!=INFO_ITYPE_VBOX && e_terminal[0] && e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO))
+ if (param->connectinfo.itype!=INFO_ITYPE_VBOX && e_ext.number[0] && e_ext.record!=CODEC_OFF && (e_capainfo.bearer_capa==INFO_BC_SPEECH || e_capainfo.bearer_capa==INFO_BC_AUDIO))
{
/* check if we are a terminal */
- if (e_terminal[0] == '\0')
+ if (e_ext.number[0] == '\0')
PERROR("Port(%d) cannot record because we are not a terminal\n", ea_endpoint->ep_serial);
else
{
port = find_port_id(portlist->port_id);
if (port)
- port->open_record(e_ext.record, 0, 0, e_terminal, e_ext.anon_ignore, "", 0);
+ port->open_record(e_ext.record, 0, 0, e_ext.number, e_ext.anon_ignore, "", 0);
}
}
}
int cause,
location;
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
/* 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);
- printlog("%3d incoming %s cause='%d' (%s) location='%d' (%s)\n",
- ea_endpoint->ep_serial,
- (message_type==MESSAGE_DISCONNECT)?"DISCONNECT":"RELEASE",
- param->disconnectinfo.cause,
- (param->disconnectinfo.cause>0 && param->disconnectinfo.cause<128)?isdn_cause[param->disconnectinfo.cause].english:"-",
- param->disconnectinfo.location,
- (param->disconnectinfo.location>=0 && param->disconnectinfo.location<16)?isdn_location[param->disconnectinfo.location].english:"-"
- );
-
//#warning does this work? only disconnect when incoming port hat not already disconnected yet?
if (e_state==EPOINT_STATE_IN_DISCONNECT && message_type!=MESSAGE_RELEASE)// || e_state==EPOINT_STATE_OUT_DISCONNECT || e_state==EPOINT_STATE_IDLE)
{
/* 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);
message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
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;
/* process hangup */
- process_hangup(e_call_cause, e_call_location);
+ process_hangup(e_join_cause, e_join_location);
e_multipoint_cause = 0;
e_multipoint_location = LOCATION_PRIVATE_LOCAL;
- /* tone to disconnected end */
- SPRINT(buffer, "cause_%02x", cause);
- if (ea_endpoint->ep_portlist)
- set_tone(ea_endpoint->ep_portlist, buffer);
+ if (message_type == MESSAGE_DISCONNECT)
+ {
+ /* tone to disconnected end */
+ SPRINT(buffer, "cause_%02x", cause);
+ if (ea_endpoint->ep_portlist)
+ set_tone(ea_endpoint->ep_portlist, buffer);
+
+ new_state(EPOINT_STATE_IN_DISCONNECT);
+ }
- new_state(EPOINT_STATE_IN_DISCONNECT);
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
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 (joinpbx_countrelations(ea_endpoint->ep_join_id)==2 // we must count relations, in order not to disturb the conference ; NOTE: asterisk always counts two, since it is a point to point call
&& message_type != MESSAGE_RELEASE) // if we release, we are done
haspatterns = 1;
if (haspatterns)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the port has patterns.\n", ea_endpoint->ep_serial);
/* indicate patterns */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_PATTERN);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_PATTERN);
message_put(message);
/* connect audio, if not already */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
/* send disconnect */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, message_type);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, message_type);
memcpy(&message->param, param, sizeof(union parameter));
message_put(message);
/* disable encryption if disconnected */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the port has no patterns.\n", ea_endpoint->ep_serial);
}
}
+ if (message_type == MESSAGE_RELEASE)
+ ea_endpoint->free_portlist(portlist);
release(RELEASE_ALL, location, cause, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, callcause, portcause */
return; /* must exit here */
}
{
char cause[16];
- printlog("%3d incoming TIMEOUT\n",
- ea_endpoint->ep_serial
- );
+ trace_header("TIMEOUT", DIRECTION_IN);
message_type = MESSAGE_DISCONNECT;
switch (param->state)
{
case PORT_STATE_OUT_SETUP:
case PORT_STATE_OUT_OVERLAP:
+ add_trace("state", NULL, "outgoing setup/dialing");
+ end_trace();
/* no user responding */
release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOUSER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL);
return; /* must exit here */
case PORT_STATE_IN_SETUP:
case PORT_STATE_IN_OVERLAP:
+ add_trace("state", NULL, "incoming setup/dialing");
param->disconnectinfo.cause = CAUSE_INVALID; /* number incomplete */
param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
break;
case PORT_STATE_OUT_PROCEEDING:
+ add_trace("state", NULL, "outgoing proceeding");
+ end_trace();
param->disconnectinfo.cause = CAUSE_NOUSER; /* no user responding */
param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOUSER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL);
return; /* must exit here */
case PORT_STATE_IN_PROCEEDING:
+ add_trace("state", NULL, "incoming proceeding");
param->disconnectinfo.cause = CAUSE_NOUSER;
param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL; /* no user responding */
break;
case PORT_STATE_OUT_ALERTING:
+ add_trace("state", NULL, "outgoing alerting");
+ end_trace();
param->disconnectinfo.cause = CAUSE_NOANSWER; /* no answer */
param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NOANSWER, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL);
return; /* must exit here */
+ case PORT_STATE_CONNECT:
+ add_trace("state", NULL, "connect");
+ end_trace();
+ param->disconnectinfo.cause = CAUSE_NORMAL; /* normal */
+ param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
+ release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL);
+ return; /* must exit here */
+
case PORT_STATE_IN_ALERTING:
+ add_trace("state", NULL, "incoming alerting");
param->disconnectinfo.cause = CAUSE_NOANSWER;
param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
break;
case PORT_STATE_IN_DISCONNECT:
case PORT_STATE_OUT_DISCONNECT:
+ add_trace("state", NULL, "disconnect");
+ end_trace();
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) in this special case, we release due to disconnect timeout.\n", ea_endpoint->ep_serial);
release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL);
return; /* must exit here */
param->disconnectinfo.cause = 31; /* normal unspecified */
param->disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
}
+ end_trace();
/* release call, disconnect isdn */
- e_call_pattern = 0;
+ e_join_pattern = 0;
new_state(EPOINT_STATE_OUT_DISCONNECT);
SPRINT(cause, "cause_%02x", param->disconnectinfo.cause);
SCPY(e_tone, cause);
message_disconnect_port(portlist, param->disconnectinfo.cause, param->disconnectinfo.location, "");
portlist = portlist->next;
}
- release(RELEASE_CALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, call, port */
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
}
/* port MESSAGE_NOTIFY */
void EndpointAppPBX::port_notify(struct port_list *portlist, int message_type, union parameter *param)
{
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
struct message *message;
char *logtext = "";
char buffer[64];
case INFO_NOTIFY_REMOTE_HOLD:
case INFO_NOTIFY_USER_SUSPENDED:
/* tell call about it */
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_HOLD;
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
+ message->param.audiopath = CHANNEL_STATE_HOLD;
message_put(message);
}
break;
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)
{
if (portlist)
set_tone(portlist, e_tone);
/* tell call about it */
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
}
break;
logtext = "CALL_IS_DIVERTING";
break;
default:
- SPRINT(buffer, "indicator=%d", param->notifyinfo.notify - 0x80);
+ SPRINT(buffer, "%d", param->notifyinfo.notify - 0x80);
logtext = buffer;
}
- printlog("%3d incoming NOTIFY notify='%s' id='%s'%s\n",
- ea_endpoint->ep_serial,
- logtext,
- param->notifyinfo.id,
- (param->notifyinfo.present==INFO_PRESENT_RESTRICTED)?" anonymous":""
- );
/* notify call if available */
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_NOTIFY);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_NOTIFY);
memcpy(&message->param.notifyinfo, ¶m->notifyinfo, sizeof(struct notify_info));
message_put(message);
}
/* port MESSAGE_FACILITY */
void EndpointAppPBX::port_facility(struct port_list *portlist, int message_type, union parameter *param)
{
- struct message *message;
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
- printlog("%3d incoming FACILITY len='%d'\n",
- ea_endpoint->ep_serial,
- param->facilityinfo.len
- );
+ struct message *message;
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_FACILITY);
+ 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));
message_put(message);
}
/* NOTE: before supending, the inactive-notification must be done in order to set call mixer */
void EndpointAppPBX::port_suspend(struct port_list *portlist, int message_type, union parameter *param)
{
- printlog("%3d incoming SUSPEND\n",
- ea_endpoint->ep_serial
- );
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
/* epoint is now parked */
ea_endpoint->ep_park = 1;
memcpy(ea_endpoint->ep_park_callid, param->parkinfo.callid, sizeof(ea_endpoint->ep_park_callid));
/* NOTE: before resume, the active-notification must be done in order to set call mixer */
void EndpointAppPBX::port_resume(struct port_list *portlist, int message_type, union parameter *param)
{
- printlog("%3d incoming RESUME\n",
- ea_endpoint->ep_serial
- );
+ logmessage(message_type, param, portlist->port_id, DIRECTION_IN);
+
/* epoint is now resumed */
ea_endpoint->ep_park = 0;
{
struct port_list *portlist;
struct message *message;
- class Port *port;
portlist = ea_endpoint->ep_portlist;
while(portlist)
return;
}
-// PDEBUG(DEBUG_EPOINT, "received message %d (terminal %s, caller id %s)\n", message, e_terminal, e_callerinfo.id);
+// PDEBUG(DEBUG_EPOINT, "received message %d (terminal %s, caller id %s)\n", message, e_ext.number, e_callerinfo.id);
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)
+ if (!ea_endpoint->ep_join_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_join_id, EPOINT_TO_JOIN, 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_terminal, 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;
/* PORT sends FACILITY message */
case MESSAGE_FACILITY:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming facility (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) incoming facility (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
port_facility(portlist, message_type, param);
break;
/* PORT sends DTMF message */
case MESSAGE_DTMF: /* dtmf digits received */
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dtmf digit=%c (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->dtmf, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dtmf digit=%c (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->dtmf, e_ext.number, e_callerinfo.id);
port_dtmf(portlist, message_type, param);
break;
/* PORT sends MORE message */
case MESSAGE_OVERLAP:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is accepted [overlap dialing] (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is accepted [overlap dialing] (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state != EPOINT_STATE_OUT_SETUP)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup state (for port_list: another portlist might have changed the state already).\n", ea_endpoint->ep_serial);
/* PORT sends PROCEEDING message */
case MESSAGE_PROCEEDING: /* port is proceeding */
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is proceeding (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is proceeding (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_OUT_SETUP
&& e_state!=EPOINT_STATE_OUT_OVERLAP)
{
/* PORT sends ALERTING message */
case MESSAGE_ALERTING:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is ringing (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call is ringing (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_OUT_SETUP
&& e_state!=EPOINT_STATE_OUT_OVERLAP
&& e_state!=EPOINT_STATE_OUT_PROCEEDING)
/* PORT sends CONNECT message */
case MESSAGE_CONNECT:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call connected to %s (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_connectinfo.id, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) outgoing call connected to %s (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, e_connectinfo.id, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_OUT_SETUP
&& e_state!=EPOINT_STATE_OUT_OVERLAP
&& e_state!=EPOINT_STATE_OUT_PROCEEDING
/* PORT sends DISCONNECT message */
case MESSAGE_DISCONNECT: /* port is disconnected */
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call disconnect with cause=%d location=%d (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->disconnectinfo.cause, param->disconnectinfo.location, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call disconnect with cause=%d location=%d (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->disconnectinfo.cause, param->disconnectinfo.location, e_ext.number, e_callerinfo.id);
port_disconnect_release(portlist, message_type, param);
break;
/* PORT sends a RELEASE message */
case MESSAGE_RELEASE: /* port releases */
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) release with cause=%d location=%d (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->disconnectinfo.cause, param->disconnectinfo.location, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) release with cause=%d location=%d (terminal '%s', caller id '%s')\n", ea_endpoint->ep_serial, param->disconnectinfo.cause, param->disconnectinfo.location, e_ext.number, e_callerinfo.id);
/* portlist is release at port_disconnect_release, thanx Paul */
port_disconnect_release(portlist, message_type, param);
break;
/* PORT sends a TIMEOUT message */
case MESSAGE_TIMEOUT:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received timeout (state=%d).\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id, param->state);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received timeout (state=%d).\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->state);
port_timeout(portlist, message_type, param);
break; /* release */
/* PORT 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_terminal, e_callerinfo.id);
+ 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);
port_notify(portlist, message_type, param);
break;
/* PORT sends a SUSPEND message */
case MESSAGE_SUSPEND:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received suspend.\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received suspend.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
port_suspend(portlist, message_type, param);
break; /* suspend */
/* PORT sends a RESUME message */
case MESSAGE_RESUME:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received resume.\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received resume.\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
port_resume(portlist, message_type, param);
break;
default:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received a wrong message: %d\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id, message);
+ 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);
}
/* Note: this endpoint may be destroyed, so we MUST return */
}
-/* messages from port
+/* messages from join
*/
-/* call MESSAGE_CRYPT */
-void EndpointAppPBX::call_crypt(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_CRYPT */
+void EndpointAppPBX::join_crypt(struct port_list *portlist, int message_type, union parameter *param)
{
switch(param->crypt.type)
{
break;
default:
- PERROR("EPOINT(%d) epoint with terminal '%s' (caller id '%s') unknown crypt message: '%d'\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id, param->crypt.type);
+ PERROR("EPOINT(%d) epoint with terminal '%s' (caller id '%s') unknown crypt message: '%d'\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, param->crypt.type);
}
}
-/* call MESSAGE_INFORMATION */
-void EndpointAppPBX::call_information(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_INFORMATION */
+void EndpointAppPBX::join_information(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *message;
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_INFORMATION);
memcpy(&message->param.information, ¶m->information, sizeof(struct dialing_info));
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
portlist = portlist->next;
}
}
-/* call MESSAGE_FACILITY */
-void EndpointAppPBX::call_facility(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_FACILITY */
+void EndpointAppPBX::join_facility(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *message;
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_FACILITY);
memcpy(&message->param.facilityinfo, ¶m->facilityinfo, sizeof(struct facility_info));
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
portlist = portlist->next;
}
}
-/* call MESSAGE_MORE */
-void EndpointAppPBX::call_overlap(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_MORE */
+void EndpointAppPBX::join_overlap(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *message;
new_state(EPOINT_STATE_IN_OVERLAP);
/* own dialtone */
- if (e_call_pattern && e_ext.own_setup)
+ if (e_join_pattern && e_ext.own_setup)
{
/* disconnect audio */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_HOLD;
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
+ message->param.audiopath = CHANNEL_STATE_HOLD;
message_put(message);
}
if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL)
set_tone(portlist, "dialtone");
return;
}
- if (e_terminal[0])
+ if (e_ext.number[0])
set_tone(portlist, "dialpbx");
else
set_tone(portlist, "dialtone");
}
-/* call MESSAGE_PROCEEDING */
-void EndpointAppPBX::call_proceeding(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_PROCEEDING */
+void EndpointAppPBX::join_proceeding(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *message;
new_state(EPOINT_STATE_IN_PROCEEDING);
/* own proceeding tone */
- if (e_call_pattern)
+ if (e_join_pattern)
{
/* connect / disconnect audio */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
if (e_ext.own_proceeding)
- message->param.channel = CHANNEL_STATE_HOLD;
+ message->param.audiopath = CHANNEL_STATE_HOLD;
else
- message->param.channel = CHANNEL_STATE_CONNECT;
+ message->param.audiopath = CHANNEL_STATE_CONNECT;
message_put(message);
}
-// UCPY(e_call_tone, "proceeding");
+// UCPY(e_join_tone, "proceeding");
if (portlist)
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
set_tone(portlist, "proceeding");
}
-/* call MESSAGE_ALERTING */
-void EndpointAppPBX::call_alerting(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_ALERTING */
+void EndpointAppPBX::join_alerting(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *message;
new_state(EPOINT_STATE_IN_ALERTING);
/* own alerting tone */
- if (e_call_pattern)
+ if (e_join_pattern)
{
/* connect / disconnect audio */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
if (e_ext.own_alerting)
- message->param.channel = CHANNEL_STATE_HOLD;
+ message->param.audiopath = CHANNEL_STATE_HOLD;
else
- message->param.channel = CHANNEL_STATE_CONNECT;
+ message->param.audiopath = CHANNEL_STATE_CONNECT;
message_put(message);
}
if (portlist)
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_ALERTING);
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
if (e_action) if (e_action->index == ACTION_OUTDIAL || e_action->index == ACTION_EXTERNAL)
{
set_tone(portlist, "ringing");
return;
}
- if (e_terminal[0])
+ if (e_ext.number[0])
set_tone(portlist, "ringpbx");
else
set_tone(portlist, "ringing");
}
-/* call MESSAGE_CONNECT */
-void EndpointAppPBX::call_connect(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_CONNECT */
+void EndpointAppPBX::join_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, "");
- if (e_terminal[0])
+// UCPY(e_join_tone, "");
+ if (e_ext.number[0])
e_dtmf = 1; /* allow dtmf */
e_powerdialing = 0;
memcpy(&e_connectinfo, ¶m->connectinfo, sizeof(e_callerinfo));
{
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_terminal[0] && message->param.connectinfo.id[0] && e_ext.clip_prefix[0])
+ if (e_ext.number[0] && message->param.connectinfo.id[0] && e_ext.clip_prefix[0])
{
SCPY(message->param.connectinfo.id, e_ext.clip_prefix);
SCAT(message->param.connectinfo.id, numberrize_callerinfo(e_connectinfo.id,e_connectinfo.ntype));
}
/* use internal caller id */
- if (e_terminal[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)
/* send connect */
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
set_tone(portlist, NULL);
- e_call_pattern = 0;
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ e_join_pattern = 0;
+ 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);
e_start = now;
}
-/* call MESSAGE_DISCONNECT MESSAGE_RELEASE */
-void EndpointAppPBX::call_disconnect_release(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_DISCONNECT MESSAGE_RELEASE */
+void EndpointAppPBX::join_disconnect_release(struct port_list *portlist, int message_type, union parameter *param)
{
char cause[16];
struct message *message;
/* we are powerdialing, if e_powerdialing is set and limit is not exceeded if given */
if (e_powerdialing && ((e_powercount+1)<e_powerlimit || e_powerlimit<1))
{
- release(RELEASE_CALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, call, port */
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
/* set time for power dialing */
e_powerdialing = now_d + e_powerdelay; /* set redial in the future */
/* set redial tone */
if (ea_endpoint->ep_portlist)
{
- e_call_pattern = 0;
+ e_join_pattern = 0;
}
set_tone(ea_endpoint->ep_portlist, "redial");
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') redialing in %d seconds\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id, (int)e_powerdelay);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') redialing in %d seconds\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, (int)e_powerdelay);
/* send proceeding when powerdialing and still setup (avoid dialing timeout) */
if (e_state==EPOINT_STATE_IN_OVERLAP)
{
{
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
/* caused the error, that the first knock sound was not there */
/* set_tone(portlist, "proceeding"); */
else
SPRINT(message->param.notifyinfo.display, "Retry %d", e_powercount);
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
portlist = portlist->next;
}
}
|| !ea_endpoint->ep_portlist) /* or no port */
{
process_hangup(param->disconnectinfo.cause, param->disconnectinfo.location);
- release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, param->disconnectinfo.cause); /* RELEASE_TYPE, call, port */
+ release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, param->disconnectinfo.cause); /* RELEASE_TYPE, join, port */
return; /* must exit here */
}
/* save cause */
- if (!e_call_cause)
+ if (!e_join_cause)
{
- e_call_cause = param->disconnectinfo.cause;
- e_call_location = param->disconnectinfo.location;
+ e_join_cause = param->disconnectinfo.cause;
+ e_join_location = param->disconnectinfo.location;
}
/* on release we need the audio again! */
if (message_type == MESSAGE_RELEASE)
{
- e_call_pattern = 0;
- ea_endpoint->ep_call_id = 0;
+ e_join_pattern = 0;
+ ea_endpoint->ep_join_id = 0;
}
/* disconnect and select tone */
new_state(EPOINT_STATE_OUT_DISCONNECT);
SPRINT(cause, "cause_%02x", param->disconnectinfo.cause);
- /* if own_cause, we must release the call */
+ /* if own_cause, we must release the join */
if (e_ext.own_cause /* own cause */
- || !e_call_pattern) /* no patterns */
+ || !e_join_pattern) /* no patterns */
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have own cause or we have no patterns. (own_cause=%d pattern=%d)\n", ea_endpoint->ep_serial, e_ext.own_cause, e_call_pattern);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have own cause or we have no patterns. (own_cause=%d pattern=%d)\n", ea_endpoint->ep_serial, e_ext.own_cause, e_join_pattern);
if (message_type != MESSAGE_RELEASE)
- release(RELEASE_CALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, call, port */
- e_call_pattern = 0;
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL); /* RELEASE_TYPE, join, port */
+ e_join_pattern = 0;
} else /* else we enable audio */
{
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
}
/* send disconnect message */
}
}
-/* call MESSAGE_SETUP */
-void EndpointAppPBX::call_setup(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_SETUP */
+void EndpointAppPBX::join_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 */
message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
ea_endpoint->free_portlist(portlist);
}
/* disconnect audio */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_HOLD;
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
+ message->param.audiopath = CHANNEL_STATE_HOLD;
message_put(message);
/* get dialing info */
/* 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);
+ logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
}
/* always store what we have dialed or queued */
memcpy(&e_dialinginfo, ¶m->setup.dialinginfo, sizeof(e_dialinginfo));
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_terminal, 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_terminal[0])
+ if (e_ext.number[0])
{
- if (!read_extension(&e_ext, e_terminal))
+ if (!read_extension(&e_ext, e_ext.number))
{
- e_terminal[0] = '\0';
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the called terminal='%s' is not found in directory tree!\n", ea_endpoint->ep_serial, e_terminal);
+ e_ext.number[0] = '\0';
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) the called terminal='%s' is not found in directory tree!\n", ea_endpoint->ep_serial, e_ext.number);
}
}
memcpy(&e_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)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) handling data call as audio call: '%s'\n", ea_endpoint->ep_serial, e_terminal);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) handling data call as audio call: '%s'\n", ea_endpoint->ep_serial, e_ext.number);
memset(&e_capainfo, 0, sizeof(e_capainfo));
e_capainfo.bearer_capa = INFO_BC_AUDIO;
e_capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
out_setup();
}
-/* call MESSAGE_mISDNSIGNAL */
-void EndpointAppPBX::call_mISDNsignal(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_mISDNSIGNAL */
+void EndpointAppPBX::join_mISDNsignal(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *message;
}
}
-/* call MESSAGE_NOTIFY */
-void EndpointAppPBX::call_notify(struct port_list *portlist, int message_type, union parameter *param)
+/* join MESSAGE_NOTIFY */
+void EndpointAppPBX::join_notify(struct port_list *portlist, int message_type, union parameter *param)
{
struct message *message;
int new_state;
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);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
portlist = portlist->next;
}
}
/* call sends messages to the endpoint
*/
-void EndpointAppPBX::ea_message_call(unsigned long call_id, int message_type, union parameter *param)
+void EndpointAppPBX::ea_message_join(unsigned long join_id, int message_type, union parameter *param)
{
struct port_list *portlist;
struct message *message;
- if (!call_id)
+ if (!join_id)
{
PERROR("EPOINT(%d) error: call == NULL.\n", ea_endpoint->ep_serial);
return;
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 (join_id == ea_endpoint->ep_join_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;
}
}
-// 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_terminal, e_callerinfo.id, e_state);
+// 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);
switch(message_type)
{
/* CALL 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_terminal, e_callerinfo.id, param->crypt.type);
- call_crypt(portlist, message_type, param);
+ 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 */
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_terminal, e_callerinfo.id, param->information.number);
- call_information(portlist, message_type, param);
+ 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 */
case MESSAGE_FACILITY:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received facility\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id);
- call_facility(portlist, message_type, param);
+ 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 */
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_terminal, e_callerinfo.id);
+ 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
&& e_state!=EPOINT_STATE_IN_OVERLAP)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup state.\n", ea_endpoint->ep_serial);
break;
}
- call_overlap(portlist, message_type, param);
+ join_overlap(portlist, message_type, param);
break;
/* CALL 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_terminal, e_callerinfo.id);
+ 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)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup state.\n", ea_endpoint->ep_serial);
break;
}
- call_proceeding(portlist, message_type, param);
+ join_proceeding(portlist, message_type, param);
break;
/* CALL 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_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received alerting\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_IN_OVERLAP
&& e_state!=EPOINT_STATE_IN_PROCEEDING)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup or proceeding state.\n", ea_endpoint->ep_serial);
break;
}
- call_alerting(portlist, message_type, param);
+ join_alerting(portlist, message_type, param);
break;
/* CALL 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_terminal, e_callerinfo.id);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received connect\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id);
if (e_state!=EPOINT_STATE_IN_OVERLAP
&& e_state!=EPOINT_STATE_IN_PROCEEDING
&& e_state!=EPOINT_STATE_IN_ALERTING)
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ignored because we are not in setup, proceeding or alerting state.\n", ea_endpoint->ep_serial);
break;
}
- call_connect(portlist, message_type, param);
+ join_connect(portlist, message_type, param);
break;
/* CALL sends DISCONNECT/RELEASE message */
case MESSAGE_DISCONNECT: /* call disconnect */
case MESSAGE_RELEASE: /* call 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_terminal, e_callerinfo.id, (message_type==MESSAGE_DISCONNECT)?"disconnect":"release", param->disconnectinfo.cause, param->disconnectinfo.location);
- call_disconnect_release(portlist, message_type, param);
+ 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);
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);
- call_setup(portlist, message_type, param);
+ 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 */
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_terminal, e_callerinfo.id);
- call_mISDNsignal(portlist, message_type, param);
+ 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 */
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_terminal, e_callerinfo.id);
- if (!e_call_pattern)
+ 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)
{
PDEBUG(DEBUG_EPOINT, "-> pattern becomes available\n");
- e_call_pattern = 1;
+ e_join_pattern = 1;
SCPY(e_tone, "");
while(portlist)
{
portlist = portlist->next;
}
/* connect our audio tx and rx (blueboxing should be possibe before connect :)*/
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
// /* tell remote epoint to connect audio also, because we like to hear the patterns */
-// message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_REMOTE_AUDIO);
-// message->param.channel = CHANNEL_STATE_CONNECT;
+// message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_REMOTE_AUDIO);
+// message->param.audiopath = CHANNEL_STATE_CONNECT;
// message_put(message);
// patterns are available, remote already connected audio
}
/* CALL 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_terminal, e_callerinfo.id);
- if (e_call_pattern)
+ 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)
{
PDEBUG(DEBUG_EPOINT, "-> pattern becomes unavailable\n");
- e_call_pattern = 0;
+ e_join_pattern = 0;
/* disconnect our audio tx and rx */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_HOLD;
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_AUDIOPATH);
+ message->param.audiopath = CHANNEL_STATE_HOLD;
message_put(message);
}
break;
#if 0
/* CALL (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_terminal, e_callerinfo.id);
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = param->channel;
+ 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);
+ message->param.audiopath = param->channel;
message_put(message);
break;
#endif
/* CALL 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_terminal, e_callerinfo.id);
- call_notify(portlist, message_type, param);
+ 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);
break;
default:
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) epoint with terminal '%s' (caller id '%s') received a wrong message: #%d\n", ea_endpoint->ep_serial, e_terminal, e_callerinfo.id, message);
+ 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);
}
}
-/* pick_call will connect the first incoming call found. the endpoint
+/* pick_join will connect the first incoming call found. the endpoint
* will receivce a MESSAGE_CONNECT.
*/
int match_list(char *list, char *item)
}
}
-void EndpointAppPBX::pick_call(char *extensions)
+void EndpointAppPBX::pick_join(char *extensions)
{
struct message *message;
struct port_list *portlist;
class Port *port;
class EndpointAppPBX *eapp, *found;
- class Call *call;
- class CallPBX *callpbx;
- struct call_relation *relation;
+ class Join *join;
+ class JoinPBX *joinpbx;
+ struct join_relation *relation;
int vbox;
/* find an endpoint that is ringing internally or vbox with higher priority */
{
if (port->p_type == PORT_TYPE_VBOX_OUT)
{
- if (match_list(extensions, eapp->e_terminal))
+ if (match_list(extensions, eapp->e_ext.number))
{
found = eapp;
vbox = 1;
}
if ((port->p_type==PORT_TYPE_DSS1_NT_OUT || port->p_type==PORT_TYPE_DSS1_TE_OUT)
&& port->p_state==PORT_STATE_OUT_ALERTING)
- if (match_list(extensions, eapp->e_terminal))
+ if (match_list(extensions, eapp->e_ext.number))
{
found = eapp;
}
}
eapp = found;
- if (ea_endpoint->ep_call_id)
+ if (ea_endpoint->ep_join_id)
{
- PERROR("EPOINT(%d) we already have a call. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
+ PERROR("EPOINT(%d) we already have a join. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
goto reject;
}
- if (!eapp->ea_endpoint->ep_call_id)
+ if (!eapp->ea_endpoint->ep_join_id)
{
- PERROR("EPOINT(%d) ringing endpoint has no call.\n", ea_endpoint->ep_serial);
+ PERROR("EPOINT(%d) ringing endpoint has no join.\n", ea_endpoint->ep_serial);
goto reject;
}
- call = find_call_id(eapp->ea_endpoint->ep_call_id);
- if (!call)
+ join = find_join_id(eapp->ea_endpoint->ep_join_id);
+ if (!join)
{
- PERROR("EPOINT(%d) ringing endpoint's call not found.\n", ea_endpoint->ep_serial);
+ PERROR("EPOINT(%d) ringing endpoint's join not found.\n", ea_endpoint->ep_serial);
goto reject;
}
- if (callpbx->c_type != CALL_TYPE_PBX)
+ if (joinpbx->j_type != JOIN_TYPE_PBX)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ringing endpoint's call is not a PBX call, so we must reject.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) ringing endpoint's join is not a PBX join, so we must reject.\n", ea_endpoint->ep_serial);
goto reject;
}
- callpbx = (class CallPBX *)call;
- relation = callpbx->c_relation;
+ joinpbx = (class JoinPBX *)join;
+ relation = joinpbx->j_relation;
if (!relation)
{
- PERROR("EPOINT(%d) ringing endpoint's call has no relation. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
+ PERROR("EPOINT(%d) ringing endpoint's join has no relation. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
goto reject;
}
while (relation->epoint_id != eapp->ea_endpoint->ep_serial)
relation = relation->next;
if (!relation)
{
- PERROR("EPOINT(%d) ringing endpoint's call has no relation to that call. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
+ PERROR("EPOINT(%d) ringing endpoint's join has no relation to that join. SOFTWARE ERROR.\n", ea_endpoint->ep_serial);
goto reject;
}
}
if (options.deb & DEBUG_EPOINT)
{
- class Call *debug_c = call_first;
+ class Join *debug_c = join_first;
class Endpoint *debug_e = epoint_first;
class Port *debug_p = port_first;
- callpbx_debug(callpbx, "EndpointAppPBX::pick_call(before)");
+ joinpbx_debug(joinpbx, "EndpointAppPBX::pick_join(before)");
- PDEBUG(DEBUG_EPOINT, "showing all calls:\n");
+ PDEBUG(DEBUG_EPOINT, "showing all joins:\n");
while(debug_c)
{
- PDEBUG(DEBUG_EPOINT, "call=%ld\n", debug_c->c_serial);
+ PDEBUG(DEBUG_EPOINT, "join=%ld\n", debug_c->j_serial);
debug_c = debug_c->next;
}
PDEBUG(DEBUG_EPOINT, "showing all endpoints:\n");
while(debug_e)
{
- PDEBUG(DEBUG_EPOINT, "ep=%ld, call=%ld\n", debug_e->ep_serial, debug_e->ep_call_id);
+ PDEBUG(DEBUG_EPOINT, "ep=%ld, join=%ld\n", debug_e->ep_serial, debug_e->ep_join_id);
debug_e = debug_e->next;
}
PDEBUG(DEBUG_EPOINT, "showing all ports:\n");
}
}
- /* relink call */
- ea_endpoint->ep_call_id = eapp->ea_endpoint->ep_call_id; /* we get the call */
- relation->epoint_id = ea_endpoint->ep_serial; /* the call gets us */
- eapp->ea_endpoint->ep_call_id = 0; /* the ringing endpoint will get disconnected */
+ /* relink join */
+ ea_endpoint->ep_join_id = eapp->ea_endpoint->ep_join_id; /* we get the join */
+ relation->epoint_id = ea_endpoint->ep_serial; /* the join gets us */
+ eapp->ea_endpoint->ep_join_id = 0; /* the ringing endpoint will get disconnected */
/* connnecting our endpoint */
new_state(EPOINT_STATE_CONNECT);
set_tone(ea_endpoint->ep_portlist, NULL);
/* 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 = message_create(ea_endpoint->ep_join_id, eapp->ea_endpoint->ep_serial, JOIN_TO_EPOINT, MESSAGE_RELEASE);
+ message->param.disconnectinfo.cause = CAUSE_NONSELECTED; /* non selected user clearing */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message_put(message);
- /* we send a connect to the call with our caller id */
- message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CONNECT);
+ /* we send a connect to the join with our caller id */
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_CONNECT);
SCPY(message->param.connectinfo.id, e_callerinfo.id);
message->param.connectinfo.present = e_callerinfo.present;
message->param.connectinfo.screen = e_callerinfo.screen;
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 = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
- message->param.channel = CHANNEL_STATE_CONNECT;
+ 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);
/* beeing paranoid, we make call update */
- callpbx->c_mixer = 1;
+ joinpbx->j_updatebridge = 1;
if (options.deb & DEBUG_EPOINT)
{
- class Call *debug_c = call_first;
+ class Join *debug_c = join_first;
class Endpoint *debug_e = epoint_first;
class Port *debug_p = port_first;
- callpbx_debug(callpbx, "EndpointAppPBX::pick_call(after)");
+ joinpbx_debug(joinpbx, "EndpointAppPBX::pick_join(after)");
- PDEBUG(DEBUG_EPOINT, "showing all calls:\n");
+ PDEBUG(DEBUG_EPOINT, "showing all joins:\n");
while(debug_c)
{
- PDEBUG(DEBUG_EPOINT, "call=%ld\n", debug_c->c_serial);
+ PDEBUG(DEBUG_EPOINT, "join=%ld\n", debug_c->j_serial);
debug_c = debug_c->next;
}
PDEBUG(DEBUG_EPOINT, "showing all endpoints:\n");
while(debug_e)
{
- PDEBUG(DEBUG_EPOINT, "ep=%ld, call=%ld\n", debug_e->ep_serial, debug_e->ep_call_id);
+ PDEBUG(DEBUG_EPOINT, "ep=%ld, join=%ld\n", debug_e->ep_serial, debug_e->ep_join_id);
debug_e = debug_e->next;
}
PDEBUG(DEBUG_EPOINT, "showing all ports:\n");
}
-/* join calls (look for a call that is on hold (same isdn interface/terminal))
+/* join calls (look for a join that is on hold (same isdn interface/terminal))
*/
-void EndpointAppPBX::join_call(void)
+void EndpointAppPBX::join_join(void)
{
struct message *message;
- struct call_relation *our_relation, *other_relation;
- struct call_relation **our_relation_pointer, **other_relation_pointer;
- class Call *our_call, *other_call;
- class CallPBX *our_callpbx, *other_callpbx;
+ struct join_relation *our_relation, *other_relation;
+ struct join_relation **our_relation_pointer, **other_relation_pointer;
+ class Join *our_join, *other_join;
+ class JoinPBX *our_joinpbx, *other_joinpbx;
class EndpointAppPBX *other_eapp; class Endpoint *temp_epoint;
class Port *our_port, *other_port;
class Pdss1 *our_pdss1, *other_pdss1;
- /* are we a candidate to join a call */
- our_call = find_call_id(ea_endpoint->ep_call_id);
- if (!our_call)
+ /* are we a candidate to join a join */
+ our_join = find_join_id(ea_endpoint->ep_join_id);
+ if (!our_join)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: our call doesn't exist anymore.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: our join doesn't exist anymore.\n", ea_endpoint->ep_serial);
return;
}
- if (our_call->c_type != CALL_TYPE_PBX)
+ if (our_join->j_type != JOIN_TYPE_PBX)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: call is not a pbx call.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: join is not a pbx join.\n", ea_endpoint->ep_serial);
return;
}
- our_callpbx = (class CallPBX *)our_call;
+ our_joinpbx = (class JoinPBX *)our_join;
if (!ea_endpoint->ep_portlist)
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: we have no port.\n", ea_endpoint->ep_serial);
return;
}
- if (!e_terminal[0])
+ if (!e_ext.number[0])
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: we are not internal extension.\n", ea_endpoint->ep_serial);
return;
other_eapp = other_eapp->next;
continue;
}
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) comparing other endpoint candiate: (ep%d) terminal='%s' port=%s call=%d.\n", ea_endpoint->ep_serial, other_eapp->ea_endpoint->ep_serial, other_eapp->e_terminal, (other_eapp->ea_endpoint->ep_portlist)?"YES":"NO", other_eapp->ea_endpoint->ep_call_id);
- if (other_eapp->e_terminal[0] /* has terminal */
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) comparing other endpoint candiate: (ep%d) terminal='%s' port=%s join=%d.\n", ea_endpoint->ep_serial, other_eapp->ea_endpoint->ep_serial, other_eapp->e_ext.number, (other_eapp->ea_endpoint->ep_portlist)?"YES":"NO", other_eapp->ea_endpoint->ep_join_id);
+ if (other_eapp->e_ext.number[0] /* has terminal */
&& other_eapp->ea_endpoint->ep_portlist /* has port */
- && other_eapp->ea_endpoint->ep_call_id) /* has call */
+ && other_eapp->ea_endpoint->ep_join_id) /* has join */
{
other_port = find_port_id(other_eapp->ea_endpoint->ep_portlist->port_id);
if (other_port) /* port still exists */
}
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) port on hold found.\n", ea_endpoint->ep_serial);
- /* if we have the same call */
- if (other_eapp->ea_endpoint->ep_call_id == ea_endpoint->ep_call_id)
+ /* if we have the same join */
+ if (other_eapp->ea_endpoint->ep_join_id == ea_endpoint->ep_join_id)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: we an the other have the same call.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: we an the other have the same join.\n", ea_endpoint->ep_serial);
return;
}
- other_call = find_call_id(other_eapp->ea_endpoint->ep_call_id);
- if (!other_call)
+ other_join = find_join_id(other_eapp->ea_endpoint->ep_join_id);
+ if (!other_join)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: other call doesn't exist anymore.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: other join doesn't exist anymore.\n", ea_endpoint->ep_serial);
return;
}
- if (other_call->c_type != CALL_TYPE_PBX)
+ if (other_join->j_type != JOIN_TYPE_PBX)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: other call is not a pbx call.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: other join is not a pbx join.\n", ea_endpoint->ep_serial);
return;
}
- other_callpbx = (class CallPBX *)other_call;
- if (our_callpbx->c_partyline && other_callpbx->c_partyline)
+ other_joinpbx = (class JoinPBX *)other_join;
+ if (our_joinpbx->j_partyline && other_joinpbx->j_partyline)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: both calls are partylines.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) cannot join: both joins are partylines.\n", ea_endpoint->ep_serial);
return;
}
- /* remove relation to endpoint for call on hold */
- other_relation = other_callpbx->c_relation;
- other_relation_pointer = &other_callpbx->c_relation;
+ /* remove relation to endpoint for join on hold */
+ other_relation = other_joinpbx->j_relation;
+ other_relation_pointer = &other_joinpbx->j_relation;
while(other_relation)
{
if (other_relation->epoint_id == other_eapp->ea_endpoint->ep_serial)
{
/* 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 join_relation));
cmemuse--;
other_relation = *other_relation_pointer;
- other_eapp->ea_endpoint->ep_call_id = NULL;
+ other_eapp->ea_endpoint->ep_join_id = NULL;
continue;
}
- /* change call/hold pointer of endpoint to the new call */
+ /* change join/hold pointer of endpoint to the new join */
temp_epoint = find_epoint_id(other_relation->epoint_id);
if (temp_epoint)
{
- if (temp_epoint->ep_call_id == other_call->c_serial)
- temp_epoint->ep_call_id = our_call->c_serial;
+ if (temp_epoint->ep_join_id == other_join->j_serial)
+ temp_epoint->ep_join_id = our_join->j_serial;
}
other_relation_pointer = &other_relation->next;
other_relation = other_relation->next;
}
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) endpoint on hold removed, other enpoints on call relinked (to our call).\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) endpoint on hold removed, other enpoints on join relinked (to our join).\n", ea_endpoint->ep_serial);
/* join call relations */
- our_relation = our_callpbx->c_relation;
- our_relation_pointer = &our_callpbx->c_relation;
+ our_relation = our_joinpbx->j_relation;
+ our_relation_pointer = &our_joinpbx->j_relation;
while(our_relation)
{
our_relation_pointer = &our_relation->next;
our_relation = our_relation->next;
}
- *our_relation_pointer = other_callpbx->c_relation;
- other_callpbx->c_relation = NULL;
+ *our_relation_pointer = other_joinpbx->j_relation;
+ other_joinpbx->j_relation = NULL;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) relations joined.\n", ea_endpoint->ep_serial);
/* release endpoint on hold */
- message = message_create(other_callpbx->c_serial, other_eapp->ea_endpoint->ep_serial, CALL_TO_EPOINT, MESSAGE_RELEASE);
+ message = message_create(other_joinpbx->j_serial, other_eapp->ea_endpoint->ep_serial, JOIN_TO_EPOINT, MESSAGE_RELEASE);
message->param.disconnectinfo.cause = CAUSE_NORMAL; /* normal */
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message_put(message);
- /* if we are not a partyline, we get partyline state from other call */
- our_callpbx->c_partyline += other_callpbx->c_partyline;
+ /* if we are not a partyline, we get partyline state from other join */
+ our_joinpbx->j_partyline += other_joinpbx->j_partyline;
- /* remove empty call */
- delete other_call;
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d)d-call completely removed!\n");
+ /* remove empty join */
+ delete other_join;
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d)d-join completely removed!\n");
/* mixer must update */
- our_callpbx->c_mixer = 1; /* update mixer flag */
+ our_joinpbx->j_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
+ // mixer will update the hold-state of the join and send it to the endpoints is changes
}
*/
int EndpointAppPBX::check_external(char **errstr, class Port **port)
{
- struct call_relation *relation;
- class Call *call;
- class CallPBX *callpbx;
+ struct join_relation *relation;
+ class Join *join;
+ class JoinPBX *joinpbx;
class Endpoint *epoint;
/* some paranoia check */
*errstr = "No Call";
return(1);
}
- if (!e_terminal[0])
+ if (!e_ext.number[0])
{
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) error: we are not internal extension.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
- /* check if we have a call with 2 parties */
- call = find_call_id(ea_endpoint->ep_call_id);
- if (!call)
+ /* check if we have a join with 2 parties */
+ join = find_join_id(ea_endpoint->ep_join_id);
+ if (!join)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have currently no call.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) we have currently no join.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
- if (call->c_type != CALL_TYPE_PBX)
+ if (join->j_type != JOIN_TYPE_PBX)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call is nto a pbx call.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join is not a pbx join.\n", ea_endpoint->ep_serial);
*errstr = "No PBX Call";
return(1);
}
- callpbx = (class CallPBX *)call;
- relation = callpbx->c_relation;
+ joinpbx = (class JoinPBX *)join;
+ relation = joinpbx->j_relation;
if (!relation)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call has no relation.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join has no relation.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
if (!relation->next)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call has no 2nd relation.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join has no 2nd relation.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
if (relation->next->next)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call has more than two relations.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join has more than two relations.\n", ea_endpoint->ep_serial);
*errstr = "Err: Conference";
return(1);
}
relation = relation->next;
if (relation->epoint_id == ea_endpoint->ep_serial)
{
- PERROR("EPOINT(%d) SOFTWARE ERROR: both call relations are related to our endpoint.\n", ea_endpoint->ep_serial);
+ PERROR("EPOINT(%d) SOFTWARE ERROR: both join relations are related to our endpoint.\n", ea_endpoint->ep_serial);
*errstr = "Software Error";
return(1);
}
epoint = find_epoint_id(relation->epoint_id);
if (!epoint)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d) call has no 2nd endpoint.\n", ea_endpoint->ep_serial);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d) join has no 2nd endpoint.\n", ea_endpoint->ep_serial);
*errstr = "No Call";
return(1);
}
return(0);
}
-void EndpointAppPBX::logmessage(struct message *message)
+void EndpointAppPBX::logmessage(int message_type, union parameter *param, unsigned long port_id, int dir)
{
- class Port *port;
- class Pdss1 *pdss1;
char *logtext = "unknown";
char buffer[64];
- if (message->flow != EPOINT_TO_PORT)
- {
- PERROR("EPOINT(%d) message not of correct flow type-\n", ea_endpoint->ep_serial);
- return;
- }
-
- switch(message->type)
+ switch(message_type)
{
case MESSAGE_SETUP:
- port = find_port_id(message->id_to);
- if (!port)
- return;
- if (port->p_type == PORT_TYPE_DSS1_NT_OUT)
+ trace_header("SETUP", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ 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));
+ switch(param->setup.callerinfo.present)
{
- pdss1 = (class Pdss1 *)port;
- printlog("%3d outgoing SETUP from %s='%s'%s%s%s%s to intern='%s' port='%d' (NT)\n",
- ea_endpoint->ep_serial,
- (message->param.setup.callerinfo.intern[0])?"intern":"extern",
- (message->param.setup.callerinfo.intern[0])?e_callerinfo.intern:e_callerinfo.id,
- (message->param.setup.callerinfo.present==INFO_PRESENT_RESTRICTED)?" anonymous":"",
- (message->param.setup.redirinfo.id[0])?"redirected='":"",
- message->param.setup.redirinfo.id,
- (message->param.setup.redirinfo.id[0])?"'":"",
- message->param.setup.dialinginfo.number,
- pdss1->p_m_mISDNport->portnum
- );
- }
- if (port->p_type == PORT_TYPE_DSS1_TE_OUT)
- {
- pdss1 = (class Pdss1 *)port;
- printlog("%3d outgoing SETUP from %s='%s'%s%s%s%s to extern='%s' port='%d' (TE)\n",
- ea_endpoint->ep_serial,
- (message->param.setup.callerinfo.intern[0])?"intern":"extern",
- (message->param.setup.callerinfo.intern[0])?e_callerinfo.intern:e_callerinfo.id,
- (message->param.setup.callerinfo.present==INFO_PRESENT_RESTRICTED)?" anonymous":"",
- (message->param.setup.redirinfo.id[0])?"redirected='":"",
- message->param.setup.redirinfo.id,
- (message->param.setup.redirinfo.id[0])?"'":"",
- message->param.setup.dialinginfo.number,
- pdss1->p_m_mISDNport->portnum
- );
+ case INFO_PRESENT_RESTRICTED:
+ add_trace("caller id", "present", "restricted");
+ break;
+ case INFO_PRESENT_ALLOWED:
+ add_trace("caller id", "present", "allowed");
+ break;
+ default:
+ add_trace("caller id", "present", "not available");
}
- if (port->p_type == PORT_TYPE_VBOX_OUT)
+ if (param->setup.redirinfo.id[0])
{
- printlog("%3d outgoing SETUP from %s='%s'%s%s%s%s to vbox='%s'\n",
- ea_endpoint->ep_serial,
- (message->param.setup.callerinfo.intern[0])?"intern":"extern",
- (message->param.setup.callerinfo.intern[0])?e_callerinfo.intern:e_callerinfo.id,
- (message->param.setup.callerinfo.present==INFO_PRESENT_RESTRICTED)?" anonymous":"",
- (message->param.setup.redirinfo.id[0])?"redirected='":"",
- message->param.setup.redirinfo.id,
- (message->param.setup.redirinfo.id[0])?"'":"",
- message->param.setup.dialinginfo.number
- );
+ add_trace("redir'ing", "number", "%s", numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype));
+ switch(param->setup.redirinfo.present)
+ {
+ case INFO_PRESENT_RESTRICTED:
+ add_trace("redir'ing", "present", "restricted");
+ break;
+ case INFO_PRESENT_ALLOWED:
+ add_trace("redir'ing", "present", "allowed");
+ break;
+ default:
+ add_trace("redir'ing", "present", "not available");
+ }
}
+ if (param->setup.dialinginfo.id[0])
+ add_trace("dialing", NULL, "%s", param->setup.dialinginfo.id);
+ end_trace();
break;
case MESSAGE_OVERLAP:
- printlog("%3d outgoing SETUP ACKNOWLEDGE\n",
- ea_endpoint->ep_serial
- );
+ trace_header("SETUP ACKNOWLEDGE", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ end_trace();
break;
case MESSAGE_PROCEEDING:
- printlog("%3d outgoing PROCEEDING\n",
- ea_endpoint->ep_serial
- );
+ trace_header("PROCEEDING", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ end_trace();
break;
case MESSAGE_ALERTING:
- printlog("%3d outgoing ALERTING\n",
- ea_endpoint->ep_serial
- );
+ trace_header("ALERTING", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ end_trace();
break;
case MESSAGE_CONNECT:
- printlog("%3d outgoing CONNECT id='%s'%s\n",
- ea_endpoint->ep_serial,
- message->param.connectinfo.id,
- (message->param.connectinfo.present==INFO_PRESENT_RESTRICTED)?" anonymous":""
- );
+ trace_header("CONNECT", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ 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));
+ switch(param->connectinfo.present)
+ {
+ case INFO_PRESENT_RESTRICTED:
+ add_trace("connect id", "present", "restricted");
+ break;
+ case INFO_PRESENT_ALLOWED:
+ add_trace("connect id", "present", "allowed");
+ break;
+ default:
+ add_trace("connect id", "present", "not available");
+ }
+ end_trace();
break;
case MESSAGE_DISCONNECT:
- printlog("%3d outgoing DISCONNECT cause='%d' (%s) location='%d' (%s) display='%s'\n",
- ea_endpoint->ep_serial,
- message->param.disconnectinfo.cause,
- (message->param.disconnectinfo.cause>0 && message->param.disconnectinfo.cause<128)?isdn_cause[message->param.disconnectinfo.cause].english:"-",
- message->param.disconnectinfo.location,
- (message->param.disconnectinfo.location>=0 && message->param.disconnectinfo.location<16)?isdn_location[message->param.disconnectinfo.location].english:"-",
- message->param.disconnectinfo.display
- );
- break;
-
case MESSAGE_RELEASE:
- printlog("%3d outgoing RELEASE cause='%d' (%s) location='%d' (%s)\n",
- ea_endpoint->ep_serial,
- message->param.disconnectinfo.cause,
- (message->param.disconnectinfo.cause>0 && message->param.disconnectinfo.cause<128)?isdn_cause[message->param.disconnectinfo.cause].english:"-",
- message->param.disconnectinfo.location,
- (message->param.disconnectinfo.location>=0 && message->param.disconnectinfo.location<16)?isdn_location[message->param.disconnectinfo.location].english:"-"
- );
+ if (message_type == MESSAGE_DISCONNECT)
+ trace_header("DISCONNECT", dir);
+ else
+ trace_header("RELEASE", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ add_trace("cause", "value", "%d", param->disconnectinfo.cause);
+ switch(param->disconnectinfo.location)
+ {
+ case LOCATION_USER:
+ add_trace("cause", "location", "0-User");
+ break;
+ case LOCATION_PRIVATE_LOCAL:
+ add_trace("cause", "location", "1-Local-PBX");
+ break;
+ case LOCATION_PUBLIC_LOCAL:
+ add_trace("cause", "location", "2-Local-Exchange");
+ break;
+ case LOCATION_TRANSIT:
+ add_trace("cause", "location", "3-Transit");
+ break;
+ case LOCATION_PUBLIC_REMOTE:
+ add_trace("cause", "location", "4-Remote-PBX");
+ break;
+ case LOCATION_PRIVATE_REMOTE:
+ add_trace("cause", "location", "5-Remote-Exchange");
+ break;
+ case LOCATION_INTERNATIONAL:
+ add_trace("cause", "location", "7-International-Exchange");
+ break;
+ case LOCATION_BEYOND:
+ add_trace("cause", "location", "10-Beyond-Interworking");
+ break;
+ default:
+ add_trace("cause", "location", "%d", param->disconnectinfo.location);
+ }
+ end_trace();
break;
case MESSAGE_NOTIFY:
- switch(message->param.notifyinfo.notify)
+ switch(param->notifyinfo.notify)
{
case 0x00:
logtext = "NULL";
logtext = "CALL_IS_DIVERTING";
break;
default:
- SPRINT(buffer, "indicator=%d", message->param.notifyinfo.notify - 0x80);
+ SPRINT(buffer, "%d", param->notifyinfo.notify - 0x80);
logtext = buffer;
}
- printlog("%3d outgoing NOTIFY notify='%s' id='%s'%s display='%s'\n",
- ea_endpoint->ep_serial,
- logtext,
- message->param.notifyinfo.id,
- (message->param.notifyinfo.present==INFO_PRESENT_RESTRICTED)?" anonymous":"",
- message->param.notifyinfo.display
- );
+ trace_header("NOTIFY", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ if (param->notifyinfo.notify)
+ 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));
+ switch(param->notifyinfo.present)
+ {
+ case INFO_PRESENT_RESTRICTED:
+ add_trace("redir'on", "present", "restricted");
+ break;
+ case INFO_PRESENT_ALLOWED:
+ add_trace("redir'on", "present", "allowed");
+ break;
+ default:
+ add_trace("redir'on", "present", "not available");
+ }
+ }
+ if (param->notifyinfo.display[0])
+ add_trace("display", NULL, "%s", param->notifyinfo.display);
+ end_trace();
break;
case MESSAGE_INFORMATION:
- printlog("%3d outgoing INFORMATION information='%s'\n",
- ea_endpoint->ep_serial,
- message->param.information.number
- );
+ trace_header("INFORMATION", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ add_trace("dialing", NULL, "%s", param->information.id);
+ end_trace();
break;
case MESSAGE_FACILITY:
- printlog("%3d outgoing FACILITY len='%d'\n",
- ea_endpoint->ep_serial,
- message->param.facilityinfo.len
- );
+ trace_header("FACILITY", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ end_trace();
break;
case MESSAGE_TONE:
- printlog("%3d outgoing TONE dir='%s' name='%s'\n",
- ea_endpoint->ep_serial,
- message->param.tone.dir,
- message->param.tone.name
- );
+ trace_header("TONE", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ if (param->tone.name[0])
+ {
+ add_trace("directory", NULL, "%s", param->tone.dir[0]?param->tone.dir:"default");
+ add_trace("name", NULL, "%s", param->tone.name);
+ } else
+ add_trace("off", NULL, NULL);
+ end_trace();
+ break;
+
+ case MESSAGE_SUSPEND:
+ case MESSAGE_RESUME:
+ if (message_type == MESSAGE_SUSPEND)
+ trace_header("SUSPEND", dir);
+ else
+ trace_header("RESUME", dir);
+ if (dir == DIRECTION_OUT)
+ add_trace("to", NULL, "CH(%lu)", port_id);
+ if (dir == DIRECTION_IN)
+ add_trace("from", NULL, "CH(%lu)", port_id);
+ if (param->parkinfo.len)
+ add_trace("length", NULL, "%d", param->parkinfo.len);
+ end_trace();
break;
default:
- PERROR("EPOINT(%d) message not of correct type (%d)\n", ea_endpoint->ep_serial, message->type);
+ PERROR("EPOINT(%d) message not of correct type (%d)\n", ea_endpoint->ep_serial, message_type);
}
}
SCPY(message->param.notifyinfo.display, get_isdn_cause(cause, location, e_ext.display_cause));
}
message_put(message);
- logmessage(message);
+ logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
}
+
+
projects / lcr.git / blobdiff