1 /*****************************************************************************\
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg **
8 ** all actions (and hangup) are processed here **
10 \*****************************************************************************/
14 extern char **environ;
18 * process init 'internal' / 'external' / 'remote' / 'vbox-record' / 'partyline'...
20 void EndpointAppPBX::_action_init_call(char *remote)
23 struct port_list *portlist = ea_endpoint->ep_portlist;
24 struct admin_list *admin;
26 /* a created call, this should never happen */
27 if (ea_endpoint->ep_join_id)
29 if (options.deb & DEBUG_EPOINT)
30 PERROR("EPOINT(%d): We already have a call instance, this should never happen!\n", ea_endpoint->ep_serial);
35 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): Creating new join instance.\n", ea_endpoint->ep_serial);
41 if (admin->remote_name[0] && !strcmp(admin->remote_name, remote))
47 /* resource not available */
48 trace_header("ACTION remote (not available)", DIRECTION_NONE);
49 add_trace("application", NULL, "%s", remote);
51 message_disconnect_port(portlist, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
52 new_state(EPOINT_STATE_OUT_DISCONNECT);
53 set_tone(portlist,"cause_22");
56 join = new JoinRemote(ea_endpoint->ep_serial, remote, admin->sock);
59 join = new JoinPBX(ea_endpoint);
61 FATAL("No memoy for Join instance.\n");
62 ea_endpoint->ep_join_id = join->j_serial;
64 void EndpointAppPBX::action_init_call(void)
66 _action_init_call(NULL);
68 void EndpointAppPBX::action_init_remote(void)
70 struct route_param *rparam;
71 struct port_list *portlist = ea_endpoint->ep_portlist;
72 struct lcr_msg *message;
73 struct capa_info capainfo;
74 struct caller_info callerinfo;
75 struct redir_info redirinfo;
76 struct dialing_info dialinginfo;
77 char context[128] = "";
80 if (!(rparam = routeparam(e_action, PARAM_APPLICATION)))
82 trace_header("ACTION remote (no application given)", DIRECTION_NONE);
84 new_state(EPOINT_STATE_OUT_DISCONNECT);
85 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
86 set_tone(portlist, "cause_3f");
89 SCPY(remote, rparam->string_value);
90 _action_init_call(remote);
92 /* create bearer/caller/dialinginfo */
93 memcpy(&capainfo, &e_capainfo, sizeof(capainfo));
94 memcpy(&callerinfo, &e_callerinfo, sizeof(callerinfo));
95 memcpy(&redirinfo, &e_redirinfo, sizeof(redirinfo));
96 memset(&dialinginfo, 0, sizeof(dialinginfo));
98 if ((rparam = routeparam(e_action, PARAM_CONTEXT)))
100 SCPY(context, rparam->string_value);
102 if ((rparam = routeparam(e_action, PARAM_EXTEN)))
104 SCPY(dialinginfo.id, rparam->string_value);
105 dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
107 /* send setup to remote */
108 trace_header("ACTION remote (setup)", DIRECTION_NONE);
109 add_trace("number", NULL, dialinginfo.id);
110 add_trace("remote", NULL, remote);
112 add_trace("context", NULL, context);
114 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_SETUP);
115 memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
116 memcpy(&message->param.setup.redirinfo, &redirinfo, sizeof(struct redir_info));
117 memcpy(&message->param.setup.callerinfo, &callerinfo, sizeof(struct caller_info));
118 memcpy(&message->param.setup.capainfo, &capainfo, sizeof(struct capa_info));
119 SCPY(message->param.setup.context, context);
120 message_put(message);
124 * process dialing 'internal'
126 void EndpointAppPBX::action_dialing_internal(void)
128 struct capa_info capainfo;
129 struct caller_info callerinfo;
130 struct redir_info redirinfo;
131 struct dialing_info dialinginfo;
132 struct port_list *portlist = ea_endpoint->ep_portlist;
133 struct lcr_msg *message;
134 struct extension ext;
135 struct route_param *rparam;
137 /* send proceeding, because number is complete */
138 set_tone(portlist, "proceeding");
139 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
140 message_put(message);
141 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
142 new_state(EPOINT_STATE_IN_PROCEEDING);
144 /* create bearer/caller/dialinginfo */
145 memcpy(&capainfo, &e_capainfo, sizeof(capainfo));
146 memcpy(&callerinfo, &e_callerinfo, sizeof(callerinfo));
147 memcpy(&redirinfo, &e_redirinfo, sizeof(redirinfo));
148 memset(&dialinginfo, 0, sizeof(dialinginfo));
149 dialinginfo.itype = INFO_ITYPE_ISDN_EXTENSION;
150 SCPY(dialinginfo.id, e_dialinginfo.id);
152 /* process extension */
153 if ((rparam = routeparam(e_action, PARAM_EXTENSION)))
154 SCPY(dialinginfo.id, rparam->string_value);
156 /* process number type */
157 if ((rparam = routeparam(e_action, PARAM_TYPE)))
158 dialinginfo.ntype = rparam->integer_value;
160 /* process service */
161 if ((rparam = routeparam(e_action, PARAM_CAPA)))
163 capainfo.bearer_capa = rparam->integer_value;
164 if (capainfo.bearer_capa != INFO_BC_SPEECH
165 && capainfo.bearer_capa != INFO_BC_AUDIO)
167 capainfo.bearer_mode = INFO_BMODE_PACKET;
169 capainfo.bearer_info1 = INFO_INFO1_NONE;
171 if ((rparam = routeparam(e_action, PARAM_BMODE)))
173 capainfo.bearer_mode = rparam->integer_value;
175 if ((rparam = routeparam(e_action, PARAM_INFO1)))
177 capainfo.bearer_info1 = rparam->integer_value;
179 if ((rparam = routeparam(e_action, PARAM_HLC)))
181 capainfo.hlc = rparam->integer_value;
183 if ((rparam = routeparam(e_action, PARAM_EXTHLC)))
185 capainfo.exthlc = rparam->integer_value;
188 /* process presentation */
189 if ((rparam = routeparam(e_action, PARAM_PRESENT)))
191 callerinfo.present = (rparam->integer_value)?INFO_PRESENT_ALLOWED:INFO_PRESENT_RESTRICTED;
194 /* check if extension exists AND only if not multiple extensions */
195 if (!read_extension(&ext, dialinginfo.id) && !strchr(dialinginfo.id,','))
197 trace_header("ACTION extension (extension doesn't exist)", DIRECTION_NONE);
198 add_trace("extension", NULL, dialinginfo.id);
200 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0, 0);
201 new_state(EPOINT_STATE_OUT_DISCONNECT);
202 message_disconnect_port(portlist, CAUSE_UNALLOCATED, LOCATION_PRIVATE_LOCAL, "");
203 set_tone(portlist, "cause_86");
206 /* check if internal calls are denied */
207 if (e_ext.rights < 1)
209 trace_header("ACTION extension (dialing to extension denied)", DIRECTION_NONE);
210 add_trace("extension", NULL, dialinginfo.id);
212 new_state(EPOINT_STATE_OUT_DISCONNECT);
213 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0, 0);
214 message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
215 set_tone(portlist, "cause_81");
219 /* add or update internal call */
220 trace_header("ACTION extension (calling)", DIRECTION_NONE);
221 add_trace("extension", NULL, dialinginfo.id);
223 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_SETUP);
224 memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
225 memcpy(&message->param.setup.redirinfo, &redirinfo, sizeof(struct redir_info));
226 memcpy(&message->param.setup.callerinfo, &callerinfo, sizeof(struct caller_info));
227 memcpy(&message->param.setup.capainfo, &capainfo, sizeof(struct capa_info));
228 message_put(message);
231 /* process dialing external
233 void EndpointAppPBX::action_dialing_external(void)
235 struct capa_info capainfo;
236 struct caller_info callerinfo;
237 struct redir_info redirinfo;
238 struct dialing_info dialinginfo;
240 struct port_list *portlist = ea_endpoint->ep_portlist;
241 struct lcr_msg *message;
242 struct route_param *rparam;
244 /* special processing of delete characters '*' and '#' */
245 if (e_ext.delete_ext)
247 /* dialing a # causes a clearing of complete number */
248 if (strchr(e_extdialing, '#'))
250 e_extdialing[0] = '\0';
251 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): '#' detected: terminal '%s' selected caller id '%s' and continues dialing: '%s'\n", ea_endpoint->ep_serial, e_ext.number, e_callerinfo.id, e_extdialing);
253 /* eliminate digits before '*', which is a delete digit
255 if (strchr(e_extdialing, '*'))
258 while((p=strchr(e_extdialing, '*')))
260 if (p > e_extdialing) /* only if there is a digit in front */
265 UCPY(p, p+1); /* remove '*' */
267 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s deleted digits and got new string: %s\n", ea_endpoint->ep_serial, e_ext.number, e_extdialing);
271 /* create bearer/caller/dialinginfo */
272 memcpy(&capainfo, &e_capainfo, sizeof(capainfo));
273 memcpy(&callerinfo, &e_callerinfo, sizeof(callerinfo));
274 memcpy(&redirinfo, &e_redirinfo, sizeof(redirinfo));
275 memset(&dialinginfo, 0, sizeof(dialinginfo));
276 dialinginfo.itype = INFO_ITYPE_ISDN;
277 dialinginfo.sending_complete = 0;
278 SCPY(dialinginfo.id, e_extdialing);
281 if ((rparam = routeparam(e_action, PARAM_PREFIX)))
282 SPRINT(dialinginfo.id, "%s%s", rparam->string_value, e_extdialing);
284 /* process number complete */
285 if ((rparam = routeparam(e_action, PARAM_COMPLETE)))
286 if ((rparam = routeparam(e_action, PARAM_PREFIX)))
287 SCPY(dialinginfo.id, rparam->string_value);
288 dialinginfo.sending_complete = 1;
290 /* process number type */
291 if ((rparam = routeparam(e_action, PARAM_TYPE)))
292 dialinginfo.ntype = rparam->integer_value;
294 /* process service */
295 if ((rparam = routeparam(e_action, PARAM_CAPA)))
297 capainfo.bearer_capa = rparam->integer_value;
298 if (capainfo.bearer_capa != INFO_BC_SPEECH
299 && capainfo.bearer_capa != INFO_BC_AUDIO)
301 capainfo.bearer_mode = INFO_BMODE_PACKET;
303 capainfo.bearer_info1 = INFO_INFO1_NONE;
305 if ((rparam = routeparam(e_action, PARAM_BMODE)))
307 capainfo.bearer_mode = rparam->integer_value;
309 if ((rparam = routeparam(e_action, PARAM_INFO1)))
311 capainfo.bearer_info1 = rparam->integer_value;
313 if ((rparam = routeparam(e_action, PARAM_HLC)))
315 capainfo.hlc = rparam->integer_value;
317 if ((rparam = routeparam(e_action, PARAM_EXTHLC)))
319 capainfo.exthlc = rparam->integer_value;
323 /* process callerid */
324 if ((rparam = routeparam(e_action, PARAM_CALLERID)))
326 SCPY(callerinfo.id, rparam->string_value);
328 if ((rparam = routeparam(e_action, PARAM_CALLERIDTYPE)))
330 callerinfo.ntype = rparam->integer_value;
333 /* process presentation */
334 if ((rparam = routeparam(e_action, PARAM_PRESENT)))
336 callerinfo.present = (rparam->integer_value)?INFO_PRESENT_ALLOWED:INFO_PRESENT_RESTRICTED;
339 /* process interfaces */
340 if ((rparam = routeparam(e_action, PARAM_INTERFACES)))
341 SCPY(dialinginfo.interfaces, rparam->string_value);
343 /* check if local calls are denied */
344 if (e_ext.rights < 2)
346 trace_header("ACTION extern (calling denied)", DIRECTION_NONE);
348 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, 0, 0);
349 set_tone(portlist, "cause_82");
351 message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
352 new_state(EPOINT_STATE_OUT_DISCONNECT);
356 if (!strncmp(dialinginfo.id, options.national, strlen(options.national))
357 || dialinginfo.ntype == INFO_NTYPE_NATIONAL
358 || dialinginfo.ntype == INFO_NTYPE_INTERNATIONAL)
360 /* check if national calls are denied */
361 if (e_ext.rights < 3)
363 trace_header("ACTION extern (national calls denied)", DIRECTION_NONE);
365 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, 0, 0);
366 set_tone(portlist, "cause_83");
371 if (!strncmp(dialinginfo.id, options.international, strlen(options.international))
372 || dialinginfo.ntype == INFO_NTYPE_INTERNATIONAL)
374 /* check if international calls are denied */
375 if (e_ext.rights < 4)
377 trace_header("ACTION extern (international calls denied)", DIRECTION_NONE);
379 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_REJECTED, 0, 0);
380 set_tone(portlist, "cause_84");
385 /* add or update outgoing call */
386 trace_header("ACTION extern (calling)", DIRECTION_NONE);
387 add_trace("number", NULL, dialinginfo.id);
388 if (dialinginfo.interfaces[0])
389 add_trace("interfaces", NULL, dialinginfo.interfaces);
391 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_SETUP);
392 memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
393 memcpy(&message->param.setup.redirinfo, &redirinfo, sizeof(struct redir_info));
394 memcpy(&message->param.setup.callerinfo, &callerinfo, sizeof(struct caller_info));
395 memcpy(&message->param.setup.capainfo, &capainfo, sizeof(struct capa_info));
396 message_put(message);
400 void EndpointAppPBX::action_dialing_remote(void)
402 struct lcr_msg *message;
403 struct dialing_info dialinginfo;
404 // struct route_param *rparam;
406 /* create bearer/caller/dialinginfo */
407 memset(&dialinginfo, 0, sizeof(dialinginfo));
409 if (dialinginfo.id[0])
411 /* add or update outgoing call */
412 trace_header("ACTION remote (dialing)", DIRECTION_NONE);
413 add_trace("number", NULL, dialinginfo.id);
415 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_INFORMATION);
416 memcpy(&message->param.information, &dialinginfo, sizeof(struct dialing_info));
417 message_put(message);
423 * process dialing the "am" and record
425 void EndpointAppPBX::action_dialing_vbox_record(void)
427 struct dialing_info dialinginfo;
428 struct port_list *portlist = ea_endpoint->ep_portlist;
429 struct lcr_msg *message;
430 struct extension ext;
431 struct route_param *rparam;
433 portlist = ea_endpoint->ep_portlist;
435 /* check for given extension */
436 if (!(rparam = routeparam(e_action, PARAM_EXTENSION)))
438 trace_header("ACTION vbox-record (no extension given by parameter)", DIRECTION_NONE);
441 new_state(EPOINT_STATE_OUT_DISCONNECT);
442 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
443 set_tone(portlist, "cause_3f");
447 /* check if extension exists */
448 if (!read_extension(&ext, rparam->string_value))
450 trace_header("ACTION vbox-record (given extension does not exists)", DIRECTION_NONE);
451 add_trace("extension", NULL, "%s", rparam->string_value);
453 new_state(EPOINT_STATE_OUT_DISCONNECT);
454 message_disconnect_port(portlist, CAUSE_UNALLOCATED, LOCATION_PRIVATE_LOCAL, "");
455 set_tone(portlist, "cause_86");
459 /* check if internal calls are denied */
460 if (e_ext.rights < 1)
462 trace_header("ACTION vbox-record (internal calls are denied)", DIRECTION_NONE);
464 new_state(EPOINT_STATE_OUT_DISCONNECT);
465 message_disconnect_port(portlist, CAUSE_REJECTED, LOCATION_PRIVATE_LOCAL, "");
466 set_tone(portlist, "cause_81");
470 set_tone(portlist, "proceeding");
471 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
472 message_put(message);
473 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
474 new_state(EPOINT_STATE_IN_PROCEEDING);
476 memset(&dialinginfo, 0, sizeof(dialinginfo));
477 dialinginfo.itype = INFO_ITYPE_VBOX;
478 dialinginfo.sending_complete = 1;
479 SCPY(dialinginfo.id, rparam->string_value);
481 /* append special announcement (if given) */
482 if ((rparam = routeparam(e_action, PARAM_ANNOUNCEMENT)))
483 if (rparam->string_value[0])
485 SCAT(dialinginfo.id, ",");
486 SCAT(dialinginfo.id, rparam->string_value);
489 /* add or update internal call */
490 trace_header("ACTION vbox-record (calling)", DIRECTION_NONE);
491 add_trace("extension", NULL, "%s", dialinginfo.id);
493 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_SETUP);
494 memcpy(&message->param.setup.dialinginfo, &dialinginfo, sizeof(struct dialing_info));
495 memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
496 memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
497 memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
498 message_put(message);
505 void EndpointAppPBX::action_init_partyline(void)
508 class JoinPBX *joinpbx;
509 struct port_list *portlist = ea_endpoint->ep_portlist;
510 struct lcr_msg *message;
511 struct route_param *rparam;
512 int partyline, jingle = 0;
513 struct join_relation *relation;
515 portlist = ea_endpoint->ep_portlist;
517 /* check for given extension */
518 if (!(rparam = routeparam(e_action, PARAM_ROOM)))
520 trace_header("ACTION partyline (no room parameter)", DIRECTION_NONE);
523 new_state(EPOINT_STATE_OUT_DISCONNECT);
524 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
525 set_tone(portlist, "cause_3f");
528 if (rparam->integer_value <= 0)
530 trace_header("ACTION partyline (illegal room parameter)", DIRECTION_NONE);
531 add_trace("room", NULL, "%d", rparam->integer_value);
533 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): invalid value for 'room'.\n", ea_endpoint->ep_serial);
536 partyline = rparam->integer_value;
537 if ((rparam = routeparam(e_action, PARAM_JINGLE)))
540 /* don't create join if partyline exists */
544 if (join->j_type == JOIN_TYPE_PBX)
546 joinpbx = (class JoinPBX *)join;
547 if (joinpbx->j_partyline == partyline)
555 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): Creating new join instance.\n", ea_endpoint->ep_serial);
556 if (!(join = new JoinPBX(ea_endpoint)))
557 FATAL("No memory for join object\n");
560 //NOTE: joinpbx must be set here
561 /* add relation to existing join */
562 if (!(relation=joinpbx->add_relation()))
563 FATAL("No memory for join relation\n");
564 relation->type = RELATION_TYPE_SETUP;
565 relation->channel_state = CHANNEL_STATE_CONNECT;
566 relation->rx_state = NOTIFY_STATE_ACTIVE;
567 relation->tx_state = NOTIFY_STATE_ACTIVE;
568 relation->epoint_id = ea_endpoint->ep_serial;
571 ea_endpoint->ep_join_id = join->j_serial;
573 set_tone(portlist, "proceeding");
574 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
575 message_put(message);
576 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
577 new_state(EPOINT_STATE_IN_PROCEEDING);
579 /* send setup to join */
580 trace_header("ACTION partyline (calling)", DIRECTION_NONE);
581 add_trace("room", NULL, "%d", partyline);
582 add_trace("jingle", NULL, (jingle)?"on":"off");
584 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_join_id, EPOINT_TO_JOIN, MESSAGE_SETUP);
585 message->param.setup.partyline = partyline;
586 message->param.setup.partyline_jingle = jingle;
587 memcpy(&message->param.setup.dialinginfo, &e_dialinginfo, sizeof(struct dialing_info));
588 memcpy(&message->param.setup.redirinfo, &e_redirinfo, sizeof(struct redir_info));
589 memcpy(&message->param.setup.callerinfo, &e_callerinfo, sizeof(struct caller_info));
590 memcpy(&message->param.setup.capainfo, &e_capainfo, sizeof(struct capa_info));
591 message_put(message);
596 * process hangup of all calls
598 void EndpointAppPBX::action_hangup_call(void)
600 trace_header("ACTION hangup", DIRECTION_NONE);
606 * process dialing 'login'
608 void EndpointAppPBX::action_dialing_login(void)
610 struct port_list *portlist = ea_endpoint->ep_portlist;
611 struct lcr_msg *message;
613 struct route_param *rparam;
615 /* extension parameter */
616 if ((rparam = routeparam(e_action, PARAM_EXTENSION)))
618 /* extension is given by parameter */
619 extension = rparam->string_value;
620 if (extension[0] == '\0')
622 if (!read_extension(&e_ext, extension))
624 trace_header("ACTION login (extension doesn't exist)", DIRECTION_NONE);
625 add_trace("extension", NULL, "%s", extension);
627 /* extension doesn't exist */
628 new_state(EPOINT_STATE_OUT_DISCONNECT);
629 message_disconnect_port(portlist, CAUSE_UNALLOCATED, LOCATION_PRIVATE_LOCAL, "");
630 set_tone(portlist, "cause_86");
635 /* extension must be given by dialstring */
636 extension = e_extdialing;
637 if (extension[0] == '\0')
639 if (!read_extension(&e_ext, extension))
641 trace_header("ACTION login (extension incomplete or does not exist)", DIRECTION_NONE);
642 add_trace("extension", NULL, "%s", extension);
648 /* we changed our extension */
649 SCPY(e_ext.number, extension);
650 new_state(EPOINT_STATE_CONNECT);
654 /* send connect with extension's caller id (COLP) */
655 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
656 SCPY(message->param.connectinfo.id, e_ext.callerid);
657 message->param.connectinfo.ntype = e_ext.callerid_type;
658 if (e_ext.callerid_present==INFO_PRESENT_ALLOWED && e_callerinfo.present==INFO_PRESENT_RESTRICTED)
659 message->param.connectinfo.present = INFO_PRESENT_RESTRICTED;
660 else message->param.connectinfo.present = e_ext.callerid_present;
661 /* handle restricted caller ids */
662 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);
663 /* display callerid if desired for extension */
664 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));
665 message->param.connectinfo.ntype = e_ext.callerid_type;
666 message_put(message);
667 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
669 /* set our caller id */
670 SCPY(e_callerinfo.id, e_ext.callerid);
671 e_callerinfo.ntype = e_ext.callerid_type;
672 e_callerinfo.present = e_ext.callerid_present;
674 /* enable connectedmode */
678 if (!(rparam = routeparam(e_action, PARAM_NOPASSWORD)))
680 /* make call state to enter password */
681 trace_header("ACTION login (ask for password)", DIRECTION_NONE);
682 add_trace("extension", NULL, "%s", e_ext.number);
684 new_state(EPOINT_STATE_IN_OVERLAP);
687 e_action = &action_password;
689 e_match_to_action = NULL;
690 e_dialinginfo.id[0] = '\0';
691 e_extdialing = strchr(e_dialinginfo.id, '\0');
694 e_password_timeout = now+20;
700 /* make call state */
701 new_state(EPOINT_STATE_IN_OVERLAP);
702 e_ruleset = ruleset_main;
704 e_rule = e_ruleset->rule_first;
706 e_dialinginfo.id[0] = '\0';
707 e_extdialing = e_dialinginfo.id;
708 set_tone(portlist, "dialpbx");
714 * process init 'change_callerid'
716 void EndpointAppPBX::action_init_change_callerid(void)
718 struct port_list *portlist = ea_endpoint->ep_portlist;
720 if (!e_ext.change_callerid)
722 /* service not available */
723 trace_header("ACTION change-callerid (denied for this caller)", DIRECTION_NONE);
725 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
726 new_state(EPOINT_STATE_OUT_DISCONNECT);
727 set_tone(portlist,"cause_87");
732 /* process dialing callerid
734 void EndpointAppPBX::_action_callerid_calleridnext(int next)
736 struct port_list *portlist = ea_endpoint->ep_portlist;
737 struct route_param *rparam;
738 char buffer[64], *callerid;
739 char old_id[64] = "", new_id[64] = "";
740 int old_type=0, new_type=0, old_present=0, new_present=0;
742 if ((rparam = routeparam(e_action, PARAM_CALLERID)))
744 /* the caller ID is given by parameter */
745 callerid = rparam->string_value;
748 /* caller ID is dialed */
749 if (!strchr(e_extdialing, '#'))
751 /* no complete ID yet */
754 *strchr(e_extdialing, '#') = '\0';
755 callerid = e_extdialing;
758 /* given callerid type */
759 if ((rparam = routeparam(e_action, PARAM_CALLERIDTYPE)))
760 switch(rparam->integer_value)
762 case INFO_NTYPE_SUBSCRIBER:
763 SPRINT(buffer, "s%s", callerid);
766 case INFO_NTYPE_NATIONAL:
767 SPRINT(buffer, "n%s", callerid);
770 case INFO_NTYPE_INTERNATIONAL:
771 SPRINT(buffer, "i%s", callerid);
775 SPRINT(buffer, "%s", callerid);
780 /* caller id complete, dialing with new caller id */
781 /* write new parameters */
782 if (read_extension(&e_ext, e_ext.number))
784 old_present = (!next)?e_ext.callerid_present:e_ext.id_next_call_present;
785 old_type = (!next)?e_ext.callerid_type:e_ext.id_next_call_type;
786 SCPY(old_id, (!next)?e_ext.callerid:e_ext.id_next_call);
787 if (callerid[0] == '\0')
790 (!next)?e_ext.callerid_present:e_ext.id_next_call_present = INFO_PRESENT_RESTRICTED;
794 (!next)?e_ext.callerid_present:e_ext.id_next_call_present = INFO_PRESENT_ALLOWED;
795 if ((rparam = routeparam(e_action, PARAM_PRESENT))) if (rparam->integer_value == 0)
796 (!next)?e_ext.callerid_present:e_ext.id_next_call_present = INFO_PRESENT_RESTRICTED;
797 if (e_ext.callerid_type == INFO_NTYPE_UNKNOWN) /* if callerid is unknown, the given id is not nationalized */
799 SCPY((!next)?e_ext.callerid:e_ext.id_next_call, callerid);
800 (!next)?e_ext.callerid_type:e_ext.id_next_call_type = INFO_NTYPE_UNKNOWN;
803 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));
805 if (!next) e_ext.id_next_call_type = -1;
806 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);
808 new_present = (!next)?e_ext.callerid_present:e_ext.id_next_call_present;
809 new_type = (!next)?e_ext.callerid_type:e_ext.id_next_call_type;
810 SCPY(new_id, (!next)?e_ext.callerid:e_ext.id_next_call);
811 write_extension(&e_ext, e_ext.number);
814 /* function activated */
816 trace_header("ACTION change-callerid (only next call)", DIRECTION_NONE);
818 trace_header("ACTION change-callerid (all future calls)", DIRECTION_NONE);
819 add_trace("old", "caller id", "%s", numberrize_callerinfo(old_id, old_type, options.national, options.international));
820 add_trace("old", "present", "%s", (old_present==INFO_PRESENT_RESTRICTED)?"restricted":"allowed");
821 add_trace("new", "caller id", "%s", numberrize_callerinfo(new_id, new_type, options.national, options.international));
822 add_trace("new", "present", "%s", (new_present==INFO_PRESENT_RESTRICTED)?"restricted":"allowed");
824 message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
825 new_state(EPOINT_STATE_OUT_DISCONNECT);
826 set_tone(portlist,"activated");
829 /* process dialing callerid for all call
831 void EndpointAppPBX::action_dialing_callerid(void)
833 _action_callerid_calleridnext(0);
836 /* process dialing callerid for next call
838 void EndpointAppPBX::action_dialing_calleridnext(void)
840 _action_callerid_calleridnext(1);
845 * process init 'change_forward'
847 void EndpointAppPBX::action_init_change_forward(void)
849 struct port_list *portlist = ea_endpoint->ep_portlist;
851 if (!e_ext.change_forward)
853 trace_header("ACTION change-forward (denied for this caller)", DIRECTION_NONE);
855 /* service not available */
856 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
857 new_state(EPOINT_STATE_OUT_DISCONNECT);
858 set_tone(portlist,"cause_87");
863 /* process dialing forwarding
865 void EndpointAppPBX::action_dialing_forward(void)
867 struct port_list *portlist = ea_endpoint->ep_portlist;
868 int diversion = INFO_DIVERSION_CFU;
869 char *dest = e_extdialing;
870 struct route_param *rparam;
872 /* if diversion type is given */
873 if ((rparam = routeparam(e_action, PARAM_DIVERSION)))
874 diversion = rparam->integer_value;
876 if ((rparam = routeparam(e_action, PARAM_DEST)))
878 /* if destination is given */
879 dest = rparam->string_value;
882 if (!strchr(e_extdialing, '#'))
884 *strchr(e_extdialing, '#') = '\0';
888 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: storing forwarding to '%s'.\n", ea_endpoint->ep_serial, e_ext.number, dest);
889 if (read_extension(&e_ext, e_ext.number))
893 case INFO_DIVERSION_CFU:
894 trace_header("ACTION change-forward (new CFU=unconditional)", DIRECTION_NONE);
895 add_trace("destin'", NULL, "%s", dest);
897 SCPY(e_ext.cfu, dest);
899 case INFO_DIVERSION_CFB:
900 trace_header("ACTION change-forward (new CFB=busy)", DIRECTION_NONE);
901 add_trace("destin'", NULL, "%s", dest);
903 SCPY(e_ext.cfb, dest);
905 case INFO_DIVERSION_CFNR:
906 if ((rparam = routeparam(e_action, PARAM_DELAY)))
907 e_ext.cfnr_delay = rparam->integer_value;
908 trace_header("ACTION change-forward (new CFNR=no response)", DIRECTION_NONE);
909 add_trace("destin'", NULL, "%s", dest);
910 add_trace("delay", NULL, "%s", e_ext.cfnr_delay);
912 SCPY(e_ext.cfnr, dest);
914 case INFO_DIVERSION_CFP:
915 trace_header("ACTION change-forward (new CFP=parallel)", DIRECTION_NONE);
916 add_trace("destin'", NULL, "%s", dest);
918 SCPY(e_ext.cfp, dest);
921 write_extension(&e_ext, e_ext.number);
923 /* function (de)activated */
924 message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
925 new_state(EPOINT_STATE_OUT_DISCONNECT);
927 set_tone(portlist,"activated");
929 set_tone(portlist,"deactivated");
933 /* process dialing redial
935 void EndpointAppPBX::action_init_redial_reply(void)
937 struct port_list *portlist = ea_endpoint->ep_portlist;
940 if (!e_ext.last_out[0])
942 trace_header("ACTION redial/reply (no last number stored)", DIRECTION_NONE);
944 new_state(EPOINT_STATE_OUT_DISCONNECT);
945 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
946 set_tone(portlist, "cause_3f");
951 /* process dialing redial
953 void EndpointAppPBX::_action_redial_reply(int in)
955 struct lcr_msg *message;
957 struct route_param *rparam;
959 last = (in)?e_ext.last_in[0]:e_ext.last_out[0];
961 /* if no display is available */
962 if (!e_ext.display_menu)
964 if (ea_endpoint->ep_portlist->port_type!=PORT_TYPE_DSS1_NT_IN && ea_endpoint->ep_portlist->port_type!=PORT_TYPE_DSS1_NT_OUT)
967 /* if select is not given */
968 if (!(rparam = routeparam(e_action, PARAM_SELECT)))
972 if (e_extdialing[0]=='*' || e_extdialing[0]=='1')
974 /* find prev entry */
980 if (e_extdialing[0]=='#' || e_extdialing[0]=='3')
982 /* find next entry */
984 if (e_select >= MAX_REMEMBER)
987 if (e_ext.last_in[e_select][0] == '\0')
990 if (e_ext.last_out[e_select][0] == '\0')
995 last = (in)?e_ext.last_in[e_select]:e_ext.last_out[e_select];
996 if (e_extdialing[0]=='0' || e_extdialing[0]=='2')
1000 trace_header("ACTION reply (dialing)", DIRECTION_NONE);
1002 trace_header("ACTION redial (dialing)", DIRECTION_NONE);
1003 add_trace("number", NULL, "%s", last);
1004 add_trace("last but", NULL, "%d", e_select);
1006 SCPY(e_dialinginfo.id, last);
1007 e_extdialing = e_dialinginfo.id;
1012 e_extdialing[0] = '\0';
1014 /* send display message to port */
1015 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
1016 if (!strncmp(last, "extern:", 7))
1017 SPRINT(message->param.notifyinfo.display, "(%d) %s ext", e_select+1, last+7);
1019 if (!strncmp(last, "intern:", 7))
1020 SPRINT(message->param.notifyinfo.display, "(%d) %s int", e_select+1, last+7);
1022 if (!strncmp(last, "chan:", 4))
1023 SPRINT(message->param.notifyinfo.display, "(%d) %s chan", e_select+1, last+5);
1025 if (!strncmp(last, "vbox:", 5))
1026 SPRINT(message->param.notifyinfo.display, "(%d) %s vbox", e_select+1, last+5);
1028 SPRINT(message->param.notifyinfo.display, "(%d) %s", e_select+1, (last[0])?last:"- empty -");
1029 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s sending display:%s\n", ea_endpoint->ep_serial, e_ext.number, message->param.notifyinfo.display);
1030 message_put(message);
1031 logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
1034 /* process dialing redial
1036 void EndpointAppPBX::action_dialing_redial(void)
1038 _action_redial_reply(0);
1041 /* process dialing reply
1043 void EndpointAppPBX::action_dialing_reply(void)
1045 _action_redial_reply(1);
1049 /* dialing powerdialing delay
1051 void EndpointAppPBX::action_dialing_powerdial(void)
1053 struct port_list *portlist = ea_endpoint->ep_portlist;
1054 struct lcr_msg *message;
1055 struct route_param *rparam;
1057 /* power dialing only possible if we have a last dialed number */
1058 if (!e_ext.last_out[0])
1060 trace_header("ACTION powerdial (no last number stored)", DIRECTION_NONE);
1062 new_state(EPOINT_STATE_OUT_DISCONNECT);
1063 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
1064 set_tone(portlist, "cause_3f");
1069 if ((rparam = routeparam(e_action, PARAM_LIMIT)))
1071 e_powerlimit = rparam->integer_value;
1078 if ((rparam = routeparam(e_action, PARAM_DELAY)))
1080 e_powerdelay = rparam->integer_value;
1083 /* delay incomplete */
1084 if (!strchr(e_extdialing, '#'))
1086 *strchr(e_extdialing, '#') = '\0';
1087 e_powerdelay = e_extdialing[0]?atoi(e_extdialing): 0;
1090 if (e_powerdelay < 1)
1092 trace_header("ACTION powerdial (dialing)", DIRECTION_NONE);
1093 add_trace("number", NULL, "%s", e_ext.last_out[0]);
1094 add_trace("delay", NULL, "%d", e_powerdelay);
1097 /* send connect to avoid overlap timeout */
1098 // new_state(EPOINT_STATE_CONNECT); connect may prevent further dialing
1099 if (e_ext.number[0])
1101 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
1102 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
1103 message_put(message);
1104 logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
1107 SCPY(e_dialinginfo.id, e_ext.last_out[0]);
1108 e_powerdialing = -1; /* indicates the existence of powerdialing but no redial time given */
1117 void EndpointAppPBX::action_dialing_callback(void)
1119 struct port_list *portlist = ea_endpoint->ep_portlist;
1120 struct route_param *rparam;
1121 struct extension cbext;
1123 portlist = ea_endpoint->ep_portlist;
1125 /* check given extension */
1126 if (!(rparam = routeparam(e_action, PARAM_EXTENSION)))
1129 trace_header("ACTION callback (no extension defined)", DIRECTION_NONE);
1133 new_state(EPOINT_STATE_OUT_DISCONNECT);
1134 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
1135 set_tone(portlist, "cause_3f");
1137 e_cbcaller[0] = e_cbdialing[0] = '\0';
1141 /* if extension is given */
1142 SCPY(e_cbcaller, rparam->string_value);
1143 if (e_cbcaller[0] == '\0')
1146 /* read callback extension */
1147 memset(&cbext, 0, sizeof(cbext));
1148 if (!read_extension(&cbext, e_cbcaller))
1150 trace_header("ACTION callback (extension doesn't exist)", DIRECTION_NONE);
1151 add_trace("extension", NULL, "%s", e_cbcaller);
1156 /* if password is not given */
1157 if (cbext.password[0] == '\0')
1159 trace_header("ACTION callback (no password set)", DIRECTION_NONE);
1160 add_trace("extension", NULL, "%s", e_cbcaller);
1165 /* callback only possible if callerid exists OR it is given */
1166 if ((rparam = routeparam(e_action, PARAM_CALLTO)))
1167 SCPY(e_cbto, rparam->string_value);
1170 trace_header("ACTION callback (alternative caller id)", DIRECTION_NONE);
1171 add_trace("extension", NULL, "%s", e_cbcaller);
1172 add_trace("callerid", NULL, "%s", e_cbto);
1174 SCPY(e_callerinfo.id, e_cbto);
1175 e_callerinfo.ntype = INFO_NTYPE_UNKNOWN;
1176 e_callerinfo.present = INFO_PRESENT_ALLOWED;
1178 if (e_callerinfo.id[0]=='\0' || e_callerinfo.present==INFO_PRESENT_NOTAVAIL)
1180 trace_header("ACTION callback (no caller ID available)", DIRECTION_NONE);
1181 add_trace("extension", NULL, "%s", e_cbcaller);
1186 e_callerinfo.present = INFO_PRESENT_ALLOWED;
1191 * process hangup 'callback'
1193 void EndpointAppPBX::action_hangup_callback(void)
1195 struct route_param *rparam;
1199 delay = 2; /* default value */
1200 if ((rparam = routeparam(e_action, PARAM_DELAY)))
1201 if (rparam->integer_value>0)
1202 delay = rparam->integer_value;
1204 /* dialing after callback */
1205 if ((rparam = routeparam(e_action, PARAM_PREFIX)))
1206 SCPY(e_cbdialing, rparam->string_value);
1208 SCPY(e_cbdialing, e_extdialing);
1210 trace_header("ACTION callback (dialing)", DIRECTION_NONE);
1211 add_trace("extension", NULL, "%s", e_cbcaller);
1212 add_trace("caller id", NULL, "%s", e_callerinfo.id);
1213 add_trace("delay", NULL, "%d", delay);
1214 add_trace("dialing", NULL, "%s", e_cbdialing);
1217 /* set time to callback */
1218 e_callback = now_d + delay;
1223 * dialing action abbreviation
1225 void EndpointAppPBX::action_dialing_abbrev(void)
1227 struct port_list *portlist = ea_endpoint->ep_portlist;
1228 char *abbrev, *phone, *name;
1231 portlist = ea_endpoint->ep_portlist;
1233 /* abbrev dialing is only possible if we have a caller defined */
1234 if (!e_ext.number[0])
1236 trace_header("ACTION abbreviation (only for extension)", DIRECTION_NONE);
1238 new_state(EPOINT_STATE_OUT_DISCONNECT);
1239 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
1240 set_tone(portlist, "cause_3f");
1244 /* check abbreviation */
1245 abbrev = e_extdialing;
1248 result = parse_phonebook(e_ext.number, &abbrev, &phone, &name);
1251 trace_header("ACTION abbreviation (not found)", DIRECTION_NONE);
1252 add_trace("abbrev", NULL, "%s", abbrev);
1254 new_state(EPOINT_STATE_OUT_DISCONNECT);
1255 message_disconnect_port(portlist, CAUSE_UNALLOCATED, LOCATION_PRIVATE_LOCAL, "");
1256 set_tone(portlist, "cause_01");
1259 if (result == -1) /* may match if more digits are dialed */
1264 /* dial abbreviation */
1265 trace_header("ACTION abbreviation (dialing)", DIRECTION_NONE);
1266 add_trace("abbrev", NULL, "%s", abbrev);
1267 add_trace("number", NULL, "%s", phone);
1268 if (name) if (name[0])
1269 add_trace("name", NULL, "%s", name);
1271 SCPY(e_dialinginfo.id, phone);
1272 e_extdialing = e_dialinginfo.id;
1278 /* process dialing 'test'
1280 void EndpointAppPBX::action_dialing_test(void)
1284 struct port_list *portlist = ea_endpoint->ep_portlist;
1285 struct lcr_msg *message;
1287 char testcode[32] = "";
1288 struct route_param *rparam;
1290 /* given testcode */
1291 if ((rparam = routeparam(e_action, PARAM_PREFIX)))
1292 SCPY(testcode, rparam->string_value);
1293 SCAT(testcode, e_extdialing);
1298 trace_header("ACTION test", DIRECTION_NONE);
1299 add_trace("test", NULL, "proceeding");
1301 new_state(EPOINT_STATE_IN_PROCEEDING);
1302 set_tone(portlist, "proceeding");
1303 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
1304 message_put(message);
1305 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1309 trace_header("ACTION test", DIRECTION_NONE);
1310 add_trace("test", NULL, "alerting");
1312 new_state(EPOINT_STATE_IN_ALERTING);
1313 set_tone(portlist, "ringpbx");
1314 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_ALERTING);
1315 message_put(message);
1316 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1320 trace_header("ACTION test", DIRECTION_NONE);
1321 add_trace("test", NULL, "echo");
1323 new_state(EPOINT_STATE_CONNECT);
1324 if (e_ext.number[0])
1326 set_tone(portlist, NULL);
1327 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
1328 SCPY(e_connectinfo.id, e_callerinfo.id);
1329 SCPY(e_connectinfo.extension, e_callerinfo.extension);
1330 e_connectinfo.itype = e_callerinfo.itype;
1331 e_connectinfo.ntype = e_callerinfo.ntype;
1332 e_connectinfo.present = e_callerinfo.present;
1333 e_connectinfo.screen = e_callerinfo.screen;
1334 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
1335 memcpy(&message->param.connectinfo, &e_connectinfo, sizeof(struct connect_info));
1336 /* handle restricted caller ids */
1337 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);
1338 /* display callerid if desired for extension */
1339 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));
1340 message_put(message);
1341 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1343 port = find_port_id(portlist->port_id);
1346 port->set_echotest(1);
1351 trace_header("ACTION test", DIRECTION_NONE);
1352 add_trace("test", NULL, "tone");
1354 new_state(EPOINT_STATE_CONNECT);
1355 if (e_ext.number[0])
1357 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
1358 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
1359 message_put(message);
1360 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1361 set_tone(portlist, "test");
1365 trace_header("ACTION test", DIRECTION_NONE);
1366 add_trace("test", NULL, "hold music");
1368 new_state(EPOINT_STATE_CONNECT);
1369 if (e_ext.number[0])
1371 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
1372 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
1373 message_put(message);
1374 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1375 set_tone(portlist, "hold");
1379 if (strlen(testcode) < 4)
1382 cause = atoi(testcode+1);
1385 trace_header("ACTION test", DIRECTION_NONE);
1386 add_trace("test", NULL, "announcement");
1387 add_trace("cause", NULL, "%d", cause);
1389 new_state(EPOINT_STATE_CONNECT);
1390 if (e_ext.number[0])
1392 SPRINT(causestr,"cause_%02x",cause);
1393 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
1394 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
1395 message_put(message);
1396 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1397 set_tone(portlist, causestr);
1401 if (strlen(testcode) < 4)
1404 cause = atoi(testcode+1);
1407 trace_header("ACTION test", DIRECTION_NONE);
1408 add_trace("test", NULL, "disconnect");
1409 add_trace("cause", NULL, "%d", cause);
1411 new_state(EPOINT_STATE_OUT_DISCONNECT);
1412 SPRINT(causestr,"cause_%02x",cause);
1413 message_disconnect_port(portlist, cause, LOCATION_PRIVATE_LOCAL, "");
1414 set_tone(portlist, causestr);
1417 case '8': /* release */
1418 trace_header("ACTION test", DIRECTION_NONE);
1419 add_trace("test", NULL, "release");
1420 add_trace("cause", NULL, "16");
1422 new_state(EPOINT_STATE_OUT_DISCONNECT);
1423 message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
1424 set_tone(portlist, "release");
1427 case '9': /* text callerid test */
1428 trace_header("ACTION test", DIRECTION_NONE);
1429 add_trace("test", NULL, "callerid");
1431 new_state(EPOINT_STATE_CONNECT);
1432 if (e_ext.number[0])
1434 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
1435 SCPY(e_connectinfo.id, "12345678");
1436 SCPY(e_connectinfo.name, "Welcome to LCR");
1437 SCPY(e_connectinfo.display, "Welcome to LCR");
1438 e_connectinfo.ntype = INFO_NTYPE_UNKNOWN;
1439 e_connectinfo.present = INFO_PRESENT_ALLOWED;
1440 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
1441 memcpy(&message->param.connectinfo, &e_connectinfo, sizeof(message->param.connectinfo));
1442 message_put(message);
1443 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1444 set_tone(portlist, "hold");
1450 /* process init play
1452 void EndpointAppPBX::action_init_play(void)
1454 struct route_param *rparam;
1455 struct port_list *portlist = ea_endpoint->ep_portlist;
1457 /* check given sample */
1458 if (!(rparam = routeparam(e_action, PARAM_SAMPLE)))
1460 trace_header("ACTION play (no sample given)", DIRECTION_NONE);
1464 new_state(EPOINT_STATE_OUT_DISCONNECT);
1465 message_disconnect_port(portlist, CAUSE_UNSPECIFIED, LOCATION_PRIVATE_LOCAL, "");
1466 set_tone(portlist, "cause_3f");
1471 /* if sample is given */
1472 if (rparam->string_value[0] == '\0')
1474 trace_header("ACTION play (no sample given)", DIRECTION_NONE);
1479 if (e_ext.number[0])
1482 set_tone(ea_endpoint->ep_portlist, rparam->string_value);
1487 * action_*_vbox_play is implemented in "action_vbox.cpp"
1492 * process dialing of calculator
1494 void EndpointAppPBX::action_dialing_calculator(void)
1496 struct port_list *portlist = ea_endpoint->ep_portlist;
1497 struct lcr_msg *message;
1498 double value1, value2, v, sign1;
1499 int komma1, komma2, k, state, mode, first;
1502 portlist = ea_endpoint->ep_portlist;
1504 /* remove error message */
1505 if (!strncmp(e_extdialing, "Error", 5))
1507 UCPY(e_extdialing, e_extdialing+5);
1509 if (!strncmp(e_extdialing, "inf", 3))
1511 UCPY(e_extdialing, e_extdialing+3);
1513 if (!strncmp(e_extdialing, "-inf", 4))
1515 UCPY(e_extdialing, e_extdialing+4);
1518 /* process dialing */
1531 if (*p>='0' && *p<='9')
1539 if ((p[-1]<'0' || p[-1]>'0') && p[-1]!='.')
1548 case 0: /* first number */
1551 value1 = value1*10 + (*p-'0');
1561 case 1: /* second number */
1564 value2 = value2*10 + (*p-'0');
1581 UCPY(e_extdialing, "Error");
1584 /* if there is a multiplication, we change to / */
1593 /* if there is a division, we change to + */
1602 /* if there is a addition, we change to - */
1611 /* if there is a substraction and a comma, we change to * */
1612 if (p[-1]=='-' && komma1)
1620 /* if there is a substraction and no comma and the first or second value, we change to , */
1629 /* if there is a komma and we are at the first value, we change to * */
1630 if (p[-1]=='.' && state==0)
1639 /* if there is a komma and we are at the second value, we display error */
1640 if (komma2 && state==1)
1642 UCPY(e_extdialing, "Error");
1645 /* if we are at state 1, we write a comma */
1652 /* we assume multiplication */
1659 /* if just a number is displayed, the input is cleared */
1662 *e_extdialing = '\0';
1665 /* calculate the result */
1668 case 0: /* multiply */
1669 UNPRINT(e_extdialing, sizeof(e_dialinginfo.id)-strlen(e_dialinginfo.id), "%.8f", sign1*value1*value2);
1671 case 1: /* divide */
1672 UNPRINT(e_extdialing, sizeof(e_dialinginfo.id)-strlen(e_dialinginfo.id), "%.8f", sign1*value1/value2);
1675 UNPRINT(e_extdialing, sizeof(e_dialinginfo.id)-strlen(e_dialinginfo.id), "%.8f", sign1*value1+value2);
1677 case 3: /* substract */
1678 UNPRINT(e_extdialing, sizeof(e_dialinginfo.id)-strlen(e_dialinginfo.id), "%.8f", sign1*value1-value2);
1681 e_dialinginfo.id[sizeof(e_dialinginfo.id)-1] = '\0';
1682 if (strchr(e_extdialing, '.')) /* remove zeroes */
1684 while (e_extdialing[strlen(e_extdialing)-1] == '0')
1685 e_extdialing[strlen(e_extdialing)-1] = '\0';
1686 if (e_extdialing[strlen(e_extdialing)-1] == '.')
1687 e_extdialing[strlen(e_extdialing)-1] = '\0'; /* and remove dot */
1689 p = strchr(e_extdialing,'\0')-1;
1722 UCPY(e_extdialing, "Error");
1731 /* display dialing */
1732 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
1733 SPRINT(message->param.notifyinfo.display, ">%s", e_extdialing);
1734 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s displaying interpreted dialing '%s' internal values: %f %f\n", ea_endpoint->ep_serial, e_ext.number, e_extdialing, value1, value2);
1735 message_put(message);
1736 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
1741 * process dialing of timer
1743 void EndpointAppPBX::action_dialing_timer(void)
1749 * process 'goto' or 'menu'
1751 void EndpointAppPBX::_action_goto_menu(int mode)
1753 struct port_list *portlist = ea_endpoint->ep_portlist;
1754 struct route_param *rparam;
1756 /* check given ruleset */
1757 if (!(rparam = routeparam(e_action, PARAM_RULESET)))
1760 trace_header("ACTION goto/menu (no ruleset given)", DIRECTION_NONE);
1764 new_state(EPOINT_STATE_OUT_DISCONNECT);
1765 message_disconnect_port(portlist, CAUSE_SERVICEUNAVAIL, LOCATION_PRIVATE_LOCAL, "");
1766 set_tone(portlist, "cause_3f");
1770 if (rparam->string_value[0] == '\0')
1772 e_ruleset = getrulesetbyname(rparam->string_value);
1775 trace_header("ACTION goto/menu (ruleset not found)", DIRECTION_NONE);
1776 add_trace("ruleset", NULL, "%s", rparam->string_value);
1781 /* if the 'menu' was selected, we will flush all digits */
1784 e_dialinginfo.id[0] = 0;
1785 e_extdialing = e_dialinginfo.id;
1788 /* remove digits that are required to match the rule */
1789 if ((rparam = routeparam(e_action, PARAM_STRIP)))
1792 SCPY(e_dialinginfo.id, e_extdialing);
1793 e_extdialing = e_dialinginfo.id;
1798 trace_header("ACTION goto/menu (change to)", DIRECTION_NONE);
1799 add_trace("ruleset", NULL, "%s", e_ruleset->name);
1800 if (e_dialinginfo.id[0])
1802 add_trace("dialing", NULL, "%s", e_dialinginfo.id);
1804 if ((rparam = routeparam(e_action, PARAM_SAMPLE)))
1806 add_trace("sample", NULL, "%s", rparam->string_value);
1808 set_tone(ea_endpoint->ep_portlist, rparam->string_value);
1814 /* do dialing with new ruleset */
1819 /* process dialing goto
1821 void EndpointAppPBX::action_dialing_goto(void)
1823 _action_goto_menu(0);
1826 /* process dialing menu
1828 void EndpointAppPBX::action_dialing_menu(void)
1830 _action_goto_menu(1);
1835 * process dialing disconnect
1837 void EndpointAppPBX::action_dialing_disconnect(void)
1839 struct route_param *rparam;
1840 struct port_list *portlist = ea_endpoint->ep_portlist;
1841 struct lcr_msg *message;
1842 int cause = CAUSE_NORMAL; /* normal call clearing */
1843 int location = LOCATION_PRIVATE_LOCAL;
1844 char cause_string[256] = "", display[84] = "";
1846 /* check cause parameter */
1847 if ((rparam = routeparam(e_action, PARAM_CAUSE)))
1849 cause = rparam->integer_value;
1850 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): 'cause' is given: %d\n", ea_endpoint->ep_serial, cause);
1852 if ((rparam = routeparam(e_action, PARAM_LOCATION)))
1854 location = rparam->integer_value;
1855 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): 'location' is given: %d\n", ea_endpoint->ep_serial, location);
1859 /* use cause as sample, if not given later */
1860 SPRINT(cause_string, "cause_%02x", cause);
1862 /* check sample parameter */
1863 if ((rparam = routeparam(e_action, PARAM_SAMPLE)))
1865 SCPY(cause_string, rparam->string_value);
1866 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): 'sample' is given: %s\n", ea_endpoint->ep_serial, cause_string);
1870 if ((rparam = routeparam(e_action, PARAM_DISPLAY)))
1872 SCPY(display, rparam->string_value);
1873 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): 'display' is given: %s\n", ea_endpoint->ep_serial, display);
1876 /* disconnect only if connect parameter is not given */
1877 trace_header("ACTION disconnect", DIRECTION_NONE);
1878 add_trace("cause", "value", "%d", cause);
1879 add_trace("cause", "location", "%d", location);
1880 if (cause_string[0])
1881 add_trace("sample", NULL, "%s", cause_string);
1883 add_trace("display", NULL, "%s", display);
1885 new_state(EPOINT_STATE_OUT_DISCONNECT);
1886 set_tone(portlist, cause_string);
1887 if (!(rparam = routeparam(e_action, PARAM_CONNECT)))
1889 message_disconnect_port(portlist, cause, location, display);
1892 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
1893 SCPY(message->param.notifyinfo.display, display);
1894 message_put(message);
1895 logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
1902 * process dialing help
1904 void EndpointAppPBX::action_dialing_help(void)
1906 /* show all things that would match */
1908 struct numbering *numbering = numbering_int;
1909 char dialing[sizeof(e_dialinginfo.id)];
1911 struct lcr_msg *message;
1912 struct route_param *rparam;
1914 /* in case we have no menu (this should never happen) */
1919 if (strchr(e_dialinginfo.id,'*'))
1922 e_dialinginfo.id[0] = '\0';
1924 if (strchr(e_dialinginfo.id,'#'))
1927 e_dialinginfo.id[0] = '\0';
1930 /* get position in menu */
1933 /* get last menu position */
1935 while(numbering->next)
1938 numbering = numbering->next;
1942 /* get menu position */
1946 numbering = numbering->next;
1950 numbering = numbering_int;
1957 /* if we dial something else we need to add the prefix and change the action */
1958 if (e_dialinginfo.id[0])
1960 e_action = NUMB_ACTION_NONE;
1961 SCPY(dialing, numbering->prefix);
1962 //we ignore the first digit after selecting
1963 //SCAT(dialing, e_dialinginfo.id);
1964 SCPY(e_dialinginfo.id, dialing);
1965 e_extdialing = e_dialinginfo.id+strlen(numbering->prefix);
1966 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s selected a new menu '%s' dialing: %s\n", ea_endpoint->ep_serial, e_ext.number, numb_actions[numbering->action], e_dialinginfo.id);
1972 /* send display message to port */
1973 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
1974 SPRINT(message->param.notifyinfo.display, ">%s %s%s%s", numbering->prefix, numb_actions[numbering->action], (numbering->param[0])?" ":"", numbering->param);
1975 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s selected a new menu '%s' sending display:%s\n", ea_endpoint->ep_serial, e_ext.number, numb_actions[numbering->action], message->param.notifyinfo.display);
1976 message_put(message);
1977 logmessage(message->type, message->paramea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
1983 * process dialing deflect
1985 void EndpointAppPBX::action_dialing_deflect(void)
1991 * process dialing setforward
1993 void EndpointAppPBX::action_dialing_setforward(void)
1999 * process hangup 'execute'
2001 void EndpointAppPBX::action_hangup_execute(void)
2003 struct route_param *rparam;
2005 char *command = "", isdn_port[10];
2006 char *argv[11]; /* check also number of args below */
2009 /* get script / command */
2010 if ((rparam = routeparam(e_action, PARAM_EXECUTE)))
2011 command = rparam->string_value;
2012 if (command[0] == '\0')
2014 trace_header("ACTION execute (no parameter given)", DIRECTION_NONE);
2018 argv[i++] = "/bin/sh";
2020 argv[i++] = command;
2021 argv[i++] = command;
2022 if ((rparam = routeparam(e_action, PARAM_PARAM)))
2024 argv[i++] = rparam->string_value;
2026 argv[i++] = e_extdialing;
2027 argv[i++] = numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype, options.national, options.international);
2028 argv[i++] = e_callerinfo.extension;
2029 argv[i++] = e_callerinfo.name;
2030 SPRINT(isdn_port, "%d", e_callerinfo.isdn_port);
2031 argv[i++] = isdn_port;
2032 argv[i++] = NULL; /* check also number of args above */
2033 switch (pid = fork ()) {
2035 trace_header("ACTION execute (fork failed)", DIRECTION_NONE);
2039 execve("/bin/sh", argv, environ);
2042 trace_header("ACTION execute", DIRECTION_NONE);
2043 add_trace("command", NULL, "%s", command);
2051 * process hangup 'file'
2053 void EndpointAppPBX::action_hangup_file(void)
2055 struct route_param *rparam;
2056 char *file, *content, *mode;
2059 /* get file / content */
2060 if (!(rparam = routeparam(e_action, PARAM_FILE)))
2061 file = rparam->string_value;
2064 if (!(rparam = routeparam(e_action, PARAM_CONTENT)))
2065 content = rparam->string_value;
2067 content = e_extdialing;
2068 if (!(rparam = routeparam(e_action, PARAM_APPEND)))
2072 if (file[0] == '\0')
2074 trace_header("ACTION file (no filename given)", DIRECTION_NONE);
2078 if (!(fp = fopen(file, mode)))
2080 trace_header("ACTION file (failed to open)", DIRECTION_NONE);
2081 add_trace("file", "name", "%s", file);
2082 add_trace("file", "mode", "%s", (mode[0]=='w')?"write":"append");
2086 trace_header("ACTION file", DIRECTION_NONE);
2087 add_trace("file", "name", "%s", file);
2088 add_trace("file", "mode", "%s", (mode[0]=='w')?"write":"append");
2089 add_trace("content", NULL, "%s", content);
2091 fprintf(fp, "%s\n", content);
2097 * process init 'pick'
2099 void EndpointAppPBX::action_init_pick(void)
2101 struct route_param *rparam;
2102 char *extensions = NULL;
2104 if ((rparam = routeparam(e_action, PARAM_EXTENSIONS)))
2105 extensions = rparam->string_value;
2107 trace_header("ACTION pick", DIRECTION_NONE);
2108 if (extensions) if (extensions[0])
2109 add_trace("extensions", NULL, "%s", extensions);
2111 pick_join(extensions);
2116 * process dialing 'password'
2118 void EndpointAppPBX::action_dialing_password(void)
2120 struct port_list *portlist = ea_endpoint->ep_portlist;
2122 /* prompt for password */
2123 if (e_extdialing[0] == '\0')
2125 /* give password tone */
2126 set_tone(portlist, "password");
2128 if (e_extdialing[1] == '\0')
2130 /* give password tone */
2131 set_tone(portlist, "dialing");
2134 /* wait until all digits are dialed */
2135 if (strlen(e_ext.password) != strlen(e_extdialing))
2136 return; /* more digits needed */
2138 /* check the password */
2139 if (e_ext.password[0]=='\0' || (strlen(e_ext.password)==strlen(e_extdialing) && !!strcmp(e_ext.password,e_extdialing)))
2141 trace_header("ACTION password_write (wrong password)", DIRECTION_NONE);
2142 add_trace("dialed", NULL, "%s", e_extdialing);
2144 e_connectedmode = 0;
2146 new_state(EPOINT_STATE_OUT_DISCONNECT);
2147 message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
2148 set_tone(portlist, "cause_10");
2152 /* write caller id if ACTION_PASSWORD_WRITE was selected */
2154 if (e_action->index == ACTION_PASSWORD_WRITE)
2156 append_callbackauth(e_ext.number, &e_callbackinfo);
2157 trace_header("ACTION password_write (written)", DIRECTION_NONE);
2158 add_trace("dialed", NULL, "%s", e_extdialing);
2162 /* make call state */
2163 new_state(EPOINT_STATE_IN_OVERLAP);
2164 e_ruleset = ruleset_main;
2166 e_rule = e_ruleset->rule_first;
2168 e_dialinginfo.id[0] = '\0';
2169 e_extdialing = e_dialinginfo.id;
2170 set_tone(portlist, "dialpbx");
2173 void EndpointAppPBX::action_dialing_password_wr(void)
2175 action_dialing_password();
2179 /* general process dialing of incoming call
2180 * depending on the detected prefix, subfunctions above (action_*) will be
2183 void EndpointAppPBX::process_dialing(void)
2185 struct port_list *portlist = ea_endpoint->ep_portlist;
2186 struct lcr_msg *message;
2187 struct route_param *rparam;
2189 //#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.
2190 //PDEBUG(~0, "HANG-BUG-DEBUGGING: entered porcess_dialing\n");
2191 portlist = ea_endpoint->ep_portlist;
2192 /* check if we have a port instance linked to our epoint */
2196 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): note: dialing call requires exactly one port object to process dialing. this case could happen due to a parked call. we end dialing here.\n", ea_endpoint->ep_serial, e_ext.number);
2197 e_action_timeout = 0;
2198 e_match_timeout = 0;
2203 goto portlist_error;
2206 /* check nesting levels */
2207 if (++e_rule_nesting > RULE_NESTING)
2209 trace_header("ACTION (nesting too deep)", DIRECTION_NONE);
2210 add_trace("max-levels", NULL, "%d", RULE_NESTING);
2212 new_state(EPOINT_STATE_OUT_DISCONNECT);
2213 message_disconnect_port(portlist, CAUSE_UNSPECIFIED, LOCATION_PRIVATE_LOCAL, "");
2214 set_tone(portlist, "cause_3f");
2215 e_action_timeout = 0;
2216 e_match_timeout = 0;
2220 //PDEBUG(~0, "HANG-BUG-DEBUGGING: before action-timeout processing\n");
2221 /* process timeout */
2222 if (e_action_timeout)
2224 e_action_timeout = 0;
2225 if (e_state == EPOINT_STATE_CONNECT)
2227 PDEBUG(DEBUG_ROUTE|DEBUG_EPOINT, "EPOINT(%d): action timed out, but we already have connected, so we stop timer and continue.\n", ea_endpoint->ep_serial);
2230 if (e_action->index == ACTION_DISCONNECT
2231 || e_state == EPOINT_STATE_OUT_DISCONNECT)
2233 /* release after disconnect */
2234 release(RELEASE_ALL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL);
2237 release(RELEASE_JOIN, LOCATION_PRIVATE_LOCAL, CAUSE_NORMAL, 0, 0);
2238 e_action = e_action->next;
2241 /* nothing more, so we release */
2242 PDEBUG(DEBUG_ROUTE|DEBUG_EPOINT, "EPOINT(%d): action timed out, and we have no next action, so we disconnect.\n", ea_endpoint->ep_serial);
2243 new_state(EPOINT_STATE_OUT_DISCONNECT);
2244 message_disconnect_port(portlist, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL, "");
2245 set_tone(portlist, "cause_3f");
2248 goto action_timeout;
2251 //PDEBUG(~0, "HANG-BUG-DEBUGGING: before setup/overlap state checking\n");
2252 if (e_state!=EPOINT_STATE_IN_SETUP
2253 && e_state!=EPOINT_STATE_IN_OVERLAP)
2255 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);
2256 e_match_timeout = 0;
2261 /* check if we do menu selection */
2262 if (e_action==NUMB_ACTION_NONE && (e_dialinginfo.id[0]=='*' || e_dialinginfo.id[0]=='#'))
2263 /* do menu selection */
2264 if (e_ext.display_menu)
2266 if (portlist->port_type==PORT_TYPE_DSS1_NT_IN || portlist->port_type==PORT_TYPE_DSS1_NT_OUT) /* only if the dialing terminal is an isdn telephone connected to an internal port */
2268 e_dialinginfo.id[0] = '\0';
2269 e_action = NUMB_ACTION_MENU;
2272 e_match_timeout = 0;
2275 /* invalid dialing */
2276 message_disconnect_port(portlist, CAUSE_INCALID, LOCATION_PRIVATE_LOCAL, "");
2277 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_DISCONNECT);
2278 message->param.disconnectinfo.cause = CAUSE_INVALID;
2279 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2282 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
2283 SCPY(message->param.notifyinfo.display,get_isdn_cause(LOCATION_PRIVATE_LOCAL, epoint->e_ext.display_cause, param->disconnectinfo.location, param->disconnectinfo.cause));
2285 message_put(message);
2286 logmessage(message->type, message->param, portlist->port_id, DIRECTION_OUT);
2288 new_state(EPOINT_STATE_OUT_DISCONNECT);
2289 set_tone(portlist,"cause_1c");
2290 e_match_timeout = 0;
2295 //PDEBUG(~0, "HANG-BUG-DEBUGGING: before e_action==NULL\n");
2296 /* if no action yet, we will call try to find a matching rule */
2299 /* be sure that all selectors are initialized */
2302 /* check for external call */
2303 if (!strncmp(e_dialinginfo.id, "extern:", 7))
2305 e_extdialing = e_dialinginfo.id+7;
2306 e_action = &action_external;
2307 goto process_action;
2309 /* check for internal call */
2310 if (!strncmp(e_dialinginfo.id, "intern:", 7))
2312 e_extdialing = e_dialinginfo.id+7;
2313 e_action = &action_internal;
2314 goto process_action;
2316 /* check for chan call */
2317 if (!strncmp(e_dialinginfo.id, "remote:", 7))
2319 e_extdialing = e_dialinginfo.id+7;
2320 e_action = &action_remote;
2321 goto process_action;
2323 /* check for vbox call */
2324 if (!strncmp(e_dialinginfo.id, "vbox:", 5))
2326 e_extdialing = e_dialinginfo.id+5;
2327 e_action = &action_vbox;
2328 goto process_action;
2331 if (e_match_timeout && now_d>=e_match_timeout)
2333 /* return timeout rule */
2334 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal '%s' dialing: '%s', timeout in ruleset '%s'\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id, e_ruleset->name);
2335 e_match_timeout = 0;
2336 e_action = e_match_to_action;
2337 e_extdialing = e_match_to_extdialing;
2338 trace_header("ROUTING (timeout)", DIRECTION_NONE);
2339 add_trace("action", NULL, "%s", action_defs[e_action->index].name);
2340 add_trace("line", NULL, "%d", e_action->line);
2344 //PDEBUG(~0, "HANG-BUG-DEBUGGING: before routing\n");
2345 /* check for matching rule */
2346 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal '%s' dialing: '%s', checking matching rule of ruleset '%s'\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id, e_ruleset->name);
2349 e_action = route(e_ruleset);
2352 trace_header("ACTION (match)", DIRECTION_NONE);
2353 add_trace("action", NULL, "%s", action_defs[e_action->index].name);
2354 add_trace("line", NULL, "%d", e_action->line);
2359 e_action = &action_disconnect;
2362 trace_header("ACTION (no main ruleset, disconnecting)", DIRECTION_NONE);
2366 //PDEBUG(~0, "HANG-BUG-DEBUGGING: after routing\n");
2370 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): no rule within the current ruleset matches yet.\n", ea_endpoint->ep_serial, e_ext.number);
2375 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): a rule with action '%s' matches.\n", ea_endpoint->ep_serial, action_defs[e_action->index].name);
2380 e_action_timeout = 0;
2381 if (e_action->timeout)
2383 e_action_timeout = now_d + e_action->timeout;
2384 PDEBUG(DEBUG_ROUTE|DEBUG_EPOINT, "EPOINT(%d): action has a timeout of %d secods.\n", ea_endpoint->ep_serial, e_action->timeout);
2388 /* check param proceeding / alerting / connect */
2389 if ((rparam = routeparam(e_action, PARAM_CONNECT)))
2391 /* NOTE: we may not change our state to connect, because dialing will then not possible */
2393 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
2394 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
2395 message_put(message);
2396 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2398 if ((rparam = routeparam(e_action, PARAM_ALERTING)))
2400 /* NOTE: we may not change our state to alerting, because dialing will then not possible */
2401 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
2402 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_ALERTING);
2403 message_put(message);
2404 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2406 if ((rparam = routeparam(e_action, PARAM_PROCEEDING)))
2408 /* NOTE: we may not change our state to proceeding, because dialing will then not possible */
2409 memset(&e_connectinfo, 0, sizeof(e_connectinfo));
2410 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_PROCEEDING);
2411 message_put(message);
2412 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2415 if (action_defs[e_action->index].init_func)
2417 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: current action '%s' has a init function, so we call it...\n", ea_endpoint->ep_serial, e_ext.number, action_defs[e_action->index].name);
2418 (this->*(action_defs[e_action->index].init_func))();
2420 if (e_state!=EPOINT_STATE_IN_SETUP
2421 && e_state!=EPOINT_STATE_IN_OVERLAP)
2423 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);
2424 goto display_action;
2428 /* show what we are doing */
2429 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal '%s' action: %s (dialing '%s')\n", ea_endpoint->ep_serial, e_ext.number, action_defs[e_action->index].name, e_extdialing);
2430 /* go to action's dialing function */
2431 if (action_defs[e_action->index].dialing_func)
2433 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: current action '%s' has a dialing function, so we call it...\n", ea_endpoint->ep_serial, e_ext.number, action_defs[e_action->index].name);
2434 (this->*(action_defs[e_action->index].dialing_func))();
2437 /* display selected dialing action if enabled and still in setup state */
2441 if (e_action->index==ACTION_MENU
2442 || e_action->index==ACTION_REDIAL
2443 || e_action->index==ACTION_REPLY
2444 || e_action->index==ACTION_TIMER
2445 || e_action->index==ACTION_CALCULATOR
2446 || e_action->index==ACTION_TEST)
2450 if (!e_ext.display_dialing)
2452 if (e_state==EPOINT_STATE_IN_OVERLAP || e_state==EPOINT_STATE_IN_PROCEEDING || e_state==EPOINT_STATE_IN_ALERTING || e_state==EPOINT_STATE_CONNECT/* || e_state==EPOINT_STATE_IN_DISCONNECT || e_state==EPOINT_STATE_OUT_DISCONNECT*/)
2453 if (portlist->port_type==PORT_TYPE_DSS1_NT_IN || portlist->port_type==PORT_TYPE_DSS1_NT_OUT) /* only if the dialing terminal is an isdn telephone connected to an internal port */
2455 message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
2459 SPRINT(message->param.notifyinfo.display, "> %s", e_dialinginfo.id);
2462 SPRINT(message->param.notifyinfo.display, "%s%s%s", action_defs[e_action->index].name, (e_extdialing[0])?" ":"", e_extdialing);
2465 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s displaying interpreted dialing '%s'\n", ea_endpoint->ep_serial, e_ext.number, message->param.notifyinfo.display);
2466 message_put(message);
2467 logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
2476 /* some services store information after hangup */
2477 void EndpointAppPBX::process_hangup(int cause, int location)
2479 char callertext[256], dialingtext[256];
2480 int writeext = 0, i;
2482 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal '%s'\n", ea_endpoint->ep_serial, e_ext.number);
2483 if (e_ext.number[0])
2485 if (read_extension(&e_ext, e_ext.number))
2495 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): writing connect from %s to %s into logfile of %s\n", ea_endpoint->ep_serial, e_callerinfo.id, e_dialinginfo.id, e_ext.number);
2496 switch(e_dialinginfo.itype)
2498 case INFO_ITYPE_CHAN:
2499 SPRINT(dialingtext, "chan:%s", e_dialinginfo.id);
2501 case INFO_ITYPE_ISDN_EXTENSION:
2502 SPRINT(dialingtext, "intern:%s", e_dialinginfo.id);
2504 case INFO_ITYPE_VBOX:
2505 SPRINT(dialingtext, "vbox:%s", e_dialinginfo.id);
2508 SPRINT(dialingtext, "%s", e_dialinginfo.id);
2511 if (e_callerinfo.id[0])
2512 SPRINT(callertext, "%s", numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype, options.national, options.international));
2514 SPRINT(callertext, "unknown");
2515 /* allpy restriction */
2516 if (!e_ext.anon_ignore && e_callerinfo.present==INFO_PRESENT_RESTRICTED)
2517 SPRINT(callertext, "anonymous");
2518 if (e_callerinfo.extension[0]) /* add intern if present */
2519 UNPRINT(strchr(callertext,'\0'), sizeof(callertext)-1+strlen(callertext), " (intern %s)", e_callerinfo.extension);
2520 write_log(e_ext.number, callertext, dialingtext, e_start, e_stop, 0, cause, location);
2522 /* store last received call for reply-list */
2523 if (e_origin == 1) // outgoing to phone is incoming for user
2524 if (e_callerinfo.id[0] || e_callerinfo.extension[0])
2525 if (e_ext.anon_ignore || e_callerinfo.present!=INFO_PRESENT_RESTRICTED)
2527 if (e_callerinfo.extension[0])
2528 SPRINT(callertext, "intern:%s", e_callerinfo.extension);
2530 SPRINT(callertext, "extern:%s", numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype, options.national, options.international));
2531 if (!!strcmp(callertext, e_ext.last_in[0]))
2536 UCPY(e_ext.last_in[i], e_ext.last_in[i-1]);
2539 SCPY(e_ext.last_in[0], callertext);
2540 writeext |= 1; /* store extension later */
2541 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: storing last received caller id '%s'.\n", ea_endpoint->ep_serial, e_ext.number, e_ext.last_in[0]);
2543 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);
2546 /* store last made call for reply-list */
2547 if (e_origin == 0) // incoming from phone is outgoing for user
2548 if (e_dialinginfo.id[0])
2550 if (!!strcmp(e_dialinginfo.id, e_ext.last_out[0]))
2555 UCPY(e_ext.last_out[i], e_ext.last_out[i-1]);
2558 SCPY(e_ext.last_out[0], e_dialinginfo.id);
2559 writeext |= 1; /* store extension later */
2560 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: storing last number '%s'.\n", ea_endpoint->ep_serial, e_ext.number, e_dialinginfo.id);
2562 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);
2565 /* write extension if needed */
2566 if (writeext == 0x11)
2567 write_extension(&e_ext, e_ext.number);
2571 if (action_defs[e_action->index].hangup_func)
2573 PDEBUG(DEBUG_EPOINT, "EPOINT(%d): terminal %s: current action '%s' has a hangup function, so we call it...\n", ea_endpoint->ep_serial, e_ext.number, action_defs[e_action->index].name);
2574 (this->*(action_defs[e_action->index].hangup_func))();