ADMIN_CALL_DISCONNECT,
ADMIN_CALL_RELEASE,
ADMIN_CALL_NOTIFY,
+ ADMIN_MESSAGE,
};
struct admin_response_cmd {
};
struct admin_message {
+ int type; /* type of message */
+ unsigned long ref; /* reference to individual endpoints */
+ union parameter param; /* parameter union */
+};
+
+struct admin_message {
int message; /* type of admin message */
union u {
struct admin_response_cmd x;
struct admin_response_epoint e;
struct admin_response_call c;
struct admin_call call;
+ struct admin_message message;
} u;
};
if (admin_state(&admin->response) < 0)
{
PERROR("Failed to create state response for socket %d.\n", admin->sock);
+ goto response_error;
+ }
+ case ADMIN_REQUEST_MESSAGE:
+ if (admin_message(&admin->response) < 0)
+ {
+ PERROR("Failed to create message response for socket %d.\n", admin->sock);
response_error:
*adminp = admin->next;
free_connection(admin);
if (*present != INFO_PRESENT_RESTRICTED)
return;
- /* external ports receive no restricted caller id */
- if (port_type==PORT_TYPE_DSS1_TE_IN || port_type==PORT_TYPE_DSS1_TE_OUT)
+ /* only extensions are restricted */
+ if (!intern)
+ return;
+ if (!intern[0])
return;
/* if we enabled anonymouse ignore */
/* see if port is available */
if (!ifport->mISDNport)
{
- printlog("%3d port#%d position %d is not available, skipping.\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
+ printlog("%3d port#%d position %d is not available, skipping.\n", ea_endpoint->ep_serial, ifport->portnum, index);
goto portbusy;
}
mISDNport = ifport->mISDNport;
/* 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_start->portnum, index);
+ printlog("%3d port#%d position %d is administratively blocked, skipping.\n", ea_endpoint->ep_serial, ifport->portnum, index);
goto portbusy;
}
/* see if link is up */
if (mISDNport->ptp && !mISDNport->l2link)
{
- printlog("%3d port#%d position %d is ptp but layer 2 is down.\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
+ 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);
goto portbusy;
}
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_start->portnum, index, *channel);
+ printlog("%3d port#%d position %d selecting free channel %d\n", ea_endpoint->ep_serial, ifport->portnum, index, *channel);
break;
}
i++;
{
break; /* all channel in use or reserverd */
}
- printlog("%3d port#%d position %d using with 'any channel'\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
+ printlog("%3d port#%d position %d using with 'any channel'\n", ea_endpoint->ep_serial, ifport->portnum, index);
*channel = SEL_CHANNEL_ANY;
break;
case CHANNEL_NO: /* call waiting */
- printlog("%3d port#%d position %d using with 'no channel'\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
+ printlog("%3d port#%d position %d using with 'no channel'\n", ea_endpoint->ep_serial, ifport->portnum, index);
*channel = SEL_CHANNEL_NO;
break;
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_start->portnum, index, *channel);
+ printlog("%3d port#%d position %d selecting given channel %d\n", ea_endpoint->ep_serial, ifport->portnum, index, *channel);
break;
}
break;
}
if (*channel)
break; /* found channel */
- printlog("%3d port#%d position %d skipping, because no channel found.\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
selchannel = selchannel->next;
}
return(mISDNport);
}
+ printlog("%3d port#%d position %d skipping, because no channel found.\n", ea_endpoint->ep_serial, ifport->portnum, index);
+
portbusy:
/* go next port, until all ports are checked */
index++;
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);
- dialinginfo.itype = INFO_ITYPE_INTERN;
+ 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);
+ portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->is_earlyb);
if (!portlist)
{
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
while(*p)
{
/* only if vbox should be dialed, and terminal is given */
+ earlyb = 0;
if (!strcmp(p, "vbox") && e_terminal[0])
{
/* go to the end of p */
/* 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;
} else
{
port = NULL;
SCPY(dialinginfo.number, cfp);
dialinginfo.itype = INFO_ITYPE_EXTERN;
dialinginfo.ntype = e_dialinginfo.ntype;
- portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type);
+ portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, earlyb);
if (!portlist)
{
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
SCPY(dialinginfo.number, e_dialinginfo.number);
dialinginfo.itype = INFO_ITYPE_H323;
dialinginfo.ntype = e_dialinginfo.ntype;
- portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type);
+ portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, 0);
if (!portlist)
{
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
SCPY(dialinginfo.number, e_dialinginfo.number);
dialinginfo.itype = INFO_ITYPE_SIP;
dialinginfo.ntype = e_dialinginfo.ntype;
- portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type);
+ portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, 0);
if (!portlist)
{
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
SCPY(dialinginfo.number, number);
dialinginfo.itype = INFO_ITYPE_EXTERN;
dialinginfo.ntype = e_dialinginfo.ntype;
- portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type);
+ portlist = ea_endpoint->portlist_new(port->p_serial, port->p_type, mISDNport->is_earlyb);
if (!portlist)
{
PERROR("EPOINT(%d) cannot allocate port_list relation\n", ea_endpoint->ep_serial);
e_dtmf = param->setup.dtmf;
/* check where the call is from */
- if ((param->setup.port_type&PORT_CLASS_mISDN_MASK) == PORT_CLASS_mISDN_DSS1)
+ if (e_callerinfo.interface[0])
{
interface = interface_first;
while(interface)
{
- if (param->setup.isdn_port>=0 && param->setup.isdn_port<(int)sizeof(interface->ports))
+ if (!strcmp(e_callerinfo.interface, interface->name))
{
- if (interface->ports[param->setup.isdn_port])
- break;
+ break;
}
interface = interface->next;
}
if (interface)
{
+ /* check for MSN numbers, use first MSN if no match */
+ msn1 = NULL;
+ ifmsn = interface->ifmsn;
+ while(ifmns)
+ {
+ if (!msn1)
+ msn1 = ifmns->msn;
+ if (!strcmp(ifmns->mns, e_callerinfo.id))
+ {
+ break;
+ }
+ ifmsn = ifmsn->next;
+ }
+ if (!ifmns && mns1) // not in list, first msn given
+ SCPY(p_callerinfo.id, msn1);
+
/* interface is known */
if (interface->iftype==IF_INTERN)
{
+
/* interface is internal */
if (interface->extensions[0])
{
+ hier denken
/* extensions are assigned to interface */
p = interface->extensions;
extension1[0] = '\0';
e_dialing_queue[0] = '\0';
}
/* check if pattern is available */
- if (!ea_endpoint->ep_portlist->next && portlist->port_type==PORT_TYPE_DSS1_TE_OUT) /* one port_list relation and outgoing external*/
+ if (!ea_endpoint->ep_portlist->next && portlist->earlyb) /* 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);
} else
{
/* indicate no 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_call_id, EPOINT_TO_CALL, MESSAGE_NOPATTERN);
message_put(message);
/* disconnect audio, if not already */
);
e_state = EPOINT_STATE_OUT_PROCEEDING;
/* check if pattern is availatle */
- if (!ea_endpoint->ep_portlist->next && (portlist->port_type==PORT_TYPE_DSS1_TE_OUT || portlist->port_type==PORT_TYPE_VBOX_OUT)) /* one port_list relation and outgoing external*/
+ if (!ea_endpoint->ep_portlist->next && (portlist->earlyb || 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);
} else
{
/* indicate no 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_call_id, EPOINT_TO_CALL, MESSAGE_NOPATTERN);
message_put(message);
/* disconnect audio, if not already */
);
new_state(EPOINT_STATE_OUT_ALERTING);
/* check if pattern is available */
- if (!ea_endpoint->ep_portlist->next && (portlist->port_type==PORT_TYPE_DSS1_TE_OUT || portlist->port_type==PORT_TYPE_VBOX_OUT)) /* one port_list relation and outgoing external*/
+ if (!ea_endpoint->ep_portlist->next && (portlist->earlyb || 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);
SCPY(e_terminal_interface, e_connectinfo.interfaces);
/* for internal and am calls, we get the extension's id */
- /* also for hidden calls to extension */
- if (portlist->port_type==PORT_TYPE_DSS1_NT_OUT || portlist->port_type==PORT_TYPE_VBOX_OUT || e_ext.colp==COLP_HIDE)
+ if (portlist->port_type==PORT_TYPE_VBOX_OUT || e_ext.colp==COLP_HIDE)
{
SCPY(e_connectinfo.id, e_ext.callerid);
SCPY(e_connectinfo.intern, e_terminal);
int haspatterns = 0;
/* check if pattern is available */
if (ea_endpoint->ep_portlist)
- if (!ea_endpoint->ep_portlist->next)
- if ((ea_endpoint->ep_portlist->port_type==PORT_TYPE_DSS1_TE_OUT) || (ea_endpoint->ep_portlist->port_type==PORT_TYPE_DSS1_TE_IN))
+ 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:
&& message_type != MESSAGE_RELEASE) // if we release, we are done
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_call_id, EPOINT_TO_CALL, MESSAGE_CHANNEL);
message->param.channel = 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_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_put(message);
+// patterns are available, remote already connected audio
}
break;
}
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->param.channel = param->channel;
message_put(message);
break;
+#endif
/* CALL sends a notify message */
case MESSAGE_NOTIFY:
if (other_port) /* port still exists */
{
if (other_port->p_type==PORT_TYPE_DSS1_NT_OUT
- || other_port->p_type==PORT_TYPE_DSS1_NT_IN) /* port is internal isdn */
+ || other_port->p_type==PORT_TYPE_DSS1_NT_IN) /* port is isdn nt-mode */
{
other_pdss1 = (class Pdss1 *)other_port;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) comparing other endpoint's port is of type isdn! comparing our portnum=%d with other's portnum=%d hold=%s ces=%d\n", ea_endpoint->ep_serial, our_pdss1->p_m_mISDNport->portnum, other_pdss1->p_m_mISDNport->portnum, (other_pdss1->p_m_hold)?"YES":"NO", other_pdss1->p_m_d_ces);
*/
Pdss1::Pdss1(int type, mISDNport *mISDNport, char *portname, struct port_settings *settings, int channel, int exclusive) : PmISDN(type, mISDNport, portname, settings, channel, exclusive)
{
- p_callerinfo.itype = INFO_ITYPE_ISDN;
+ p_callerinfo.itype = (mISDNport->ifport->interface->extension)?INFO_ITYPE_ISDN:INFO_ITYPE_ISDN_EXTENSION;
p_m_d_ntmode = mISDNport->ntmode;
p_m_d_l3id = 0;
p_m_d_ces = -1;
class Endpoint *epoint;
struct message *message;
+ /* if blocked, release call */
+ if (p_m_mISDNport->ifport->block)
+ {
+ RELEASE_COMPLETE_t *release_complete;
+
+ printlog("--- port#%d is blocked.\n", mISDNport->ifport->portnum);
+ dmsg = create_l3msg(CC_RELEASE_COMPLETE | REQUEST, MT_RELEASE_COMPLETE, dinfo, sizeof(RELEASE_COMPLETE_t), p_m_d_ntmode);
+ isdn_show_send_message(CC_RELEASE_COMPLETE | REQUEST, dmsg);
+ release_complete = (RELEASE_COMPLETE_t *)(dmsg->data + headerlen);
+ enc_ie_cause(&release_complete->CAUSE, dmsg, (p_m_d_ntmode)?LOCATION_PRIVATE_LOCAL:LOCATION_PRIVATE_REMOTE, 27); /* temporary unavailable */
+ msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
+ new_state(PORT_STATE_RELEASE);
+ p_m_delete = 1;
+ return;
+ }
+
/* caller information */
dec_ie_calling_pn(setup->CALLING_PN, (Q931_info_t *)((unsigned long)data+headerlen), &type, &plan, &present, &screen, (unsigned char *)p_callerinfo.id, sizeof(p_callerinfo.id));
switch (present)
break;
}
- /* channel_id */ jolly todo
+ /* channel_id */
dec_ie_channel_id(setup->CHANNEL_ID, (Q931_info_t *)((unsigned long)data+headerlen), &exclusive, &channel);
if (exclusive<0)
exclusive = 0;
PDEBUG(DEBUG_BCHANNEL, "- no channel is given by the network, causing to fail, since CW is not possible for external lines\n");
if (channel <= 0) /* not given, no channel, whatever.. */
channel = CHANNEL_ANY; /* any channel */
+ if (p_m_mISDNport->b_reserved >= p_m_mISDNport->b_num) // of out chan..
+ {
+ printlog("--- port#%d all channels are used/reserved.\n", ifport->portnum);
+ ret = -34; // no channel
+ goto no_channel;
+ }
if (channel == CHANNE_ANY)
{
PDEBUG(DEBUG_BCHANNEL, "- any channel is assumed from the %s, so we need to return the a channel from our list\n", (p_m_d_ntmode)?"user":"network");
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_start->portnum, index, *channel);
+ printlog("--- port#%d no channel given, so selecting free channel %d\n", ifport->portnum, channel);
break;
}
i++;
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_start->portnum, index, *channel);
+ printlog("--- port#%d no channel given, so selecting channel %d from list\n", ifport->portnum, channel);
break;
}
break;
}
if (channel)
break; /* found channel */
- //printlog("%3d port#%d position %d skipping, because no channel found.\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
selchannel = selchannel->next;
}
if (!channel)
{
+ printlog("--- port#%d no channel found.\n", ifport->portnum);
ret = -34; // no channel
goto no_channel;
}
+ goto use_channel;
}
if (channel > 0)
+ {
/* check for given channel in selection list */
selchannel = ifport->channel_in;
while(selchannel)
{
if (selchannel->channel == channel || selchannel->channel == CHANNEL_FREE)
break;
- //printlog("%3d port#%d position %d skipping, because no channel found.\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
selchannel = selchannel->next;
}
if (!selchannel)
channel = 0;
+ /* exclusive channel requests must be in the list */
if (exclusive)
{
if (!channel)
{
PDEBUG(DEBUG_BCHANNEL, "- exclusive channel %d is selected, but not in list of incomming channel.\n", channel);
+ printlog("--- port#%d channel %d given exclusively, it is accepted.\n", ifport->portnum, channel);
ret = 6; // unacceptable
goto no_channel;
}
PDEBUG(DEBUG_BCHANNEL, "- exclusive channel %d is selected, as in list of incomming channels.\n", channel);
- } else
+ i = selchannel->channel-1-(selchannel->channel>=17);
+ if (mISDNport->b_port[i] == NULL)
+ {
+ printlog("--- port#%d channel %d given exclusively, it is accepted and free.\n", ifport->portnum, channel);
+ goto use_channel;
+ }
+ printlog("--- port#%d channel %d given exclusively, it is accepted, but busy.\n", ifport->portnum, channel);
+ ret = 6; // unacceptable
+ goto no_channel;
+ }
+
+ /* requested channels in list will be used */
if (channel)
{
PDEBUG(DEBUG_BCHANNEL, "- channel %d given, found in list.\n", channel);
i = selchannel->channel-1-(selchannel->channel>=17);
if (mISDNport->b_port[i] == NULL)
{
+ printlog("--- port#%d channel %d given, it is accepted and free.\n", ifport->portnum, channel);
goto use_channel;
}
- goto inuse_search_differnt;
- } else
- {
- inuse_search_different:
- PDEBUG(DEBUG_BCHANNEL, "- channel %d given, but not in list of incomming channels.\n", channel);
+ }
+
+ /* if channel is not available or not in list, it must be searched */
+ PDEBUG(DEBUG_BCHANNEL, "- channel %d given, but not in list of incomming channels.\n", channel);
- /* check for first free channel in list */
- selchannel = ifport->channel_in;
- while(selchannel)
+ /* check for first free channel in list */
+ channel = 0;
+ selchannel = ifport->channel_in;
+ while(selchannel)
+ {
+ switch(selchannel->channel)
{
- switch(selchannel->channel)
+ case CHANNEL_FREE: /* free channel */
+ if (mISDNport->b_inuse >= mISDNport->b_num)
+ break; /* all channel in use or reserverd */
+ /* find channel */
+ i = 0;
+ while(i < mISDNport->b_num)
{
- case CHANNEL_FREE: /* free channel */
- if (mISDNport->b_inuse >= mISDNport->b_num)
- break; /* all channel in use or reserverd */
- /* find channel */
- i = 0;
- while(i < mISDNport->b_num)
- {
- if (mISDNport->b_port[i] == NULL)
- {
- channel = i+1+(i>=15);
- //printlog("%3d port#%d position %d selecting free channel %d\n", ea_endpoint->ep_serial, ifport_start->portnum, index, *channel);
- break;
- }
- i++;
- }
- break;
-
- default:
- if (selchannel->channel<1 || selchannel->channel==16)
- break; /* invalid channels */
- i = selchannel->channel-1-(selchannel->channel>=17);
- if (i >= mISDNport->b_num)
- break; /* channel not in port */
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_start->portnum, index, *channel);
+ channel = i+1+(i>=15);
+ printlog("--- port#%d requested channel was not in list, so using free channel %d from list.\n", ifport->portnum, channel);
break;
}
+ i++;
+ }
+ break;
+
+ default:
+ if (selchannel->channel<1 || selchannel->channel==16)
+ break; /* invalid channels */
+ i = selchannel->channel-1-(selchannel->channel>=17);
+ if (i >= mISDNport->b_num)
+ break; /* channel not in port */
+ if (mISDNport->b_port[i] == NULL)
+ {
+ channel = selchannel->channel;
+ printlog("--- port#%d requested channel was not in list, so using free channel %d from list.\n", ifport->portnum, channel);
break;
}
- if (channel)
- break; /* found channel */
- //printlog("%3d port#%d position %d skipping, because no channel found.\n", ea_endpoint->ep_serial, ifport_start->portnum, index);
- selchannel = selchannel->next;
- }
- if (!channel)
- {
- ret = 6; // unacceptable
- goto no_channel;
+ break;
}
+ if (channel)
+ break; /* found channel */
+ selchannel = selchannel->next;
}
-channel wählen
+ if (!channel)
+ {
+ printlog("--- port#%d no channel found.\n", ifport->portnum);
+ ret = 6; // unacceptable
+ goto no_channel;
+ }
+ }
+
/* open channel */
use_channel:
ret = seize_bchannel(channel, 1);
p_m_delete = 1;
return;
}
- PDEBUG(DEBUG_BCHANNEL, "- channel is available, we selected channel %d.\n", ret);
+ PDEBUG(DEBUG_BCHANNEL, "- channel is available, we open channel %d.\n", ret);
+ bchannel_activate(p_m_mISDNport, p_m_b_index);
+
/* create endpoint */
if (p_epointlist)
{
PDEBUG(DEBUG_ISDN, "Pdss1(%s) nt-mode gives us new l3id via setup ind: 0x%x\n", p_name, p_m_d_l3id);
}
+ /* send setup message to endpoit */
PDEBUG(DEBUG_ISDN, "Pdss1(%s) setup: %s->%s\n", p_name, p_callerinfo.id, p_dialinginfo.number);
message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_SETUP);
message->param.setup.isdn_port = p_m_portnum;
if (cause < 0)
cause = 16;
- /* release if we are internal, since internal TEs don't send tones */
- if (p_m_d_ntmode) // || !options.inbandpattern)
+ /* release if we are remote sends us no tones */
+ if (p_m_mISDNport->is_earlyb)
{
RELEASE_t *release;
msg_t *dmsg;
- PDEBUG(DEBUG_ISDN, "Pdss1(%s) send release because internal phone disconnects OR inbandpatterns are not enabled.\n", p_name);
+ PDEBUG(DEBUG_ISDN, "Pdss1(%s) send release because remote disconnects AND provides no patterns (earlyb).\n", p_name);
dmsg = create_l3msg(CC_RELEASE | REQUEST, MT_RELEASE, dinfo, sizeof(RELEASE_t), p_m_d_ntmode);
isdn_show_send_message(CC_RELEASE | REQUEST, dmsg);
release = (RELEASE_t *)(dmsg->data + headerlen);
struct message *message;
int ret;
+ /* if blocked, release call */
+ if (p_m_mISDNport->ifport->block)
+ {
+ RELEASE_COMPLETE_t *release_complete;
+
+ printlog("--- port#%d is blocked.\n", mISDNport->ifport->portnum);
+ ret = -27;
+ goto reject;
+ }
+
/* call id */
dec_ie_call_id(resume->CALL_ID, (Q931_info_t *)((unsigned long)data+headerlen), callid, &len);
if (len<0) len = 0;
PERROR("no memory for epointlist\n");
exit(-1);
}
- if (!(epoint->portlist_new(p_serial, p_type)))
+ if (!(epoint->portlist_new(p_serial, p_type, p_m_mISDNport->is_earlyb)))
{
PERROR("no memory for portlist\n");
exit(-1);
int i;
struct epoint_list *epointlist;
+ /* release if port is blocked */
+ if (p_m_mISDNport->ifport->block)
+ {
+ message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
+ message->param.disconnectinfo.cause = 27; // temp. unavail.
+ message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
+ message_put(message);
+ new_state(PORT_STATE_RELEASE);
+ p_m_delete = 1;
+ return;
+ }
+
/* copy setup infos to port */
memcpy(&p_callerinfo, ¶m->setup.callerinfo, sizeof(p_callerinfo));
memcpy(&p_dialinginfo, ¶m->setup.dialinginfo, sizeof(p_dialinginfo));
if (p_capainfo.bearer_capa==INFO_BC_SPEECH
|| p_capainfo.bearer_capa==INFO_BC_AUDIO
|| p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
- if (p_m_d_ntmode || options.inbandpattern)
+ if (p_m_mISDNport->is_tones)
enc_ie_progress(&setup_acknowledge->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
if (p_capainfo.bearer_capa==INFO_BC_SPEECH
|| p_capainfo.bearer_capa==INFO_BC_AUDIO
|| p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
- if (p_m_d_ntmode || options.inbandpattern)
+ if (p_m_mISDNport->is_tones)
enc_ie_progress(&proceeding->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
if (p_capainfo.bearer_capa==INFO_BC_SPEECH
|| p_capainfo.bearer_capa==INFO_BC_AUDIO
|| p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
- if (p_m_d_ntmode || options.inbandpattern)
+ if (p_m_mISDNport->is_tones)
enc_ie_progress(&alerting->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
msg_queue_tail(&p_m_mISDNport->downqueue, dmsg);
struct message *message;
char *p = NULL;
- /* we reject during incoming setup when we have no inbandpatterns. also if we are in outgoing setup state */
- if ((!p_m_d_ntmode && p_state==PORT_STATE_IN_SETUP && !options.inbandpattern)
+ /* we reject during incoming setup when we have no tones. also if we are in outgoing setup state */
+ if ((p_state==PORT_STATE_IN_SETUP && !p_m_mISDNport->is_tones)
|| p_state==PORT_STATE_OUT_SETUP)
{
/* sending release to endpoint */
if (p_capainfo.bearer_capa==INFO_BC_SPEECH
|| p_capainfo.bearer_capa==INFO_BC_AUDIO
|| p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
- if (p_m_d_ntmode || options.inbandpattern)
+ if (p_m_mISDNport->is_tones)
enc_ie_progress(&disconnect->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
/* send cause */
enc_ie_cause(&disconnect->CAUSE, dmsg, (p_m_d_ntmode && param->disconnectinfo.location==LOCATION_PRIVATE_LOCAL)?LOCATION_PRIVATE_LOCAL:param->disconnectinfo.location, param->disconnectinfo.cause);
if (p_capainfo.bearer_capa==INFO_BC_SPEECH
|| p_capainfo.bearer_capa==INFO_BC_AUDIO
|| p_capainfo.bearer_capa==INFO_BC_DATAUNRESTRICTED_TONES)
- if (p_m_d_ntmode || options.inbandpattern)
+ if (p_m_mISDNport->is_tones)
enc_ie_progress(&disconnect->PROGRESS, dmsg, 0, p_m_d_ntmode?1:5, 8);
/* send cause */
enc_ie_cause(&disconnect->CAUSE, dmsg, (p_m_d_ntmode && param->disconnectinfo.location==LOCATION_PRIVATE_LOCAL)?LOCATION_PRIVATE_LOCAL:param->disconnectinfo.location, param->disconnectinfo.cause);
{
class Port *port;
class Endpoint **epointpointer;
+ int earlyb = 0;
/* epoint structure */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d): Allocating enpoint %d and connecting it with:%s%s\n", epoint_serial, epoint_serial, (port_id)?" ioport":"", (call_id)?" call":"");
{
port = find_port_id(port_id);
if (port)
- if (!portlist_new(port_id, port->p_type))
{
- PERROR("no mem for portlist, exitting...\n");
- exit(-1);
+ if ((port->p_type&PORT_CLASS_mISDN_MASK) == PORT_CLASS_mISDN_DSS1)
+ earlyb = port->mISDNport->is_earlyb;
+ if (!portlist_new(port_id, port->p_type, earlyb))
+ {
+ PERROR("no mem for portlist, exitting...\n");
+ exit(-1);
+ }
}
}
ep_call_id = call_id;
/* create new portlist relation
*/
-struct port_list *Endpoint::portlist_new(unsigned long port_id, int port_type)
+struct port_list *Endpoint::portlist_new(unsigned long port_id, int port_type, int earlyb)
{
struct port_list *portlist, **portlistpointer;
/* link to call or port */
portlist->port_id = port_id;
portlist->port_type = port_type;
+ portlist->earlyb = earlyb;
return(portlist);
}
struct port_list *next;
unsigned long port_id;
int port_type;
+ int early_b; /* if patterns are available */
};
/* structure of an Enpoint */
SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
return(-1);
}
+ if (interface->ifport->ptmp)
+ {
+ SPRINT(interface_error, "Error in %s (line %d): parameter '%s' previously ptmp was given.\n", filename, line, parameter);
+ return(-1);
+ }
/* goto end of chain */
ifport = interface->ifport;
while(ifport->next)
ifport->ptp = 1;
return(0);
}
+static int inter_ptmp(struct interface *interface, char *filename, int line, char *parameter, char *value)
+{
+ struct interface_port *ifport;
+
+ /* port in chain ? */
+ if (!interface->ifport)
+ {
+ SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects previous 'port' definition.\n", filename, line, parameter);
+ return(-1);
+ }
+ if (interface->ifport->ptp)
+ {
+ SPRINT(interface_error, "Error in %s (line %d): parameter '%s' previously ptp was given.\n", filename, line, parameter);
+ return(-1);
+ }
+ /* goto end of chain */
+ ifport = interface->ifport;
+ while(ifport->next)
+ ifport = ifport->next;
+ /* add value */
+ if (value[0])
+ {
+ SPRINT(interface_error, "Error in %s (line %d): parameter '%s' expects no value.\n", filename, line, parameter);
+ return(-1);
+ }
+ ifport->ptmp = 1;
+ return(0);
+}
static int inter_tones(struct interface *interface, char *filename, int line, char *parameter, char *value)
{
if (!strcasecmp(value, "yes"))
"This is required on NT-mode ports that are multipoint by default.\n"
"This parameter must follow a 'port' parameter."},
+ {"ptmp", &inter_ptmp, "",
+ "The given port above is opened as point-to-multipoint.\n"
+ "This is required on PRI NT-mode ports that are point-to-point by default.\n"
+ "This parameter must follow a 'port' parameter."},
+
{"channel_out", &inter_channel_out, "[force,][<number>][,...][,free][,any][,no]",
"Channel selection list for all outgoing calls to the interface.\n"
"A free channels is searched in order of appearance.\n"
if (!ifport->mISDNport)
{
/* open new port */
- mISDNport = mISDNport_open(ifport->portnum, ifport->ptp);
+ mISDNport = mISDNport_open(ifport->portnum, ifport->ptp, ifport->ptmp);
if (mISDNport)
{
ifport->mISDNport = mISDNport;
mISDNport->ifport = ifport;
}
}
- if (ifport->mISDNport && !ifport->selchannel)
- default_selchannel(ifport);
+ if (ifport->mISDNport)
+ {
+ /* default channel selection list */
+ if (!ifport->selchannel)
+ default_selchannel(ifport);
+ /* default is_tones */
+ if (ifport->interface->is_tones)
+ ifport->mISDNport->is_tones = (ifport->interface->is_tones==IS_YES);
+ else
+ ifport->mISDNport->is_tones = (ifport->mISDNport->ntmode)?1:0;
+ /* default is_earlyb */
+ if (ifport->interface->is_earlyb)
+ ifport->mISDNport->is_earlyb = (ifport->interface->is_earlyb==IS_YES);
+ else
+ ifport->mISDNport->is_earlyb = (ifport->mISDNport->ntmode)?0:1;
+ }
}
interface = interface->next;
}
int channel_force; /* forces channel by protocol */
struct select_channel *out_select; /* list of channels to select */
struct select_channel *in_select; /* the same for incoming channels */
-// int open; /* set if port is opened */
int block; /* set if interface is blocked */
};
return;
}
- /* external incoming calls will not process any audio data unless
- * the call is connected OR inbandpattern feature is enabled.
+ /* calls will not process any audio data unless
+ * the call is connected OR tones feature is enabled.
*/
- if (p_type==PORT_TYPE_DSS1_TE_IN
- && p_state!=PORT_STATE_CONNECT
- && !options.inbandpattern)
+ if (p_state!=PORT_STATE_CONNECT
+ && !p_m_mISDNport->is_tones)
return;
#if 0
/*
* global function to add a new card (port)
*/
-struct mISDNport *mISDN_port_open(int port, int ptp)
+struct mISDNport *mISDN_port_open(int port, int ptp, int ptmp)
{
int ret;
unsigned char buff[1025];
{
PDEBUG(DEBUG_ISDN, "Port is point-to-point.\n");
mISDNport->ptp = ptp = 1;
+ if (ptmp && nt)
+ {
+ PDEBUG(DEBUG_ISDN, "Port is forced to point-to-multipoint.\n");
+ mISDNport->ptp = ptp = 0;
+ }
}
i = 0;
while(i < stinf->childcnt)
int use; /* counts the number of port that uses this port */
int ntmode; /* is TRUE if port is nt mode */
int pri; /* is TRUE if port is a primary rate interface */
+ int is_tones; /* TRUE if tones are sent outside connect state */
+ int is_earlyb; /* TRUE if tones are received outside connect state */
int upper_id; /* id to transfer data down */
int lower_id; /* id to transfer data up */
int d_stid;
/*****************************************************************************\
** **
-** PBX4Linux **
+** Linux Call Router **
** **
**---------------------------------------------------------------------------**
** Copyright: Andreas Eversberg **
/* call-info structure CALLER */
struct caller_info {
char id[32]; /* id of caller (user number) */
- char voip[64]; /* URI of voip (or gateway) */
- char intern[32]; /* internal id */
+ char extension[32]; /* internal id */
char name[16];
int isdn_port; /* internal/external port (if call is isdn) */
char interface[32]; /* interface name the call was from */
/* call-info structure SETUP */
struct message_setup {
- int isdn_port; /* card number 1...n (only on calls from internal isdn port) */
+ int isdn_port; /* card number 1...n (only on calls from isdn port) */
int port_type; /* type of port (only required if message is port -> epoint) */
int dtmf; /* used to enabled dtmf dialing at setup state */
int partyline; /* if set, call will be a conference room */
MESSAGE_RESUME, /* resume port */
MESSAGE_CHANNEL, /* set status of audio path to endpoint (to call, audio is also set) */
- MESSAGE_REMOTE_AUDIO, /* tell remote to set audio status */
+// MESSAGE_REMOTE_AUDIO, /* tell remote to set audio status */
MESSAGE_PATTERN, /* pattern information tones available */
MESSAGE_NOPATTERN, /* pattern information tones unavailable */
MESSAGE_CRYPT, /* encryption message */
"MESSAGE_SUSPEND", \
"MESSAGE_RESUME", \
"MESSAGE_CHANNEL", \
- "MESSAGE_REMOTE_AUDIO", \
+/* "MESSAGE_REMOTE_AUDIO",*/ \
"MESSAGE_PATTERN", \
"MESSAGE_NOPATTERN", \
"MESSAGE_CRYPT", \
5060, 5, /* SIP port, maxqueue */
0, /* dtmf detection on */
"", /* dummy caller id */
- 0, /* inband patterns on external calls */
0, /* use tones by dsp.o */
0, /* by default use priority 0 */
"pbx@jolly.de" /* source mail adress */
PDEBUG(DEBUG_CONFIG, "dummy caller id\n", param);
} else
- if (!strcmp(option,"inbandpattern"))
- {
- if (!strcasecmp(param, "yes"))
- options.inbandpattern = 1;
-
- PDEBUG(DEBUG_CONFIG, "inband pattern = %s\n", (options.inbandpattern)?"yes":"no");
- } else
if (!strcmp(option,"dsptones"))
{
if (!strcasecmp(param, "american"))
int sip_maxqueue;
int nodtmf; /* use dtmf detection */
char dummyid[32]; /* caller id for external calls if not available */
- int inbandpattern; /* inband patterns on external calls */
int dsptones; /* tones will be generated via dsp.o 1=american 2=ger */
int schedule; /* run process in realtime @ given priority */
char email[128]; /* source email address */
+define and change dsp conference ids
make asterisk call implementation
-interface.conf neu
+new interface.conf
-mixer abspecken
+reduce mixer
call recording
-call zu mehreren extensions
-
-
+call to multiple endpoints (extensions)
+trace with layers and filters
+ - layer 1 and 2 state changes and messages
+ - layer 3 isdn trace, process ids
+ - messages between port, endpoint and call
+ - port hunt and channel selection
+ - dialing / routing
+ - application process (action)
+ - bchannel control (tones, dsp, filter, activation/deactivation)
+sip raus, h323 raus
+avoid disconnect-collision (release if disconnect from both sides)
projects / lcr.git / commitdiff