** **
\*****************************************************************************/
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <poll.h>
#include "main.h"
-#include "linux/isdnif.h"
extern char **environ;
-/* create caller id from digits by comparing with national and international
- * prefixes.
- */
-char *nationalize_callerinfo(char *string, int *ntype)
-{
- if (!strncmp(options.international, string, strlen(options.international)))
- {
- *ntype = INFO_NTYPE_INTERNATIONAL;
- return(string+strlen(options.international));
- }
- if (!strncmp(options.national, string, strlen(options.national)))
- {
- *ntype = INFO_NTYPE_NATIONAL;
- return(string+strlen(options.national));
- }
- *ntype = INFO_NTYPE_SUBSCRIBER;
- return(string);
-}
-
-/* create number (including access codes) from caller id
- * prefixes.
- */
-char *numberrize_callerinfo(char *string, int ntype)
-{
- static char result[256];
-
- switch(ntype)
- {
- case INFO_NTYPE_INTERNATIONAL:
- UCPY(result, options.international);
- SCAT(result, string);
- return(result);
- break;
-
- case INFO_NTYPE_NATIONAL:
- UCPY(result, options.national);
- SCAT(result, string);
- return(result);
- break;
-
- default:
- return(string);
- }
-}
-
-
/*
- * process init 'internal' / 'external' / 'asterisk' / 'vbox-record' / 'partyline'...
+ * process init 'internal' / 'external' / 'remote' / 'vbox-record' / 'partyline'...
*/
-void EndpointAppPBX::_action_init_call(int asterisk)
+int EndpointAppPBX::_action_init_call(char *remote)
{
class Join *join;
struct port_list *portlist = ea_endpoint->ep_portlist;
{
if (options.deb & DEBUG_EPOINT)
PERROR("EPOINT(%d): We already have a call instance, this should never happen!\n", ea_endpoint->ep_serial);
- return;
+ return(0);
}
- /* create call */
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d): Creating new call instance.\n", ea_endpoint->ep_serial);
- if (asterisk)
+ /* create join */
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d): Creating new join instance.\n", ea_endpoint->ep_serial);
+ if (remote)
{
- admin = admin_list;
+ admin = admin_first;
while(admin)
{
- if (admin->asterisk)
+ if (admin->remote_name[0] && !strcmp(admin->remote_name, remote))
break;
admin = admin->next;
}
if (!admin)
{
/* resource not available */
- message_disconnect_port(portlist, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
+ trace_header("ACTION remote (not available)", DIRECTION_NONE);
+ add_trace("application", NULL, "%s", remote);
+ end_trace();
+ message_disconnect_port(portlist, CAUSE_OUTOFORDER, LOCATION_PRIVATE_LOCAL, "");
new_state(EPOINT_STATE_OUT_DISCONNECT);
- set_tone(portlist,"cause_22");
- return;
+ set_tone(portlist,"cause_1b");
+ return(0);
}
- join = new JoinAsterisk(ea_endpoint->ep_serial);
+ join = new JoinRemote(ea_endpoint->ep_serial, remote, admin->sock);
}
else
join = new JoinPBX(ea_endpoint);
if (!join)
- FATAL("No memoy for Call instance.\n");
- ea_endpoint->ep_join_id = join->c_serial;
+ FATAL("No memoy for Join instance.\n");
+ ea_endpoint->ep_join_id = join->j_serial;
+ return(1);
}
void EndpointAppPBX::action_init_call(void)
{
- _action_init_call(0);
+ _action_init_call(NULL);
}
-void EndpointAppPBX::action_init_chan(void)
+void EndpointAppPBX::action_init_remote(void)
{
- _action_init_call(1);
}
/*
struct redir_info redirinfo;
struct dialing_info dialinginfo;
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
struct extension ext;
struct route_param *rparam;
trace_header("ACTION extension (extension doesn't exist)", DIRECTION_NONE);
add_trace("extension", NULL, dialinginfo.id);
end_trace();
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0, 0);
new_state(EPOINT_STATE_OUT_DISCONNECT);
message_disconnect_port(portlist, CAUSE_UNALLOCATED, LOCATION_PRIVATE_LOCAL, "");
set_tone(portlist, "cause_86");
add_trace("extension", NULL, dialinginfo.id);
end_trace();
new_state(EPOINT_STATE_OUT_DISCONNECT);
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0, 0);
message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
set_tone(portlist, "cause_81");
return;
struct dialing_info dialinginfo;
char *p;
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
struct route_param *rparam;
/* special processing of delete characters '*' and '#' */
{
trace_header("ACTION extern (calling denied)", DIRECTION_NONE);
end_trace();
- release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, 0);
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, 0, 0);
set_tone(portlist, "cause_82");
denied:
message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
{
trace_header("ACTION extern (national calls denied)", DIRECTION_NONE);
end_trace();
- release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, 0);
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, 0, 0);
set_tone(portlist, "cause_83");
goto denied;
}
{
trace_header("ACTION extern (international calls denied)", DIRECTION_NONE);
end_trace();
- release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, 0);
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, 0, 0);
set_tone(portlist, "cause_84");
goto denied;
}
}
-void EndpointAppPBX::action_dialing_chan(void)
+void EndpointAppPBX::action_dialing_remote(void)
{
- struct port_list *portlist = ea_endpoint->ep_portlist;
+ struct route_param *rparam;
+ struct port_list *portlist = ea_endpoint->ep_portlist;
+ struct lcr_msg *message;
+ struct capa_info capainfo;
+ struct caller_info callerinfo;
+ struct redir_info redirinfo;
+ struct dialing_info dialinginfo;
+ char context[128] = "";
+ char remote[32];
- trace_header("ACTION channel (not implemented)", DIRECTION_NONE);
- end_trace();
- message_disconnect_port(portlist, CAUSE_UNIMPLEMENTED, LOCATION_PRIVATE_LOCAL, "");
- new_state(EPOINT_STATE_OUT_DISCONNECT);
- set_tone(portlist,"cause_4f");
+ if (!ea_endpoint->ep_join_id)
+ {
+ /* no join yet, sending setup */
+ if (!(rparam = routeparam(e_action, PARAM_APPLICATION)))
+ {
+ trace_header("ACTION remote (no application given)", DIRECTION_NONE);
+ end_trace();
+ new_state(EPOINT_STATE_OUT_DISCONNECT);
+ message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
+ set_tone(portlist, "cause_3f");
+ return;
+ }
+ SCPY(remote, rparam->string_value);
+ if (!_action_init_call(remote))
+ return;
+
+ /* create bearer/caller/dialinginfo */
+ memcpy(&capainfo, &e_capainfo, sizeof(capainfo));
+ memcpy(&callerinfo, &e_callerinfo, sizeof(callerinfo));
+ memcpy(&redirinfo, &e_redirinfo, sizeof(redirinfo));
+ memset(&dialinginfo, 0, sizeof(dialinginfo));
+
+ if ((rparam = routeparam(e_action, PARAM_CONTEXT)))
+ {
+ SCPY(context, rparam->string_value);
+ }
+ if ((rparam = routeparam(e_action, PARAM_EXTEN)))
+ {
+ SCPY(dialinginfo.id, rparam->string_value);
+ dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
+ } else
+ {
+ SCPY(dialinginfo.id, e_extdialing);
+ }
+ e_extdialing = e_dialinginfo.id + strlen(e_dialinginfo.id);
+ /* send setup to remote */
+ trace_header("ACTION remote (setup)", DIRECTION_NONE);
+ add_trace("number", NULL, dialinginfo.id);
+ add_trace("remote", NULL, remote);
+ if (context[0])
+ add_trace("context", NULL, context);
+ end_trace();
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_SETUP);
+ memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
+ memcpy(&message->param.setup.redirinfo, &redirinfo, sizeof(struct redir_info));
+ memcpy(&message->param.setup.callerinfo, &callerinfo, sizeof(struct caller_info));
+ memcpy(&message->param.setup.capainfo, &capainfo, sizeof(struct capa_info));
+ SCPY(message->param.setup.context, context);
+ message_put(message);
+ } else
+ {
+ /* send overlap digits */
+ trace_header("ACTION remote (dialing)", DIRECTION_NONE);
+ add_trace("number", NULL, e_extdialing);
+ end_trace();
+ if (e_extdialing[0])
+ {
+ message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_INFORMATION);
+ memcpy(&message->param.information, &e_dialinginfo, sizeof(struct dialing_info));
+ SCPY(message->param.information.id, e_extdialing);
+ e_extdialing = e_dialinginfo.id + strlen(e_dialinginfo.id);
+ message_put(message);
+ }
+ }
}
{
struct dialing_info dialinginfo;
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
struct extension ext;
struct route_param *rparam;
class Join *join;
class JoinPBX *joinpbx;
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
struct route_param *rparam;
- int partyline;
+ int partyline, jingle = 0;
struct join_relation *relation;
portlist = ea_endpoint->ep_portlist;
goto noroom;
}
partyline = rparam->integer_value;
+ if ((rparam = routeparam(e_action, PARAM_JINGLE)))
+ jingle = 1;
/* don't create join if partyline exists */
join = join_first;
while(join)
{
- if (join->c_type == JOIN_TYPE_PBX)
+ if (join->j_type == JOIN_TYPE_PBX)
{
joinpbx = (class JoinPBX *)join;
- if (joinpbx->c_partyline == rparam->integer_value)
+ if (joinpbx->j_partyline == partyline)
break;
}
join = join->next;
if (!(relation=joinpbx->add_relation()))
FATAL("No memory for join relation\n");
relation->type = RELATION_TYPE_SETUP;
- relation->channel_state = CHANNEL_STATE_CONNECT;
+ relation->channel_state = 1;
relation->rx_state = NOTIFY_STATE_ACTIVE;
relation->tx_state = NOTIFY_STATE_ACTIVE;
relation->epoint_id = ea_endpoint->ep_serial;
}
- ea_endpoint->ep_join_id = join->c_serial;
+ ea_endpoint->ep_join_id = join->j_serial;
set_tone(portlist, "proceeding");
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
/* send setup to join */
trace_header("ACTION partyline (calling)", DIRECTION_NONE);
add_trace("room", NULL, "%d", partyline);
+ add_trace("jingle", NULL, (jingle)?"on":"off");
end_trace();
message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_SETUP);
message->param.setup.partyline = partyline;
+ message->param.setup.partyline_jingle = jingle;
memcpy(&message->param.setup.dialinginfo, &e_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));
*/
void EndpointAppPBX::action_hangup_call(void)
{
- int i;
-
trace_header("ACTION hangup", DIRECTION_NONE);
end_trace();
- /* check */
- if (e_ext.number[0] == '\0')
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: cannot store last dialed number '%s' because caller is unknown (not internal).\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id);
- return;
- }
- if (!(read_extension(&e_ext, e_ext.number)))
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: cannot store last dialed number '%s' because cannot read settings.\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id);
- return;
- }
- if (e_dialinginfo.id[0] == '\0')
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: cannot store last dialed number because nothing was dialed.\n", ea_endpoint->ep_serial, e_ext.number);
- return;
- }
- if (!strcmp(e_dialinginfo.id, e_ext.last_out[0]))
- {
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: cannot store last dialed number '%s' because it is identical with the last one.\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id);
- return;
- }
-
- /* insert */
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: storing last number '%s'.\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id);
- i = MAX_REMEMBER-1;
- while(i)
- {
- UCPY(e_ext.last_out[i], e_ext.last_out[i-1]);
- i--;
- }
- SCPY(e_ext.last_out[0], e_dialinginfo.id);
-
- /* write extension */
- write_extension(&e_ext, e_ext.number);
}
void EndpointAppPBX::action_dialing_login(void)
{
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
char *extension;
struct route_param *rparam;
message->param.connectinfo.present = INFO_PRESENT_RESTRICTED;
else message->param.connectinfo.present = e_ext.callerid_present;
/* handle restricted caller ids */
- apply_callerid_restriction(e_ext.anon_ignore, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name);
+ apply_callerid_restriction(&e_ext, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name);
/* display callerid if desired for extension */
SCPY(message->param.connectinfo.display, apply_callerid_display(message->param.connectinfo.id, message->param.connectinfo.itype, message->param.connectinfo.ntype, message->param.connectinfo.present, message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name));
message->param.connectinfo.ntype = e_ext.callerid_type;
(!next)?e_ext.callerid_type:e_ext.id_next_call_type = INFO_NTYPE_UNKNOWN;
} else
{
- SCPY((!next)?e_ext.callerid:e_ext.id_next_call, nationalize_callerinfo(callerid,&((!next)?e_ext.callerid_type:e_ext.id_next_call_type)));
+ SCPY((!next)?e_ext.callerid:e_ext.id_next_call, nationalize_callerinfo(callerid,&((!next)?e_ext.callerid_type:e_ext.id_next_call_type), options.national, options.international));
}
if (!next) e_ext.id_next_call_type = -1;
PDEBUG(DEBUG_EPOINT, "EPOINT(%d): nationalized callerid: '%s' type=%d\n", ea_endpoint->ep_serial, (!next)?e_ext.callerid:e_ext.id_next_call, (!next)?e_ext.callerid_type:e_ext.id_next_call_type);
trace_header("ACTION change-callerid (only next call)", DIRECTION_NONE);
else
trace_header("ACTION change-callerid (all future calls)", DIRECTION_NONE);
- add_trace("old", "caller id", "%s", numberrize_callerinfo(old_id, old_type));
+ add_trace("old", "caller id", "%s", numberrize_callerinfo(old_id, old_type, options.national, options.international));
add_trace("old", "present", "%s", (old_present==INFO_PRESENT_RESTRICTED)?"restricted":"allowed");
- add_trace("new", "caller id", "%s", numberrize_callerinfo(new_id, new_type));
+ add_trace("new", "caller id", "%s", numberrize_callerinfo(new_id, new_type, options.national, options.international));
add_trace("new", "present", "%s", (new_present==INFO_PRESENT_RESTRICTED)?"restricted":"allowed");
end_trace();
message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
*/
void EndpointAppPBX::_action_redial_reply(int in)
{
- struct message *message;
+ struct lcr_msg *message;
char *last;
struct route_param *rparam;
void EndpointAppPBX::action_dialing_powerdial(void)
{
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
struct route_param *rparam;
/* power dialing only possible if we have a last dialed number */
unsigned int cause;
char causestr[16];
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
class Port *port;
char testcode[32] = "";
struct route_param *rparam;
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
memcpy(&message->param.connectinfo, &e_connectinfo, sizeof(struct connect_info));
/* handle restricted caller ids */
- apply_callerid_restriction(e_ext.anon_ignore, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name);
+ apply_callerid_restriction(&e_ext, message->param.connectinfo.id, &message->param.connectinfo.ntype, &message->param.connectinfo.present, &message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name);
/* display callerid if desired for extension */
SCPY(message->param.connectinfo.display, apply_callerid_display(message->param.connectinfo.id, message->param.connectinfo.itype, message->param.connectinfo.ntype, message->param.connectinfo.present, message->param.connectinfo.screen, message->param.connectinfo.extension, message->param.connectinfo.name));
message_put(message);
void EndpointAppPBX::action_dialing_calculator(void)
{
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
double value1, value2, v, sign1;
int komma1, komma2, k, state, mode, first;
char *p;
} else
{
/* remove digits that are required to match the rule */
- if (!(rparam = routeparam(e_action, PARAM_STRIP)))
+ if ((rparam = routeparam(e_action, PARAM_STRIP)))
{
if (e_extdialing)
SCPY(e_dialinginfo.id, e_extdialing);
trace_header("ACTION goto/menu (change to)", DIRECTION_NONE);
add_trace("ruleset", NULL, "%s", e_ruleset->name);
if (e_dialinginfo.id[0])
+ {
add_trace("dialing", NULL, "%s", e_dialinginfo.id);
+ }
if ((rparam = routeparam(e_action, PARAM_SAMPLE)))
{
add_trace("sample", NULL, "%s", rparam->string_value);
+ end_trace();
set_tone(ea_endpoint->ep_portlist, rparam->string_value);
+ } else
+ {
+ end_trace();
}
- end_trace();
/* do dialing with new ruleset */
e_action = NULL;
{
struct route_param *rparam;
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
int cause = CAUSE_NORMAL; /* normal call clearing */
int location = LOCATION_PRIVATE_LOCAL;
char cause_string[256] = "", display[84] = "";
struct numbering *numbering = numbering_int;
char dialing[sizeof(e_dialinginfo.id)];
int i;
- struct message *message;
+ struct lcr_msg *message;
struct route_param *rparam;
/* in case we have no menu (this should never happen) */
void EndpointAppPBX::action_hangup_execute(void)
{
struct route_param *rparam;
+ pid_t pid;
char *command = "", isdn_port[10];
- char *argv[7+1]; /* check also number of args below */
+ char *argv[11]; /* check also number of args below */
int i = 0;
/* get script / command */
end_trace();
return;
}
- trace_header("ACTION execute", DIRECTION_NONE);
- add_trace("command", NULL, "%s", command);
- end_trace();
-
- argv[0] = command;
- while(strchr(argv[0], '/'))
- argv[0] = strchr(argv[0], '/')+1;
+ argv[i++] = "/bin/sh";
+ argv[i++] = "-c";
+ argv[i++] = command;
+ argv[i++] = command;
if ((rparam = routeparam(e_action, PARAM_PARAM)))
{
- argv[1] = rparam->string_value;
- i++;
+ argv[i++] = rparam->string_value;
}
- argv[1+i] = e_extdialing;
- argv[2+i] = numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype);
- argv[3+i] = e_callerinfo.extension;
- argv[4+i] = e_callerinfo.name;
+ argv[i++] = e_extdialing;
+ argv[i++] = numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype, options.national, options.international);
+ argv[i++] = e_callerinfo.extension;
+ argv[i++] = e_callerinfo.name;
SPRINT(isdn_port, "%d", e_callerinfo.isdn_port);
- argv[5+i] = isdn_port;
- argv[6+i] = NULL; /* check also number of args above */
- execve("/bin/sh", argv, environ);
+ argv[i++] = isdn_port;
+ argv[i++] = NULL; /* check also number of args above */
+ switch (pid = fork ()) {
+ case -1:
+ trace_header("ACTION execute (fork failed)", DIRECTION_NONE);
+ end_trace();
+ break;
+ case 0:
+ execve("/bin/sh", argv, environ);
+ break;
+ default:
+ trace_header("ACTION execute", DIRECTION_NONE);
+ add_trace("command", NULL, "%s", command);
+ end_trace();
+ break;
+ }
}
void EndpointAppPBX::process_dialing(void)
{
struct port_list *portlist = ea_endpoint->ep_portlist;
- struct message *message;
+ struct lcr_msg *message;
struct route_param *rparam;
//#warning Due to HANG-BUG somewhere here, I added some HANG-BUG-DEBUGGING output that cannot be disabled. after bug has been found, this will be removed.
release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL);
goto end;
}
- release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, 0);
+ release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0, 0);
e_action = e_action->next;
if (!e_action)
{
if (e_state!=EPOINT_STATE_IN_SETUP
&& e_state!=EPOINT_STATE_IN_OVERLAP)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d): we are not in incomming setup/overlap state, so we ignore init/dialing process.\n", ea_endpoint->ep_serial, e_rule_nesting);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d): we are not in incoming setup/overlap state, so we ignore init/dialing process.\n", ea_endpoint->ep_serial, e_rule_nesting);
e_match_timeout = 0;
goto end;
}
goto process_action;
}
/* check for chan call */
- if (!strncmp(e_dialinginfo.id, "chan:", 5))
+ if (!strncmp(e_dialinginfo.id, "remote:", 7))
{
- e_extdialing = e_dialinginfo.id+4;
- e_action = &action_chan;
+ e_extdialing = e_dialinginfo.id+7;
+ e_action = &action_remote;
goto process_action;
}
/* check for vbox call */
if (e_state!=EPOINT_STATE_IN_SETUP
&& e_state!=EPOINT_STATE_IN_OVERLAP)
{
- PDEBUG(DEBUG_EPOINT, "EPOINT(%d): AFTER init process: we are not in incomming setup/overlap state anymore, so we ignore further dialing process.\n", ea_endpoint->ep_serial, e_rule_nesting);
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d): AFTER init process: we are not in incoming setup/overlap state anymore, so we ignore further dialing process.\n", ea_endpoint->ep_serial, e_rule_nesting);
goto display_action;
}
}
}
if (e_callerinfo.id[0])
- SPRINT(callertext, "%s", numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype));
+ SPRINT(callertext, "%s", numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype, options.national, options.international));
else
SPRINT(callertext, "unknown");
/* allpy restriction */
write_log(e_ext.number, callertext, dialingtext, e_start, e_stop, 0, cause, location);
/* store last received call for reply-list */
+ if (e_origin == 1) // outgoing to phone is incoming for user
if (e_callerinfo.id[0] || e_callerinfo.extension[0])
if (e_ext.anon_ignore || e_callerinfo.present!=INFO_PRESENT_RESTRICTED)
{
if (e_callerinfo.extension[0])
SPRINT(callertext, "intern:%s", e_callerinfo.extension);
else
- SPRINT(callertext, "extern:%s", numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype));
+ SPRINT(callertext, "extern:%s", numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype, options.national, options.international));
if (!!strcmp(callertext, e_ext.last_in[0]))
{
i = MAX_REMEMBER-1;
} else
PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: cannot store last received id '%s' because it is identical with the last one.\n", ea_endpoint->ep_serial, e_ext.number, callertext);
}
- }
+ /* store last made call for reply-list */
+ if (e_origin == 0) // incoming from phone is outgoing for user
+ if (e_dialinginfo.id[0])
+ {
+ if (!!strcmp(e_dialinginfo.id, e_ext.last_out[0]))
+ {
+ i = MAX_REMEMBER-1;
+ while(i)
+ {
+ UCPY(e_ext.last_out[i], e_ext.last_out[i-1]);
+ i--;
+ }
+ SCPY(e_ext.last_out[0], e_dialinginfo.id);
+ writeext |= 1; /* store extension later */
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: storing last number '%s'.\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id);
+ } else
+ PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: cannot store last number '%s' because it is identical with the last one.\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id);
+ }
+ }
/* write extension if needed */
if (writeext == 0x11)
write_extension(&e_ext, e_ext.number);